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.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Hh.Mes.Pojo.System;

using Hh.Mes.Common;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.Service.SystemAuth;

using System.Data;

using Hh.Mes.Common.config;

namespace Hh.Mes.Service.Configure
{

    public class BaseClientInfoService : RepositorySqlSugar<base_project_client_info>

    {

        private readonly IAuth _auth;

        public BaseClientInfoService(IAuth auth)
        {
            _auth = auth;
        }

        #region 列表

        public dynamic Load(PageReq pageReq, base_project_client_info entity)

        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {

				var result = new Response();
				var expression = LinqWhere(entity);
				//先组合查询表达式(多表查询查看IOT 设备列表案例)
				var query = Context.Queryable<base_project_client_info>().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");

        }

        //private List<base_project_client_info> DataHandle(List<base_project_client_info> data)
        //{
        //    var clientKeys = data.Select(item => item.keys).ToList();
        //    var projectQuery = Context.Queryable<base_project_client_info, base_project_client_rel, sys_user_client_rel, base_project>((client,  proClient, uClient, pro) =>
        //                                        new JoinQueryInfos(
        //                                            JoinType.Left, proClient.clientKeys == client.keys,
        //                                            JoinType.Left, uClient.clientKeys == client.keys,
        //                                            JoinType.Left, pro.keys == proClient.projectKeys))
        //                                        .Where((client, proClient, uClient, pro) => clientKeys.Contains(client.keys))
        //                                        .Select((client, proClient, uClient, pro) => new
        //                                        {
        //                                            client.keys,
        //                                            pro.projectName,

        //                                            uClient.userAccount,
        //                                        })
        //                                        .ToList();
        //    //给项目 赋值 登入用户、项目关联绑定客户信息
        //    foreach (var item in data)
        //    {
        //        var projectUsers = projectQuery.Where(x => x.keys == item.keys)
        //                                       .Select(x => x.userAccount)
        //                                       .ToArray();
        //        item.projectUsers = string.Join(",", projectUsers);

        //        var projectNames = projectQuery.Where(x => x.keys == item.keys)
        //                                         .Select(x => x.projectName)
        //                                         .Distinct()
        //                                         .ToArray();
        //        item.projectNames = string.Join(",", projectNames);
        //    }

        //    return data;
        //} 

        #endregion

        public dynamic Ins(base_project_client_info 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(base_project_client_info entity)

        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                entity.setupDate = DateTime.Now;
                //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[] keys)

        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                //项目工商信息表绑定项目，不允许删除
                if (Context.Queryable<base_project>().Any(x => keys.Contains(x.projectClientInfoKeys)))

                {

                    return response.ResponseError("项目工商信息绑定了项目，不能直接删除，请先解除绑定后再试！");

                }

                Context.Deleteable<base_project_client_info>(t => keys.Contains(t.keys)).ExecuteCommand();

                return response;
            });
        }

        public Response ExportData(base_project_client_info entity)

        {
            return Load(null, entity);
        }

        public Expression<Func<base_project_client_info, bool>> LinqWhere(base_project_client_info model)

        {
            try
            {

                var exp = Expressionable.Create<base_project_client_info>();

                //数据过滤条件
                //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
                if (!string.IsNullOrWhiteSpace(model.clientName))
                {

                    exp.And((c) => c.clientName.Contains(model.clientName));

                }
                if (!string.IsNullOrWhiteSpace(model.legalRepresentative))
                {

                    exp.And((c) => c.legalRepresentative.Contains(model.legalRepresentative));

                }
                if (!string.IsNullOrWhiteSpace(model.unifiedSocialCreditCode))
                {

                    exp.And((c) => c.unifiedSocialCreditCode.Contains(model.unifiedSocialCreditCode));

                }
                return exp.ToExpression();//拼接表达式
            }
            catch (Exception ex)
            {
                throw new Exception($"{ex.Message}");
            }
        }

    }
}