MES / IOT · Files

using Hh.Mes.Common.Infrastructure;
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.Linq;
using System.Linq.Expressions;
using Hh.Mes.Pojo.System;
using Hh.Mes.Service.SystemAuth;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using System.IO;
using Hh.Mes.Service.Base;

namespace Hh.Mes.Service.Equipment
{
    public class BusEquipmentMaintainRuleService : RepositorySqlSugar<bus_equipment_maintain_rule_head>
    {

        #region 主表
        public dynamic Load(PageReq pageReq, bus_equipment_maintain_rule_head entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var expression = LinqWhere(entity);
                //先组合查询表达式(多表查询查看IOT 设备列表案例)
                var query = Context.Queryable<bus_equipment_maintain_rule_head>().Where(expression);
                //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");
        }

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

        public dynamic Upd(bus_equipment_maintain_rule_head 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(int[] ids)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                foreach (var id in ids)
                {
                    //查询设备规则相关数据
                    var entity = Context.Queryable<bus_equipment_maintain_rule_head>().Where(i => i.id == id).First();
                    //①设备绑定了不允许删除
                    var eqList = Context.Queryable<base_equipment>().Where(x => x.equipmentMaintainRuleCode == entity.equipmentRuleCode)
                                                                    .Select(x => new { x.equipmentName, x.equipmentCode }).ToList();
                    if (eqList.Count > 0) return response.ResponseError($"设备列表中以下设备 {string.Join(",", eqList)} 已绑定保养规则，无法删除。请先解除绑定后再尝试删除。");
                    //②删除head头同时删除掉detail和rel表
                    Context.Deleteable(entity).AddQueue();
                    Context.Deleteable<bus_equipment_maintain_rule_detail>().Where(i => i.headKeys == entity.keys).AddQueue();
                    Context.Deleteable<bus_equipment_maintain_rule_detail_indicator_rel>().Where(i => i.ruleHeadKeys == entity.keys).AddQueue();
                }
                response.Status = Context.SaveQueuesAsync().Result > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public Response ExportData(bus_equipment_maintain_rule_head entity)
        {
            return Load(null, entity);
        }

        public Expression<Func<bus_equipment_maintain_rule_head, bool>> LinqWhere(bus_equipment_maintain_rule_head model)
        {
            try
            {
                var exp = Expressionable.Create<bus_equipment_maintain_rule_head>();
                //数据过滤条件
                //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
                if (!string.IsNullOrWhiteSpace(model.equipmentRuleCode))
                {
                    exp.And(x => x.equipmentRuleCode == model.equipmentRuleCode);
                }
                if (!string.IsNullOrWhiteSpace(model.equipmentRuleName))
                {
                    exp.And(x => x.equipmentRuleName.Contains(model.equipmentRuleName));
                }
                if (!string.IsNullOrWhiteSpace(model.equipmentTypeCode))
                {
                    exp.And(x => x.equipmentTypeCode.Contains(model.equipmentTypeCode));
                }
                return exp.ToExpression();//拼接表达式
            }
            catch (Exception ex)
            {
                throw new Exception($"{ex.Message}");
            }
        }

        public dynamic InsAll(bus_equipment_maintain_rule_head entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                var sourceHeadKeys = entity.keys;//来源主键，复制该条数据下关联信息
                var isHave = Context.Queryable<bus_equipment_maintain_rule_detail>()
                                    .Any(x => x.headKeys == sourceHeadKeys);
                if (!isHave) return response.ResponseError("");

                var details = Context.Queryable<bus_equipment_maintain_rule_detail>().Where(x => x.headKeys == sourceHeadKeys).ToList();
                var indicators = Context.Queryable<bus_equipment_maintain_rule_detail_indicator_rel>().Where(x => x.ruleHeadKeys == sourceHeadKeys).ToList();

                var detailEntity = new List<bus_equipment_maintain_rule_detail>();
                var indicatorEntity = new List<bus_equipment_maintain_rule_detail_indicator_rel>();
                entity.keys = Guid.NewGuid();
                foreach (var item in details)//将明细表数据添加到表里，明细key新建
                {
                    var relData = indicators.Where(i => i.ruleDetailKeys == item.detailKeys).ToList();
                    item.headKeys = entity.keys;
                    item.detailKeys = Guid.NewGuid();
                    item.createTime = DateTime.Now;
                    detailEntity.Add(item);
                    foreach (var rel in relData)//将保养周期关系表数据添加到表里
                    {
                        rel.ruleHeadKeys = entity.keys;
                        rel.ruleDetailKeys = item.detailKeys;
                        rel.createTime = DateTime.Now;
                        indicatorEntity.Add(rel);
                    }
                }

                entity.createBy = sysWebUser.Account;
                entity.createTime = DateTime.Now;
                Context.Insertable(entity).AddQueue();//添加主表
                Context.Insertable(detailEntity).AddQueue();//添加明细表
                Context.Insertable(indicatorEntity).AddQueue();//添加保养类型关联表
                response.Status = Context.SaveQueuesAsync().Result > 0;

                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }
        #endregion

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

        private List<bus_equipment_maintain_rule_detail> HandleLoadDesc(List<bus_equipment_maintain_rule_detail> list)
        {
            var detailKeys = list.Select(i => i.detailKeys).ToList();
            //查询保养周期
            var dicatorsQuery = Context.Queryable<bus_equipment_maintain_rule_detail_indicator_rel>()
                                     .Where(i => detailKeys.Contains(i.ruleDetailKeys))
                                     .Select(i => new
                                     {
                                         i.ruleDetailKeys,
                                         maintainTime = i.indicatorValue + i.indicatorTypeName,
                                     })
                                     .ToList();

            //赋值
            foreach(var item in list)
            {
                var maintainTime = dicatorsQuery.Where(i => i.ruleDetailKeys == item.detailKeys && i.maintainTime!=null)
                                                .Select(i => i.maintainTime).ToArray();
                item.maintainTime = string.Join("/", maintainTime);
            }
            return list;
        }

        public Expression<Func<bus_equipment_maintain_rule_detail, bool>> LinqWhere(bus_equipment_maintain_rule_detail model)
        {
            try
            {
                var exp = Expressionable.Create<bus_equipment_maintain_rule_detail>();
                //数据过滤条件
                //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
                if (!string.IsNullOrWhiteSpace(model.equipmentPartCode))
                {
                    exp.And(x => x.equipmentPartCode == model.equipmentPartCode);
                }
                if (model.headKeys != Guid.Empty)
                {
                    exp.And(x => x.headKeys == model.headKeys);
                }
                return exp.ToExpression();//拼接表达式
            }
            catch (Exception ex)
            {
                throw new Exception($"{ex.Message}");
            }
        }

        public dynamic InsDesc(bus_equipment_maintain_rule_detail entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                bool allEmpty = entity.rule_detail_rel.All(e => string.IsNullOrEmpty(e.indicatorValue));
                if (allEmpty) return response.ResponseError("保养规则选项：至少有一个保养周期值不能为空！");
                entity.detailKeys = Guid.NewGuid();//添加明细表key
                entity.equipmentPartName = Context.Queryable<base_equipment_part>().Where(x => x.partCode == entity.equipmentPartCode)
                                                  .Select(x => x.partName).First();
                entity.createBy = sysWebUser.Account;
                entity.createTime = DateTime.Now;

                Context.Insertable(entity).AddQueue();
                var rel = new List<bus_equipment_maintain_rule_detail_indicator_rel>();
                foreach (var item in entity.rule_detail_rel)
                {
                    item.ruleHeadKeys = entity.headKeys;
                    item.ruleDetailKeys = entity.detailKeys;
                    item.createBy = sysWebUser.Account;
                    item.createTime = DateTime.Now;
                    rel.Add(item);
                }
                Context.Insertable(rel).AddQueue();
                response.Status = Context.SaveQueuesAsync().Result > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public dynamic UpdDesc(bus_equipment_maintain_rule_detail entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                bool allEmpty = entity.rule_detail_rel.All(e => string.IsNullOrEmpty(e.indicatorValue));
                if (allEmpty) return response.ResponseError("保养规则选项：至少有一个保养周期值不能为空！");
                entity.equipmentPartName = Context.Queryable<base_equipment_part>().Where(x => x.partCode == entity.equipmentPartCode)
                                                  .Select(x => x.partName).First();
                entity.updateBy = sysWebUser.Account;
                entity.updateTime = DateTime.Now;
                Context.Updateable(entity).IgnoreColumns(it => new { it.createBy, it.createTime, it.detailKeys }).AddQueue();
                foreach (var item in entity.rule_detail_rel)
                {
                    Context.Updateable(item).IgnoreColumns(it => new { it.createBy, it.createTime, it.ruleHeadKeys, it.ruleDetailKeys }).AddQueue();
                }
                response.Status = Context.SaveQueuesAsync().Result > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public dynamic DelByIdsDesc(int[] ids)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                foreach (int id in ids)
                {
                    //查询设备规则明细相关数据
                    var entity = Context.Queryable<bus_equipment_maintain_rule_detail>().Where(i => i.id == id).First();
                    Context.Deleteable(entity).AddQueue();
                    Context.Deleteable<bus_equipment_maintain_rule_detail_indicator_rel>().Where(i => i.ruleDetailKeys == entity.detailKeys).AddQueue();
                    response.Status = Context.SaveQueuesAsync().Result > 0;
                    if (!response.Status) response.Message = SystemVariable.dataActionError;
                }
                return response;
            });
        }
        #endregion


        #region 关系表
        public dynamic LoadDetailIndicatorRelList(bus_equipment_maintain_rule_detail_indicator_rel entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var expression = LinqWhereDetailIndicatorRel(entity);
                var query = Context.Queryable<bus_equipment_maintain_rule_detail_indicator_rel>().Where(expression);
                result.Result = query.ToList();
                result.Count = result.Result.Count;
                return result;
            }, catchRetrunValue: "list");
        }
        public Expression<Func<bus_equipment_maintain_rule_detail_indicator_rel, bool>> LinqWhereDetailIndicatorRel(bus_equipment_maintain_rule_detail_indicator_rel model)
        {
            try
            {
                var exp = Expressionable.Create<bus_equipment_maintain_rule_detail_indicator_rel>();
                if (model.ruleDetailKeys != Guid.Empty)
                {
                    exp.And(x => x.ruleDetailKeys == model.ruleDetailKeys);
                }
                return exp.ToExpression();//拼接表达式
            }
            catch (Exception ex)
            {
                throw new Exception($"{ex.Message}");
            }
        }

        #endregion
    }
}