MES / DataAcquisition · Files

using HHECS.BllModel;
using HHECS.DAQServer.DataFlag;
using HHECS.DAQServer.Dto.Equipment;
using HHECS.DAQServer.Services;
using HHECS.DAQShared.Common.Enums;
using HHECS.DAQShared.Dto;
using HHECS.DAQShared.Models;
using Microsoft.AspNetCore.Mvc;

namespace HHECS.DAQServer.Controllers
{
    /// <summary>
    /// 设备数据
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class EquipmentController : ControllerBase
    {
        private readonly IFreeSql<IOTCloundFlag> _iotCloundFreeSql;
        private readonly EquipmentService _equipmentService;

        public EquipmentController(IFreeSql<IOTCloundFlag> iotCloundFreeSql, EquipmentService equipmentService)
        {
            _iotCloundFreeSql = iotCloundFreeSql;
            _equipmentService = equipmentService;
        }

        /// <summary>
        /// 推送设备实时数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> SendEquipmentData(IEnumerable<EquipmentDataDto> data)
        {
            return await _equipmentService.SendEquipmentData(data);
        }

        /// <summary>
        /// 推送某段时间的设备数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> SendEquipmentDataV2(IEnumerable<EquipmentDataV2Dto> data)
        {
            return await _equipmentService.SendEquipmentDataV2(data);
        }

        /// <summary>
        /// 推送设备任务完成数
        /// </summary>
        /// <param name="taskInfos"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> EquipmentTask(List<EquipmentTaskDto> taskInfos)
        {
            try
            {
                if (taskInfos.Count == 0)
                {
                    return BllResultFactory.Error($"数据不能为空！");
                }

                var equipmentCodes = taskInfos.Select(x => x.EquipmentCode).Distinct().ToList();
                var equipments = await _iotCloundFreeSql.Queryable<Equipment>().Where(x => equipmentCodes.Contains(x.Code)).ToListAsync(x => new Equipment
                {
                    Code = x.Code,
                    Name = x.Name,
                    EquipmentTypeId = x.EquipmentTypeId,
                    FactoryCode = x.FactoryCode,
                    ProjectCode = x.ProjectCode,
                });

                if (equipmentCodes.Count != equipments.Count)
                {
                    var temps = equipmentCodes.Except(equipments.Select(x => x.Code));
                    return BllResultFactory.Error($"设备编码[{string.Join(',', temps)}]不存在，请检查数据并重试！");
                }

                var equipmentTypeIds = equipments.Select(x => x.EquipmentTypeId).Distinct().ToList();
                var equipmentTypes = _iotCloundFreeSql.Queryable<EquipmentType>().Where(x => equipmentTypeIds.Contains(x.Id)).ToList(x => new EquipmentType
                {
                    Id = x.Id,
                    Code = x.Code,
                });

                using var equipmentTaskRepository = _iotCloundFreeSql.GetRepository<EquipmentTaskInfo>();
                var addTemps = new List<EquipmentTaskInfo>();
                var updateTemps = new List<EquipmentTaskInfo>();
                foreach (var item in taskInfos)
                {
                    var record = equipmentTaskRepository.Where(x => x.EquipmentCode == item.EquipmentCode && x.Created.Value.Date == item.DateTime.Date).First();
                    //更新
                    if (record != null)
                    {
                        equipmentTaskRepository.Attach(record);
                        record.TotalTask = item.TotalTask;
                        record.Updated = item.DateTime;
                        updateTemps.Add(record);
                        continue;
                    }
                    //新增
                    var currentEquipment = equipments.Where(x => x.Code == item.EquipmentCode).First();
                    var currentEquipmentTypeCode = equipmentTypes.Where(x => x.Id == currentEquipment.EquipmentTypeId).Select(x => x.Code).FirstOrDefault();
                    addTemps.Add(new EquipmentTaskInfo
                    {
                        EquipmentCode = currentEquipment.Code,
                        EquipmentName = currentEquipment.Name,
                        EquipmentTypeCode = currentEquipmentTypeCode,
                        ProjectCode = currentEquipment.ProjectCode,
                        FactoryCode = currentEquipment.FactoryCode,
                        TotalTask = item.TotalTask,
                        Created = item.DateTime,
                    });
                }

                var updateTotal = equipmentTaskRepository.Update(updateTemps);
                var addTotal = equipmentTaskRepository.Insert(addTemps);
                return BllResultFactory.Success($"操作成功，新增{addTotal.Count}条记录，更新{updateTotal}条记录");
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"程序异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 更新客户端在线状态
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> UpdateClientStatus(ClientStatusDto data)
        {
            return await _equipmentService.UpdateClientStatus(data.ClientId);
        }

        /// <summary>
        /// 更新AGV点位信息
        /// </summary>
        /// <param name="agvPoints"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> UpdateAGVPoint(List<AGVPointDto> agvPoints)
        {
            try
            {
                if (agvPoints.Count == 0)
                {
                    return BllResultFactory.Error($"数据不能为空！");
                }

                if (agvPoints.Where(x => string.IsNullOrWhiteSpace(x.EquipmentSN)).Any())
                {
                    return BllResultFactory.Error($"EquipmentSN数据不能为空");
                }

                var equipmentSNs = agvPoints.Select(x => x.EquipmentSN).ToList();
                var equipments = await _iotCloundFreeSql.Queryable<Equipment>().Where(x => equipmentSNs.Contains(x.Code)).ToListAsync(x => new Equipment
                {
                    Id = x.Id,
                    Code = x.Code,
                    ProjectCode = x.ProjectCode,
                    FactoryCode = x.FactoryCode,
                });

                var temp = equipmentSNs.Except(equipments.Select(x => x.Code)).Distinct();
                if (temp.Any())
                {
                    var str = string.Join(',', temp);
                    return BllResultFactory.Error($"设备SN[{str}]在系统中不存在，请检测数据是否正确，或联系管理员获取！");
                }

                var allPoints = _iotCloundFreeSql.Queryable<AGVPoint>().Where(x => equipmentSNs.Contains(x.EquipmentCode)).ToList();

                foreach (var item in agvPoints)
                {
                    //数据库现有数据
                    var points = allPoints.Where(x => x.EquipmentCode == item.EquipmentSN).ToList();
                    var oldBarCodes = points.Select(x => x.BarCode).ToList();
                    var newBarCodes = item.BarCodes;

                    var currentEquipment = equipments.Where(x => x.Code == item.EquipmentSN).FirstOrDefault();
                    if (currentEquipment == null)
                    {
                        return BllResultFactory.Error($"设备SN“{item.EquipmentSN}”不存在，请检查数据是否正确，或联系管理员处理!");
                    }

                    if (string.IsNullOrWhiteSpace(currentEquipment.ProjectCode))
                    {
                        return BllResultFactory.Error($"{nameof(item.EquipmentSN)}的“{nameof(currentEquipment.ProjectCode)}”字段数据未配置，请联系管理员处理！");
                    }

                    if (string.IsNullOrWhiteSpace(currentEquipment.FactoryCode))
                    {
                        return BllResultFactory.Error($"{nameof(item.EquipmentSN)}为的“{nameof(currentEquipment.FactoryCode)}”字段数据未配置，请联系管理员处理！");
                    }

                    var addTemps = newBarCodes.Except(oldBarCodes);
                    var removeTemps = oldBarCodes.Except(newBarCodes);

                    _iotCloundFreeSql.Delete<AGVPoint>().Where(x => x.EquipmentCode == item.EquipmentSN && removeTemps.Contains(x.BarCode)).ExecuteAffrows();
                    var temps = addTemps.Select(x => new AGVPoint
                    {
                        EquipmentCode = currentEquipment.Code,
                        BarCode = x,
                        ProjectCode = currentEquipment.ProjectCode,
                        FactoryCode = currentEquipment.FactoryCode,
                        Created = DateTime.Now
                    }).ToList();
                    _iotCloundFreeSql.Insert(temps).ExecuteAffrows();
                }

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        /// <summary>
        /// 获取客户端设备数据
        /// </summary>
        /// <param name="clientId"></param>
        /// <remarks>用于客户端主动同步数据使用</remarks>
        /// <returns></returns>
        [HttpGet]
        public BllResult<List<EquipmentType>> GetClientEquipmentData(Guid clientId)
        {
            try
            {
                var client = _iotCloundFreeSql.Queryable<ClientConfig>().Where(x => x.Id == clientId).First();
                if (client == null)
                {
                    return BllResultFactory.Error<List<EquipmentType>>($"未找到ClientId“{clientId}”的客户端信息！");
                }

                if (string.IsNullOrWhiteSpace(client.ProjectCode))
                {
                    return BllResultFactory.Error<List<EquipmentType>>($"未配置客户端“{clientId}”的项目编号！");
                }

                //需过滤的设备类型
                var filterEquipmentTypeCodes = new List<EquipmentTypeConst>
                {
                    EquipmentTypeConst.WeldRobot,
                    EquipmentTypeConst.WeldRobotV2,
                    EquipmentTypeConst.AGVForklift,
                }.Select(x => x.ToString()).ToList();

                var filterEquipmentTypeIds = _iotCloundFreeSql.Queryable<EquipmentType>().Where(x => filterEquipmentTypeCodes.Contains(x.Code)).ToList(x => x.Id);
                var equipments = _iotCloundFreeSql.Queryable<Equipment>().Where(x => x.ProjectCode == client.ProjectCode && !filterEquipmentTypeIds.Contains(x.EquipmentTypeId)).IncludeMany(x => x.EquipmentProps).ToList();
                var equipmentTypeIds = equipments.Select(x => x.EquipmentTypeId).Distinct().ToList();
                var equipmentTypes = _iotCloundFreeSql.Queryable<EquipmentType>().Where(x => equipmentTypeIds.Contains(x.Id)).IncludeMany(x => x.EquipmentTypePropTemplates).ToList();
                foreach (var equipmentType in equipmentTypes)
                {
                    equipmentType.Equipments = equipments.Where(x => x.EquipmentTypeId == equipmentType.Id).ToList();
                }
                return BllResultFactory.Success(equipmentTypes);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<EquipmentType>>(ex.Message);
            }
        }

        /// <summary>
        /// 推送日志
        /// </summary>
        /// <param name="softLog"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> SendClientLog(SoftLogDto softLog)
        {
            return await _equipmentService.SendClientLog(softLog);
        }
    }
}