ECS / ECS_EquipmentMangaSystem_BingChengTaiGuang · Files

using HHECS.Application.Service;
using HHECS.Dal.Repository;
using HHECS.Executor.EquipmentHandler.SRMV4;
using HHECS.Model.Entities;
using HHECS.Model.Enums;
using HHECS.Web.Models;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Drawing;
using System.Linq;

namespace HHECS.Web.Areas.Dashboard.Controllers
{
    /// <summary>
    /// 设备运行监控页
    /// </summary>
    [Area("Dashboard")]
    public class MonitorController : BaseController
    {
        private readonly EquipmentService _equipmentService;
        private readonly EquipmentStatusRecordService _statusRecordService;

        public MonitorController(EquipmentService equipmentService, EquipmentStatusRecordService statusRecordService)
        {
            _equipmentService = equipmentService;
            _statusRecordService = statusRecordService;
        }

        [ServiceFilter(typeof(OperLogFilter))]
        public IActionResult Index()
        {
            return View();
        }

        [HttpPost]
        public string Load(PageReq pageRequest, Equipment entity)
        {
            return _equipmentService.LoadEquipmentAndStatus(entity, pageRequest.page, pageRequest.limit);
        }

        /// <summary>
        /// 详情页
        /// </summary>
        /// <param name="id">设备Id</param>
        /// <returns></returns>
        public IActionResult Detail(int id)
        {
            var equipment = _equipmentService.GetEquipment(x => x.Id.Equals(id)).Data;
            if (equipment == null)
            {
                return Redirect("/Error");
            }
            ViewBag.Id = equipment.Id;

            #region 固定属性赋值

            #region 通用属性

            //操作模式
            var OperationModelProp = equipment[$"{SRMProps.OperationModel}"]?.Value;
            if (Enum.TryParse<SRMOperationModel>(OperationModelProp, out SRMOperationModel operationModel))
            {
                ViewBag.EquipmentOperationModel = operationModel.ToDescriptionOrString();
            }
            else
            {
                ViewBag.EquipmentOperationModel = "未获取";
            }

            //水平测距
            var HorizontalDistanceProp = equipment[$"{SRMProps.HorizontalDistance}"]?.Value;
            if (!string.IsNullOrWhiteSpace(HorizontalDistanceProp))
            {
                ViewBag.EquipmentHorizontalDistance = HorizontalDistanceProp;
            }
            else
            {
                ViewBag.EquipmentHorizontalDistance = "未获取";
            }

            //升降测距
            var VerticalDistanceProp = equipment[$"{SRMProps.VerticalDistance}"]?.Value;
            if (!string.IsNullOrWhiteSpace(VerticalDistanceProp))
            {
                ViewBag.EquipmentVerticalDistance = VerticalDistanceProp;
            }
            else
            {
                ViewBag.EquipmentVerticalDistance = "未获取";
            }

            //扩展模式
            var ExpendModeProp = equipment[$"{SRMProps.ExpendMode}"]?.Value;
            switch (ExpendModeProp)
            {
                case "True":
                    ViewBag.EquipmentExpendMode = "转轨";
                    break;
                case "False":
                    ViewBag.EquipmentExpendMode = "正常";
                    break;
                default:
                    ViewBag.EquipmentExpendMode = "未获取";
                    break;
            }

            //最小列
            var ManageSmallColumnProp = equipment[$"{SRMProps.ManageSmallColumn}"]?.Value;
            if (!string.IsNullOrWhiteSpace(ManageSmallColumnProp))
            {
                ViewBag.EquipmentManageSmallColumn = ManageSmallColumnProp;
            }
            else
            {
                ViewBag.EquipmentManageSmallColumn = "未获取";
            }

            //最大列
            var ManageMaxColumnProp = equipment[$"{SRMProps.ManageMaxColumn}"]?.Value;
            if (!string.IsNullOrWhiteSpace(ManageMaxColumnProp))
            {
                ViewBag.EquipmentManageMaxColumn = ManageMaxColumnProp;
            }
            else
            {
                ViewBag.EquipmentManageMaxColumn = "未获取";
            }

            //货叉标志
            var WCSForkFlagProp = equipment[$"{SRMProps.WCSForkFlag}"]?.Value;
            if (Enum.TryParse<SRMForkFlag>(WCSForkFlagProp, out SRMForkFlag forkFlag))
            {
                ViewBag.EquipmentWCSForkFlag = forkFlag.ToDescriptionOrString();
            }
            else
            {
                ViewBag.EquipmentWCSForkFlag = "未获取";
            }

            //堆垛机总故障
            var TotalErrorProp = equipment[$"{SRMProps.TotalError}"]?.Value;
            switch (TotalErrorProp)
            {
                case "True":
                    ViewBag.EquipmentTotalError = "故障";
                    break;
                case "False":
                    ViewBag.EquipmentTotalError = "无故障";
                    break;
                default:
                    ViewBag.EquipmentTotalError = "未获取";
                    break;
            }

            #endregion

            #region 货叉1PLC属性

            //货叉测距
            var Fork1DistanceProp = equipment[$"{SRMProps.Fork1Distance}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1DistanceProp))
            {
                ViewBag.EquipmentFork1Distance = Fork1DistanceProp;
            }
            else
            {
                ViewBag.EquipmentFork1Distance = "未获取";
            }

            //有无货
            var Fork1HasPalletProp = equipment[$"{SRMProps.Fork1HasPallet}"]?.Value;
            switch (Fork1HasPalletProp)
            {
                case "True":
                    ViewBag.EquipmentFork1HasPallet = "有货";
                    break;
                case "False":
                    ViewBag.EquipmentFork1HasPallet = "无货";
                    break;
                default:
                    ViewBag.EquipmentFork1HasPallet = "未获取";
                    break;
            }

            //是否在中心
            var Fork1CenterProp = equipment[$"{SRMProps.Fork1Center}"]?.Value;
            switch (Fork1CenterProp)
            {
                case "True":
                    ViewBag.EquipmentFork1Center = "在中心";
                    break;
                case "False":
                    ViewBag.EquipmentFork1Center = "不在中心";
                    break;
                default:
                    ViewBag.EquipmentFork1Center = "未获取";
                    break;
            }

            //排
            var Fork1ZPositionProp = equipment[$"{SRMProps.Fork1ZPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1ZPositionProp))
            {
                ViewBag.EquipmentFork1ZPosition = Fork1ZPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1ZPosition = "未获取";
            }

            //列
            var Fork1XPositionProp = equipment[$"{SRMProps.Fork1XPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1XPositionProp))
            {
                ViewBag.EquipmentFork1XPosition = Fork1XPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1XPosition = "未获取";
            }

            //层
            var Fork1YPositionProp = equipment[$"{SRMProps.Fork1YPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1YPositionProp))
            {
                ViewBag.EquipmentFork1YPosition = Fork1YPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1YPosition = "未获取";
            }

            //任务执行状态
            var Fork1TaskExcuteStatusProp = equipment[$"{SRMProps.Fork1TaskExcuteStatus}"]?.Value;
            if (Enum.TryParse<SRMTaskExcuteStatus>(Fork1TaskExcuteStatusProp, out SRMTaskExcuteStatus fork1TaskExcuteStatus))
            {
                ViewBag.EquipmentFork1TaskExcuteStatus = fork1TaskExcuteStatus.ToDescriptionOrString();
            }
            else
            {
                ViewBag.EquipmentFork1TaskExcuteStatus = "未获取";
            }

            //任务类型
            var Fork1TaskTypeProp = equipment[$"{SRMProps.Fork1TaskType}"]?.Value;
            if (Enum.TryParse<SRMForkAction>(Fork1TaskTypeProp, out SRMForkAction fork1TaskType))
            {
                ViewBag.EquipmentFork1TaskType = fork1TaskType.ToDescriptionOrString();
            }
            else
            {
                ViewBag.EquipmentFork1TaskType = "未获取";
            }

            //任务号
            var Fork1TaskNoProp = equipment[$"{SRMProps.Fork1TaskNo}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1TaskNoProp))
            {
                ViewBag.EquipmentFork1TaskNo = Fork1TaskNoProp;
            }
            else
            {
                ViewBag.EquipmentFork1TaskNo = "未获取";
            }

            //取货排
            var Fork1PickZPositionProp = equipment[$"{SRMProps.Fork1PickZPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1PickZPositionProp))
            {
                ViewBag.EquipmentFork1PickZPosition = Fork1PickZPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1PickZPosition = "未获取";
            }

            //取货列
            var Fork1PickXPositionProp = equipment[$"{SRMProps.Fork1PickXPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1PickXPositionProp))
            {
                ViewBag.EquipmentFork1PickXPosition = Fork1PickXPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1PickXPosition = "未获取";
            }

            //取货层
            var Fork1PickYPositionProp = equipment[$"{SRMProps.Fork1PickYPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1PickYPositionProp))
            {
                ViewBag.EquipmentFork1PickYPosition = Fork1PickYPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1PickYPosition = "未获取";
            }

            //放货排
            var Fork1PutZPositionProp = equipment[$"{SRMProps.Fork1PutZPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1PutZPositionProp))
            {
                ViewBag.EquipmentFork1PutZPosition = Fork1PutZPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1PutZPosition = "未获取";
            }

            //放货列
            var Fork1PutXPositionProp = equipment[$"{SRMProps.Fork1PutXPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1PutXPositionProp))
            {
                ViewBag.EquipmentFork1PutXPosition = Fork1PutXPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1PutXPosition = "未获取";
            }

            //放货层
            var Fork1PutYPositionProp = equipment[$"{SRMProps.Fork1PutYPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1PutYPositionProp))
            {
                ViewBag.EquipmentFork1PutYPosition = Fork1PutYPositionProp;
            }
            else
            {
                ViewBag.EquipmentFork1PutYPosition = "未获取";
            }

            //货叉1总故障
            var Fork1TotalErrorProp = equipment[$"{SRMProps.Fork1TotalError}"]?.Value;
            switch (Fork1TotalErrorProp)
            {
                case "True":
                    ViewBag.EquipmentFork1TotalError = "故障";
                    break;
                case "False":
                    ViewBag.EquipmentFork1TotalError = "无故障";
                    break;
                default:
                    ViewBag.EquipmentFork1TotalError = "未获取";
                    break;
            }

            //货叉1屏蔽
            var Fork1BlockProp = equipment[$"{SRMProps.Fork1Block}"]?.Value;
            switch (Fork1BlockProp)
            {
                case "True":
                    ViewBag.EquipmentFork1Block = "屏蔽";
                    break;
                case "False":
                    ViewBag.EquipmentFork1Block = "未屏蔽";
                    break;
                default:
                    ViewBag.EquipmentFork1Block = "未获取";
                    break;
            }

            #endregion

            #region 货叉1WCS属性

            //动作类型 -- 即任务类型
            var WCSFork1ActionProp = equipment[$"{SRMProps.WCSFork1Action}"]?.Value;
            if (Enum.TryParse<SRMForkAction>(WCSFork1ActionProp, out SRMForkAction wcsFork1Action))
            {
                ViewBag.EquipmentWCSFork1Action = wcsFork1Action.ToDescriptionOrString();
            }
            else
            {
                ViewBag.EquipmentWCSFork1Action = "未获取";
            }

            //叠盘索引
            var WCSFork1FoldIndexProp = equipment[$"{SRMProps.WCSFork1FoldIndex}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1FoldIndexProp))
            {
                ViewBag.EquipmentWCSFork1FoldIndex = WCSFork1FoldIndexProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1FoldIndex = "未获取";
            }

            //任务号
            var WCSFork1TaskNoProp = equipment[$"{SRMProps.WCSFork1TaskNo}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1TaskNoProp))
            {
                ViewBag.EquipmentWCSFork1TaskNo = WCSFork1TaskNoProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1TaskNo = "未获取";
            }

            //取货排
            var WCSFork1PickZPositionProp = equipment[$"{SRMProps.WCSFork1PickZPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1PickZPositionProp))
            {
                ViewBag.EquipmentWCSFork1PickZPosition = WCSFork1PickZPositionProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1PickZPosition = "未获取";
            }

            //取货列
            var WCSFork1PickXPositionProp = equipment[$"{SRMProps.WCSFork1PickXPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1PickXPositionProp))
            {
                ViewBag.EquipmentWCSFork1PickXPosition = WCSFork1PickXPositionProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1PickXPosition = "未获取";
            }

            //取货层
            var WCSFork1PickYPositionProp = equipment[$"{SRMProps.WCSFork1PickYPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1PickYPositionProp))
            {
                ViewBag.EquipmentWCSFork1PickYPosition = WCSFork1PickYPositionProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1PickYPosition = "未获取";
            }

            //放货排
            var WCSFork1PutZPositionProp = equipment[$"{SRMProps.WCSFork1PutZPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1PutZPositionProp))
            {
                ViewBag.EquipmentWCSFork1PutZPosition = WCSFork1PutZPositionProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1PutZPosition = "未获取";
            }

            //放货列
            var WCSFork1PutXPositionProp = equipment[$"{SRMProps.WCSFork1PutXPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1PutXPositionProp))
            {
                ViewBag.EquipmentWCSFork1PutXPosition = WCSFork1PutXPositionProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1PutXPosition = "未获取";
            }

            //放货层
            var WCSFork1PutYPositionProp = equipment[$"{SRMProps.WCSFork1PutYPosition}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1PutYPositionProp))
            {
                ViewBag.EquipmentWCSFork1PutYPosition = WCSFork1PutYPositionProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1PutYPosition = "未获取";
            }

            #endregion

            #region 货叉1PLC货物属性

            //货叉1货物长度
            var Fork1GoodsLengthProp = equipment[$"{SRMProps.Fork1GoodsLength}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1GoodsLengthProp))
            {
                ViewBag.EquipmentFork1GoodsLength = Fork1GoodsLengthProp;
            }
            else
            {
                ViewBag.EquipmentFork1GoodsLength = "未获取";
            }

            //货叉1货物宽度
            var Fork1GoodsWidthProp = equipment[$"{SRMProps.Fork1GoodsWidth}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1GoodsWidthProp))
            {
                ViewBag.EquipmentFork1GoodsWidth = Fork1GoodsWidthProp;
            }
            else
            {
                ViewBag.EquipmentFork1GoodsWidth = "未获取";
            }

            //货叉1货物高度
            var Fork1GoodsHeightProp = equipment[$"{SRMProps.Fork1GoodsHeight}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1GoodsHeightProp))
            {
                ViewBag.EquipmentFork1GoodsHeight = Fork1GoodsHeightProp;
            }
            else
            {
                ViewBag.EquipmentFork1GoodsHeight = "未获取";
            }

            //货叉1货物重量
            var Fork1GoodsWeightProp = equipment[$"{SRMProps.Fork1GoodsWeight}"]?.Value;
            if (!string.IsNullOrWhiteSpace(Fork1GoodsWeightProp))
            {
                ViewBag.EquipmentFork1GoodsWeight = Fork1GoodsWeightProp;
            }
            else
            {
                ViewBag.EquipmentFork1GoodsWeight = "未获取";
            }

            //货叉1货物条码
            ViewBag.EquipmentFork1GoodsBarcode = equipment[$"{SRMProps.Fork1GoodsBarcode}"]?.Value;

            #endregion

            #region 货叉1WCS货物属性

            //货叉1货物长度
            var WCSFork1GoodsLengthProp = equipment[$"{SRMProps.WCSFork1GoodsLength}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1GoodsLengthProp))
            {
                ViewBag.EquipmentWCSFork1GoodsLength = WCSFork1GoodsLengthProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1GoodsLength = "未获取";
            }

            //货叉1货物宽度
            var WCSFork1GoodsWidthProp = equipment[$"{SRMProps.WCSFork1GoodsWidth}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1GoodsWidthProp))
            {
                ViewBag.EquipmentWCSFork1GoodsWidth = WCSFork1GoodsWidthProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1GoodsWidth = "未获取";
            }

            //货叉1货物高度
            var WCSFork1GoodsHeightProp = equipment[$"{SRMProps.WCSFork1GoodsHeight}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1GoodsHeightProp))
            {
                ViewBag.EquipmentWCSFork1GoodsHeight = WCSFork1GoodsHeightProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1GoodsHeight = "未获取";
            }

            //货叉1货物重量
            var WCSFork1GoodsWeightProp = equipment[$"{SRMProps.WCSFork1GoodsWeight}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1GoodsWeightProp))
            {
                ViewBag.EquipmentWCSFork1GoodsWeight = WCSFork1GoodsWeightProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1GoodsWeight = "未获取";
            }

            //货叉1货物类型
            var WCSFork1GoodsTypeProp = equipment[$"{SRMProps.WCSFork1GoodsType}"]?.Value;
            if (!string.IsNullOrWhiteSpace(WCSFork1GoodsTypeProp))
            {
                ViewBag.EquipmentWCSFork1GoodsType = WCSFork1GoodsTypeProp;
            }
            else
            {
                ViewBag.EquipmentWCSFork1GoodsType = "未获取";
            }

            //货叉1货物条码
            ViewBag.EquipmentWCSFork1GoodsBarcode = equipment[$"{SRMProps.WCSFork1GoodsBarcode}"]?.Value;

            #endregion

            #endregion

            return View();
        }

        /// <summary>
        /// 获取设备信息
        /// </summary>
        /// <param name="id">设备ID</param>
        /// <returns></returns>
        public IActionResult GetResult(int id)
        {
            try
            {
                var equipment = _equipmentService.GetEquipment(x => x.Id.Equals(id)).Data;
                if (equipment == null)
                {
                    return NotFound();
                }
                using var alarmRecordRepository = new EquipmentAlarmRecordRepository();
                using var maintainRecordRepository = new EquipmentMaintainRecordRepository();
                var alarmRecord = alarmRecordRepository.Where(x => x.EquipmentCode.Equals(equipment.Code) && !x.IsEnd).ToList();
                var equipmentStatusRecord = _statusRecordService.GetEquipmentStatusByCode(equipment.Code);
                var allStatus = _statusRecordService.GetEquipmentHistoryStatusByCode(equipment.Code);
                var maintainRecord = maintainRecordRepository.Where(x => x.EquipmentCode.Equals(equipment.Code)).OrderBy(x => x.Status).First();
                _ = Enum.TryParse(equipmentStatusRecord?.EquipmentStatus, out EquipmentStatusRecordStatus equipmentStatus);
                var result = new MonitorViewModel
                {
                    Equipment = equipment,
                    AlarmMsg = alarmRecord.Select(x => $"{x.Created}：{x.Alarm}").ToList(),
                    EquipmentStatus = equipmentStatusRecord == null ? -1 : Convert.ToInt32(equipmentStatus),
                    MaintainStatus = (EquipmentMaintainStatus)maintainRecord.Status,
                    RunTotal = allStatus.Count(x => x.EquipmentStatus == EquipmentStatusRecordStatus.Running.ToString()),
                    ErrorTotal = allStatus.Count(x => x.EquipmentStatus == EquipmentStatusRecordStatus.Error.ToString()),
                    FreeTotal = allStatus.Count(x => x.EquipmentStatus == EquipmentStatusRecordStatus.Free.ToString()),
                };
                return Ok(result);
            }
            catch (Exception ex)
            {
                return Ok(new
                {
                    code = 200,
                    count = 0,
                    data = string.Empty,
                    msg = ex.Message
                });
            }
        }
    }
}