sys/Hh.Mes.Service/WebService/Configure/DaqClientStatusService.cs

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 Hh.Mes.POJO.WebEntity.configure;
namespace Hh.Mes.Service.Configure
{
    /// <summary>
    /// 客户端状态
    /// </summary>
    public class DaqClientStatusService : RepositorySqlSugar<daq_client_config>
    {
        public DaqClientStatusService(IAuth auth) : base(auth) { }
        public dynamic Load(PageReq pageReq, daq_client_config entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var expression = LinqWhere(entity);
                //先组合查询表达式(多表查询查看IOT 设备列表案例)
                var query = Context.Queryable<daq_client_config, base_project>((c, p) => new JoinQueryInfos(JoinType.Left, c.projectCode == p.projectCode)).Where(expression).OrderBy((c, p) => c.projectCode);
                //Exel false 分页
                if (!entity.Exel)
                {
                    int total = 0;
                    result.Result = query.Select((c, p) => new
                    {
                        c.id,
                        c.name,
                        c.type,
                        c.projectCode,
                        p.projectName,
                        c.lastSeenDate,
                        c.factoryCode,
                        factoryName = SqlFunc.Subqueryable<base_factory>().Where(s => s.projectKeys == p.keys && s.factoryCode == c.factoryCode).Select(s => s.factoryName),
                        c.remark,
                    }).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 LoadStatus(PageReq pageReq, daq_client_config entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var expression = StatusLinqWhere(entity);
                //先组合查询表达式(多表查询查看IOT 设备列表案例)
                var query = Context.Queryable<daq_client_config, base_project>((c, p) => new JoinQueryInfos(JoinType.Left, c.projectCode == p.projectCode)).Where(expression).OrderBy((c, p) => c.lastSeenDate);
                //Exel false 分页
                if (!entity.Exel)
                {
                    int total = 0;
                    result.Result = query.Select((c, p) => new
                    {
                        c.id,
                        c.name,
                        c.type,
                        c.projectCode,
                        p.projectName,
                        c.lastSeenDate,
                        c.factoryCode,
                        factoryName = SqlFunc.Subqueryable<base_factory>().Where(s => s.projectKeys == p.keys && s.factoryCode == c.factoryCode).Select(s => s.factoryName),
                        c.remark,
                    }).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(daq_client_config entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                if (string.IsNullOrWhiteSpace(entity.name))
                {
                    return response.ResponseError($"客户端名称不能为空！");
                }
                if (string.IsNullOrWhiteSpace(entity.projectCode))
                {
                    return response.ResponseError($"项目信息不能为空！");
                }
                entity.created = DateTime.Now;
                entity.createdBy = sysWebUser?.Account;
                Context.Insertable(entity).ExecuteCommand();
                return response.ResponseSuccess();
            });
        }
        public dynamic Upd(daq_client_config entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                Context.Updateable<daq_client_config>().SetColumns(x => new daq_client_config
                {
                    name = entity.name,
                    type = entity.type,
                    projectCode = entity.projectCode,
                    factoryCode = entity.factoryCode,
                    remark = entity.remark
                }).Where(x => x.id == entity.id).ExecuteCommand();
                return response.ResponseSuccess();
            });
        }
        public dynamic DelByIds(Guid[] ids)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                Context.Deleteable<daq_client_config>(t => ids.Contains(t.id)).ExecuteCommand();
                return response;
            });
        }
        public Response ExportData(daq_client_config entity)
        {
            return Load(null, entity);
        }
        public Expression<Func<daq_client_config, base_project, bool>> LinqWhere(daq_client_config client)
        {
            var exp = Expressionable.Create<daq_client_config, base_project>();
            //数据过滤条件
            //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
            if (!string.IsNullOrWhiteSpace(client.name))
            {
                exp.And((c, p) => c.name.Contains(client.name));
            }
            if (!string.IsNullOrWhiteSpace(client.remark))
            {
                exp.And((c, p) => c.remark.Contains(client.remark));
            }
            if (!string.IsNullOrWhiteSpace(client.projectCode))
            {
                exp.And((c, p) => c.projectCode == client.projectCode);
            }
            string user = sysWebUser.Account;
            if (user != SystemVariable.DefaultCreated)
            {
                var projectRoleKeys = GetProjectRoleKeys(user);
                exp.And((c, p) => SqlFunc.Subqueryable<sys_role_projects_rel>().Where(x => projectRoleKeys.Contains(x.project_roles_key) && x.project_key == p.keys).Any());
            }
            return exp.ToExpression();//拼接表达式
        }
        public Expression<Func<daq_client_config, base_project, bool>> StatusLinqWhere(daq_client_config client)
        {
            var exp = Expressionable.Create<daq_client_config, base_project>();
            //数据过滤条件
            //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
            if (!string.IsNullOrWhiteSpace(client.name))
            {
                exp.And((c, p) => c.name.Contains(client.name));
            }
            if (!string.IsNullOrWhiteSpace(client.remark))
            {
                exp.And((c, p) => c.remark.Contains(client.remark));
            }
            if (!string.IsNullOrWhiteSpace(client.projectCode))
            {
                exp.And((c, p) => c.projectCode == client.projectCode);
            }
            exp.And((c, p) => SystemVariable.SoftTypes.Contains(c.type));
            string user = sysWebUser.Account;
            if (user != SystemVariable.DefaultCreated)
            {
                var projectRoleKeys = GetProjectRoleKeys(user);
                exp.And((c, p) => SqlFunc.Subqueryable<sys_role_projects_rel>().Where(x => projectRoleKeys.Contains(x.project_roles_key) && x.project_key == p.keys).Any());
            }
            return exp.ToExpression();//拼接表达式
        }
        public Dictionary<string, string> GetProjectInfo()
        {
            try
            {
                var projects = Context.Queryable<base_project>().Select(x => new base_project
                {
                    projectCode = x.projectCode,
                    projectName = x.projectName
                }).Distinct().ToList();
                return projects.ToDictionary(x => x.projectCode, y => y.projectName);
            }
            catch (Exception)
            {
                return new Dictionary<string, string>();
            }
        }
        public Dictionary<string, string> GetSoftType()
        {
            try
            {
                var dictTypeId = Context.Queryable<sys_dict_type>().Where(x => x.dictType == "softType").Select(x => x.id).First();
                var softTypes = Context.Queryable<sys_dict_data>().Where(x => x.headerId == dictTypeId).OrderBy(x => x.dictSort).ToList();
                return softTypes.ToDictionary(x => x.dictValue, y => y.dictLabel);
            }
            catch (Exception)
            {
                return new Dictionary<string, string>();
            }
        }
        public Response<List<base_factory>> GetFactorys(string projectCode)
        {
            var response = new Response<List<base_factory>>();
            try
            {
                var projectKey = Context.Queryable<base_project>().Where(x => x.projectCode == projectCode).Select(x => x.keys).First();
                var factorys = Context.Queryable<base_factory>().Where(x => x.projectKeys == projectKey).Select(x => new base_factory
                {
                    factoryCode = x.factoryCode,
                    factoryName = x.factoryName
                }).ToList();
                response.Result = factorys;
                response.Status = true;
            }
            catch (Exception ex)
            {
                response.ResponseErr(ex.Message);
            }
            return response;
        }
    }
}