MES / IOT · Files

using Hh.Mes.Common.log;
using Hh.Mes.Common.Request;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.Response;
using Hh.Mes.Service.Repository;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Hh.Mes.Pojo.System;
using System.Text;

namespace Hh.Mes.Service.Equipment
{
    public class DaqEquipmentAlarmRecordService : RepositorySqlSugar<daq_equipment_alarm_record>
    {
        public dynamic Load(PageReq pageReq, daq_equipment_alarm_record model)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                string orderBy = " counts desc  ";
                var stringBuilder = new StringBuilder();
                var sqlWhere = LoadSqlWhere(model);
                //页码，页数
                //Exel ture 不分页
                if (!model.Exel && pageReq != null)
                {
                    stringBuilder.Append("declare @pageIndex int,@pageSize int,@offset int");
                    stringBuilder.AppendLine($"  select @pageIndex={pageReq.page}, @pageSize={pageReq.limit}, @offset=(@pageIndex - 1) * @pageSize");
                }
                string sql = $@"select  t1.EquipmentCode, t1.EquipmentName, projectName='{model.projectName}',
                                        counts=count(*) 
                                        from {nameof(daq_equipment_alarm_record)} t1 with(nolock) 
                                        where {sqlWhere}
                                        group by t1.ProjectCode, t1.EquipmentCode,t1.EquipmentName";

                stringBuilder.AppendLine(sql + $@" order by {orderBy} ");

                //Exel ture 不分页
                if (!model.Exel)
                {
                    stringBuilder.AppendLine("  offset @offset row fetch next @pageSize row only ");
                    stringBuilder.Append($@" select rowTotal= count(*) from ({sql})t ");
                }
                var ds = base.Context.Ado.GetDataSetAll(stringBuilder.ToString(), new List<SugarParameter>()
                {
                    new SugarParameter("@projectKeys", model.projectKeys),
                    new SugarParameter("@equipmentCode", $"%{model.equipmentCode}%"),
                    new SugarParameter("@equipmentName", $"%{model.equipmentName}%"),
                    new SugarParameter("@projectCode", model.ProjectCode),
                });
                result.Result = ds.Tables[0];
                result.Count = model.Exel ? (int)result.Result.Rows.Count : (int)ds.Tables[1].Rows[0]["rowTotal"];
                return result;
            }, catchRetrunValue: "list");
        }


        public string LoadSqlWhere(daq_equipment_alarm_record model)
        {
            var stringBuilder = new StringBuilder();
            stringBuilder.AppendLine($@" t1.EquipmentTypeCode not in('{SystemVariable.IotNotContainDevice}') ");
            if (!string.IsNullOrEmpty(model.equipmentCode)) stringBuilder.AppendLine(" and  t1.equipmentCode  like @equipmentCode ");
            if (!string.IsNullOrEmpty(model.equipmentName)) stringBuilder.AppendLine(" and  t1.equipmentName  like @equipmentName ");
            if (!string.IsNullOrEmpty(model.ProjectCode)) stringBuilder.AppendLine(" and  t1.projectCode =@projectCode ");
            stringBuilder.AppendLine(" and  t1.IsHandled =0 ");
            return stringBuilder.ToString();
        }

        public dynamic LoadDesc(PageReq pageReq, daq_equipment_alarm_record entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var expression = LinqWhere(entity);
                //先组合查询表达式(多表查询查看IOT 设备列表案例)
                var query = Context.Queryable<daq_equipment_alarm_record>().Where(expression)
                                                                           .OrderBy(x => x.equipmentCode, OrderByType.Asc)
                                                                           .OrderBy(x => x.createTime, OrderByType.Desc);
                //Exel false 分页
                if (!entity.Exel)
                {
                    int total = 0;
                    result.Result = query.ToOffsetPage(pageReq.page, pageReq.limit, ref total);
                    result.Count = total;
                }
                else
                {
                    result.Result = query.ToList();
                    result.Count = result.Result.Count;
                }
                return result;
            }, catchRetrunValue: "list");
        }

        /// <summary>
        /// /左侧列表 设备类型+设备
        /// </summary>
        public dynamic GetTreeList()
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var stringBuilder = new StringBuilder();
                string equipmentTypeCodes = string.Join("', '", SystemVariable.IotNotContainDevice);
                string user = sysWebUser.Account;

                var nodes = new List<dynamic>();

                var rootNode = new
                {
                    id = Guid.NewGuid(),
                    name = "根节点",
                    keys = "r-1",
                    parentId = "0",
                    isok = false,
                    projectKeys = Guid.Empty,
                };

                var data = Context.Queryable<base_project>().Where(GetExpression(user)).Select(x => new
                {
                    id = x.keys,
                    name = x.projectName,
                    keys = x.projectCode,
                    parentId = rootNode.keys,
                    isok = true,
                    projectKeys = x.keys
                }).ToList();

                nodes.Add(rootNode);
                nodes.AddRange(data);
                return nodes;
            });

        }

        private Expression<Func<base_project, bool>> GetExpression(string user)
        {
            var exp = Expressionable.Create<base_project>();
            //非管理员，查询登陆用户绑定客户管理的项目
            if (user != SystemVariable.DefaultCreated)
            {
                var projectRoleKeys = GetProjectRoleKeys(user);
                exp.And(x => SqlFunc.Subqueryable<sys_role_projects_rel>().Where(c => projectRoleKeys.Contains(c.project_roles_key) && c.project_key == x.keys).Any());
            }
            return exp.ToExpression();//拼接表达式
        }

        public dynamic Ins(daq_equipment_alarm_record entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                //entity.createBy = sysWebUser?.Account;
                //entity.createTime = DateTime.Now;
                response.Status = Add(entity);
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public dynamic Upd(daq_equipment_alarm_record entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                //entity.updateBy = sysWebUser?.Account;
                //entity.updateTime = DateTime.Now;
                response.Status = Update(entity);
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public dynamic DelByIds(Guid[] ids)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                Context.Deleteable<daq_equipment_alarm_record>(t => ids.Contains(t.id)).ExecuteCommand();
                return response;
            });
        }

        public Response ExportData(daq_equipment_alarm_record entity)
        {
            var response = new Response();
            if (entity.ProjectCode == "r-1")
            {
                entity.ProjectCode = null;
            }
            var sheet1 = Load(null, entity);
            entity.isHandled = false;
            var sheet2 = LoadDesc(null, entity);
            //返回异常数据报错，传空数组给前端
            response.Result = new
            {
                head = sheet1 is string ? "[]" : sheet1.Result,
                body = sheet2 is string ? "[]" : sheet2.Result
            };
            return response;
        }

        public Expression<Func<daq_equipment_alarm_record, bool>> LinqWhere(daq_equipment_alarm_record model)
        {
            try
            {
                var exp = Expressionable.Create<daq_equipment_alarm_record>();
                //数据过滤条件
                //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
                if (!string.IsNullOrWhiteSpace(model.ProjectCode))
                {
                    exp.And(x => x.ProjectCode.Contains(model.ProjectCode));
                }
                if (!string.IsNullOrWhiteSpace(model.equipmentCode))
                {
                    exp.And(x => x.equipmentCode == model.equipmentCode);
                }
                if (!string.IsNullOrWhiteSpace(model.equipmentName))
                {
                    exp.And(x => x.equipmentName.Contains(model.equipmentName));
                }
                if (!string.IsNullOrWhiteSpace(model.Tag))
                {
                    exp.And(x => x.Tag.Contains(model.Tag));
                }
                if (!string.IsNullOrWhiteSpace(model.alarmMessage))
                {
                    exp.And(x => x.alarmMessage.Contains(model.alarmMessage));
                }
                if (model.createTime != default && model.updateTime != null)
                {
                    exp.And(x => x.createTime >= model.createTime && x.createTime <= model.updateTime);
                }
                if (model.createTime != default && model.updateTime == null)
                {
                    exp.And(x => x.createTime >= model.createTime);
                }

                if (model.updateTime != null && model.createTime == default)
                {
                    exp.And(x => x.createTime <= model.updateTime);
                }

                if (model.isHandled != default)
                {
                    exp.And(x => x.isHandled == model.isHandled);
                }
                if (model.id != Guid.Empty)
                {
                    exp.And(x => x.id == model.id);
                }
                // exp.And(x => !SystemVariable.IotNotContainDevice.Contains(x.EquipmentTypeCode));
                return exp.ToExpression();//拼接表达式
            }
            catch (Exception ex)
            {
                throw new Exception($"{ex.Message}");
            }
        }

        /// <summary>
        /// 设备报警处理记录
        /// </summary>
        public dynamic UpdAlarmHanded(daq_equipment_alarm_record entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                var idList = entity.ids.Split(",");
                var alarmList = new List<Guid>();
                if (idList.Length == 1)
                {
                    //查询同一个项目编码，同一个设备编码，同一个报警信息，处理其中一条 其他的自动处理
                    alarmList = Context.Queryable<daq_equipment_alarm_record>()
                                           .Where(i => i.ProjectCode == entity.ProjectCode && i.equipmentCode == entity.equipmentCode && i.alarmMessage == entity.alarmMessage && i.isHandled == false)
                                           .Select(i => i.id).ToList();
                    if (!string.IsNullOrEmpty(entity.remark))//有的报警信息写到了备注字段，alarmMessage报警信息字段无数据，因此单独从叠加备注匹配查询
                    {
                        alarmList = Context.Queryable<daq_equipment_alarm_record>()
                                           .Where(i => i.ProjectCode == entity.ProjectCode && i.equipmentCode == entity.equipmentCode && i.alarmMessage == entity.alarmMessage && i.isHandled == false && i.remark == entity.remark)
                                           .Select(i => i.id).ToList();
                    }
                }
                else
                {
                    //处理多个报警，id转guid类型存入alarmList
                    foreach (var i in idList)
                    {
                        alarmList.Add(Guid.Parse(i));
                    }
                }

                //批量处理（更新标识-增加处理记录）
                foreach (var alarm in alarmList)
                {
                    var alarmInfo = Context.Queryable<daq_equipment_alarm_record>().First(x => x.id == alarm);
                    if (alarmInfo == null)
                    {
                        response.Code = 500;
                        response.Message = $"未查询到匹配的数据或者该报警数据已被处理,EquipmentName:{entity.equipmentName},AlarmMessage:{entity.alarmMessage}";
                        return response;
                    }

                    //更新 设备报警表【是否处理】报警标识
                    alarmInfo.isHandled = true;
                    alarmInfo.UserHandleTime = DateTime.Now;
                    Context.Updateable(alarmInfo).AddQueue();

                    //新增 报警处理记录表数据
                    var alarmHandle = new bus_equipment_alarm_handle
                    {
                        ProjectCode = entity.ProjectCode,
                        factoryCode = entity.FactoryCode,
                        equipmentCode = entity.equipmentCode,
                        equipmentAlarmRecordId = alarmInfo.id,
                        handleInfo = $"【{entity.HandleInfo}】",
                        handleUser = entity.HandleUser,
                        reason = entity.Reason,
                        faultType = entity.FaultType,
                        createBy = sysWebUser.Account,
                        createTime = DateTime.Now
                    };
                    Context.Insertable(alarmHandle).AddQueue();//新增
                }
                ExecuteQueues(Context);
                return response;
            });
        }

        /// <summary>
        /// 追加报警处理记录
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public dynamic AddAlarmHanded(daq_equipment_alarm_record entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                if (entity.AddAlarmHandedPwd != "qwe123.")
                {
                    response.Code = 500;
                    response.Message = $"追加报警【密码】错误!";
                    return response;
                }
                var alamInfo = Context.Queryable<daq_equipment_alarm_record>().Where(x => x.id == entity.id && x.isHandled).First();
                if (alamInfo == null)
                {
                    response.Code = 500;
                    response.Message = $"未查询到匹配的数据,EquipmentName:{entity.equipmentName},AlarmId:{entity.id},AlarmMessage:{entity.alarmMessage}";
                    return response;
                }

                //追加报警处理记录
                var alarmHandle = Context.Queryable<bus_equipment_alarm_handle>().Where(x => x.equipmentAlarmRecordId == entity.id).First();
                if (alarmHandle == null)
                {
                    var alarmHandleNew = new bus_equipment_alarm_handle
                    {
                        ProjectCode = entity.ProjectCode,
                        factoryCode = entity.FactoryCode,
                        equipmentCode = entity.equipmentCode,
                        equipmentAlarmRecordId = entity.id,
                        handleInfo = $"【追加人:{entity.HandleUser} 追加报警处理记录：{entity.AddAlarmHanded}--{DateTime.Now}】",
                        handleUser = entity.HandleUser,
                        createBy = sysWebUser.Account,
                        createTime = DateTime.Now
                    };
                    Context.Insertable(alarmHandleNew).AddQueue();
                }
                else
                {

                    alarmHandle.handleInfo = alarmHandle.handleInfo + $"【追加报警处理记录：{entity.AddAlarmHanded}  --{DateTime.Now}】";
                    if (!alarmHandle.handleUser.Contains(entity.HandleUser))
                    {
                        alarmHandle.handleUser += "," + entity.HandleUser;
                    }
                    alarmHandle.updateBy = sysWebUser.Account;
                    alarmHandle.updateTime = DateTime.Now;
                    Context.Updateable(alarmHandle).AddQueue();
                }
                alamInfo.UserHandleTime = DateTime.Now;
                Context.Updateable(alamInfo).AddQueue();
                response.Status = Context.SaveQueues() > 0;
                if (!response.Status)
                {
                    response.Message = "追加报警处理记录失败！";
                    return response;
                }
                return response;

            });
        }

        public Dictionary<string, string> GetDicAlarmHandlePeopleList()
        {
            var result = new Dictionary<string, string>();

            //报警处理人 alarmHandlePeople
            var res = Context.Queryable<sys_dict_data>().Where(x => x.dictType == "AlarmHandlePeople").ToList();

            foreach (var item in res)
            {
                result.Add(item.dictValue, item.dictLabel);
            }

            return result;
        }

    }
}