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 ApkInfo;
using Microsoft.AspNetCore.Http;
using System.IO;
using System.Threading;
using Hh.Mes.Common.config;
using Microsoft.AspNetCore.Hosting;
using MySqlX.XDevAPI.Common;
using System.Security.Claims;
using NPOI.SS.Formula.Functions;
using Org.BouncyCastle.Utilities;
using NetTaste;
using System.Data;

namespace Hh.Mes.Service.Configure
{
	public class BaseProjectService : RepositorySqlSugar<base_project>
	{
		public dynamic Load(PageReq pageReq, base_project entity)
		{
			return ExceptionsHelp.Instance.ExecuteT(() =>
			{
				var result = new Response();
				//用户-客户 客户关联的项目
				string user = sysWebUser.Account;
				if (user != SystemVariable.DefaultCreated)//非管理员，查询登陆用户绑定客户管理的项目
				{
					sys_user_client_rel clientKeys = Context.Queryable<sys_user_client_rel>().Where(x => x.userAccount == user).First();
					if (clientKeys != null)
					{
						List<Guid> projectKeysList = Context.Queryable<base_project_client_rel>().Where(x => x.clientKeys == clientKeys.clientKeys).Select(x => x.projectKeys).ToList();
						entity.projectKeysString = string.Join(",", projectKeysList);
					}
				}
				var expression = LinqWhere(entity);
				//先组合查询表达式
				var query = Context.Queryable<base_project>().Where(expression);

				if (string.IsNullOrEmpty(entity.projectKeysString) && user != SystemVariable.DefaultCreated)
				{//非管理员，且无关联项目
					query = Context.Queryable<base_project>().Where(x => false);
				}

				//项目地图调用  返回结果
				if (entity.flag == "projectMapList")
				{
					List<base_project> list = query.ToList();
					var sumEqCount = 0;
					foreach (base_project i in list)
					{
						i.eqCount = Context.Queryable<base_equipment>().Where(x => x.projectKeys == i.keys).ToList().Count;//单个项目设备数
						sumEqCount = sumEqCount + i.eqCount;//关联项目 总设备数量
						var eqStatus = Context.Queryable<base_equipment, daq_equipment_status_record>(
										(x, y) => new JoinQueryInfos(JoinType.Inner, x.equipmentCode == y.equipmentCode));
						i.eqOnLine = eqStatus.Where((x, y) => x.projectKeys == i.keys && y.status=="Running").ToList().Count;//在线数
						i.eqOff = eqStatus.Where((x, y) => x.projectKeys == i.keys && y.status=="Free").ToList().Count;//待机数
					}
					Tuple<List<base_project>, int, string, string> res = new Tuple<List<base_project>, int, string, string>(list, sumEqCount, string.Format("{0:P2}", 0.2), string.Format("{0:P2}", 0.2));
					result.Result = res;
					return result;
				}
				//Exel为ture就不分页，因为导出的话是全部导出
				if (pageReq != null && !entity.Exel)
				{
					int total = 0;
					result.Result = query.ToOffsetPage(pageReq.page, pageReq.limit, ref total);
					result.Count = total;
					return result;
				}
				result.Result = query.ToList();
				result.Count = result.Result.Count();
				return result;
			}, catchRetrunValue: "list");
		}

		public dynamic Ins(base_project entity)
		{
			return ExceptionsHelp.Instance.ExecuteT(() =>
			{
				var response = new Response();
				var projectKey = Guid.NewGuid();
				entity.keys = projectKey;
				entity.createBy = sysWebUser.Account;
				entity.createTime = DateTime.Now;

				Context.Insertable(entity).AddQueue();

				var factory = new base_factory
				{
					keys = Guid.NewGuid(),
					factoryCode = "fac_" + entity.projectCode,
					factoryName = entity.projectName + "默认一厂",
					createBy = sysWebUser.Account,
					createTime = DateTime.Now,
					projectKeys = projectKey
				};
				Context.Insertable(factory).AddQueue();
				var result = Context.SaveQueuesAsync().Result > 0;
				response.Status = result;
				if (!result) response.Message = SystemVariable.dataActionError;
				return response;
			});
		}

		public dynamic Upd(base_project 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[] keysList)
		{
			return ExceptionsHelp.Instance.ExecuteT(() =>
			{
				var response = new Response();
				//1.1删除项目需要判断绑定客户
				var isBindClient = Context.Queryable<base_project_client_rel>().Any(x => keysList.Contains(x.projectKeys));
				if (isBindClient)
				{
					return response.ResponseError("选中删除的项目已关联绑定客户，不能直接删除，请选取消项目关联客户！");
				}
				//1.2 项目是否绑定设备 通过设备绑定是否存在projectKeys
				//var isBindEq = Context.Queryable<base_equipment>().Any(x => keysList.Contains(x.projectKeys));
				//if (isBindEq)
				//{
				//    return response.ResponseError("选中删除的项目已关联绑定设备，不能直接删除，请删除设备后在删除项目！");
				//}
				Context.Deleteable<base_project>(t => keysList.Contains(t.keys)).AddQueue();
				Context.Deleteable<base_factory>(t => keysList.Contains(t.projectKeys)).AddQueue();

				var result = Context.SaveQueues() > 0;
				response.Status = result;
				if (!result) response.Message = SystemVariable.dataActionError;
				return response;
			});
		}

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

		public Expression<Func<base_project, bool>> LinqWhere(base_project model)
		{
			try
			{
				var exp = Expressionable.Create<base_project>();
				//数据过滤条件
				//if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));

				if (!string.IsNullOrEmpty(model.projectKeysString))
				{
					model.projectKeysString.Split(",").ToList()
						.ForEach(i => exp.Or(x => x.keys == new Guid(i)));
				}
				if (!string.IsNullOrWhiteSpace(model.projectName))
				{
					exp.And(x => x.projectName.Contains(model.projectName));
				}
				if (!string.IsNullOrWhiteSpace(model.projectAddress))
				{
					exp.And(x => x.projectAddress.Contains(model.projectAddress));
				}
				if (!string.IsNullOrWhiteSpace(model.projectManager))
				{
					exp.And(x => x.projectManager.Contains(model.projectManager));
				}
				return exp.ToExpression();//拼接表达式
			}
			catch (Exception ex)
			{
				throw new Exception($"{ex.Message}");
			}
		}

		public dynamic LoadProjectOverview(base_project entity)
		{
			return ExceptionsHelp.Instance.ExecuteT(() =>
			{
				var result = new Response();
				//项目地图调用  返回结果
				project_overview po = new project_overview();
				po.eqSumCount = Context.Queryable<base_equipment>().Where(x => x.projectKeys == entity.keys).ToList().Count;//单个项目设备数
				result.Result = po;
				return result;
			}, catchRetrunValue: "list");
		}
	}
}