shgx_tz_mom/ZR.Service/mes/Device/DeviceTaskExecuteService.cs

799 lines
31 KiB
C#
Raw Normal View History

2025-09-23 15:11:18 +08:00
using System;
using System.Linq;
using ZR.Model;
using ZR.Model.MES.dev;
using ZR.Model.MES.dev.Dto;
using ZR.Repository;
using ZR.Service.MES.dev.IService;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using JinianNet.JNTemplate;
using JinianNet.JNTemplate.Nodes;
using Mapster;
using Microsoft.AspNetCore.Authentication;
using Newtonsoft.Json.Linq;
using SqlSugar;
using SqlSugar.IOC;
namespace ZR.Service.MES.dev
{
/// <summary>
/// 任务执行Service业务层处理
/// </summary>
[AppService(
ServiceType = typeof(IDeviceTaskExecuteService),
ServiceLifetime = LifeTime.Transient
)]
public class DeviceTaskExecuteService
: BaseService<DeviceTaskExecute>,
IDeviceTaskExecuteService
{
/// <summary>
/// 查询任务执行列表
/// 附加每个任务是检查还是保养
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
public PagedInfo<DeviceTaskExecuteDto> GetList(DeviceTaskExecuteQueryDto parm)
{
var predicate = Expressionable
.Create<DeviceTaskExecute>()
.AndIF(
!string.IsNullOrEmpty(parm.TaskName),
it => it.TaskName.Contains(parm.TaskName)
)
.AndIF(
parm.TimeRange != null && (parm.TimeRange[0] > new DateTime(1990, 1, 1)),
it => it.CreatedTime >= parm.TimeRange[0]
)
.AndIF(
parm.TimeRange != null && (parm.TimeRange[1] > new DateTime(1990, 1, 1)),
it => it.CreatedTime <= parm.TimeRange[1]
)
.AndIF(parm.Type > -1, it => it.Type == parm.Type)
.AndIF(parm.Status > -1, it => it.Status == parm.Status);
var response = Queryable()
.OrderByDescending(x => x.Id)
.Where(predicate.ToExpression())
.ToPage<DeviceTaskExecute, DeviceTaskExecuteDto>(parm);
foreach (DeviceTaskExecuteDto item in response.Result)
{
if (item.StartTime > DateTime.MinValue && item.EndTime > DateTime.MinValue)
{
TimeSpan timeDifference = item.EndTime.Value - item.StartTime.Value;
double minutes = timeDifference.TotalMinutes;
double roundedMinutes = Math.Round(minutes, 1);
item.ConsumeTime = roundedMinutes;
}
int InnerType=0;
}
return response;
}
/// <summary>
/// 获取详情
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public DeviceTaskExecute GetInfo(string Id)
{
var response = Queryable().Where(x => x.Id == Id).First();
return response;
}
/// <summary>
/// 添加任务执行
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public DeviceTaskExecute AddDeviceTaskExecute(DeviceTaskExecute model)
{
model.Id = SnowFlakeSingle.Instance.NextId().ToString();
return Context.Insertable(model).ExecuteReturnEntity();
}
/// <summary>
/// 修改任务执行
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int UpdateDeviceTaskExecute(DeviceTaskExecute model)
{
//var response = Update(w => w.Id == model.Id, it => new DeviceTaskExecute()
//{
// TaskName = model.TaskName,
// Type = model.Type,
// DistributedTime = model.DistributedTime,
// StartTime = model.StartTime,
// EndTime = model.EndTime,
// Status = model.Status,
// Remark = model.Remark,
// CreatedBy = model.CreatedBy,
// CreatedTime = model.CreatedTime,
// UpdatedBy = model.UpdatedBy,
// UpdatedTime = model.UpdatedTime,
//});
//return response;
return Update(model, true);
}
public int Update_task_status(DeviceTaskExecuteQueryDto2 parm)
{
var response = Update(
w => w.Id == parm.Id,
it => new DeviceTaskExecute()
{
Status = parm.Status,
UpdatedBy = parm.UpdatedBy,
UpdatedTime = parm.UpdatedTime,
}
);
return response;
}
/// <summary>
/// 清空任务执行
/// </summary>
/// <returns></returns>
public bool TruncateDeviceTaskExecute()
{
var newTableName = $"device_task_execute_{DateTime.Now:yyyyMMdd}";
if (Queryable().Any() && !Context.DbMaintenance.IsAnyTable(newTableName))
{
Context.DbMaintenance.BackupTable("device_task_execute", newTableName);
}
return Truncate();
}
/// <summary>
/// 导入任务执行
/// </summary>
/// <returns></returns>
public (string, object, object) ImportDeviceTaskExecute(List<DeviceTaskExecute> list)
{
var x = Context
.Storageable(list)
.SplitInsert(it => !it.Any())
.SplitError(x => x.Item.Type.IsEmpty(), "任务类型1是巡检2是点检不能为空")
//.WhereColumns(it => it.UserName)//如果不是主键可以这样实现多字段it=>new{it.x1,it.x2}
.ToStorage();
var result = x.AsInsertable.ExecuteCommand(); //插入可插入部分;
string msg =
$"插入{x.InsertList.Count} 更新{x.UpdateList.Count} 错误数据{x.ErrorList.Count} 不计算数据{x.IgnoreList.Count} 删除数据{x.DeleteList.Count} 总共{x.TotalList.Count}";
Console.WriteLine(msg);
//输出错误信息
foreach (var item in x.ErrorList)
{
Console.WriteLine("错误" + item.StorageMessage);
}
foreach (var item in x.IgnoreList)
{
Console.WriteLine("忽略" + item.StorageMessage);
}
return (msg, x.ErrorList, x.IgnoreList);
}
/// <summary>
/// 任务计划调度 扫描每日巡检任务
/// </summary>
/// <returns></returns>
public int ScanEveryTask()
{
int result = 0;
List<DeviceRouteInspectionPlan> InitDataList = DbScoped.SugarScope.CopyNew()
.Queryable<DeviceRouteInspectionPlan>()
.Where(it => it.Status == 1)
.Where(it => it.LifeCycleStart <= DateTime.Now)
.Where(it => it.LifeCycleEnd >= DateTime.Now)
.ToList();
// 今日时间
DateTime CurrentTime = new DateTime(
DateTime.Now.Year,
DateTime.Now.Month,
DateTime.Now.Day,
0,
0,
0
);
//1. 扫描巡检
List<DeviceRouteInspectionPlan> deviceRouteInspectionPlan_execute_List =
new List<DeviceRouteInspectionPlan>();
#region 1.1
List<DeviceRouteInspectionPlan> RouteInspectionPlan_day_List = InitDataList
.Where(it => it.ExcuteCycleType == 1)
.ToList();
Console.WriteLine("每日类型处理" + RouteInspectionPlan_day_List.Count);
if (RouteInspectionPlan_day_List != null && RouteInspectionPlan_day_List.Count > 0)
{
foreach (var item in RouteInspectionPlan_day_List)
{
//开始日期
DateTime start_cal =item.LifeCycleStart??DateTime.MinValue;
start_cal = new DateTime(
start_cal.Year,
start_cal.Month,
start_cal.Day,
0,
0,
0
);
//循环周期
int cycle_period = (int)item.DayNum;
DateTime date = start_cal;
do
{
date = date.AddDays(cycle_period);
if (date == CurrentTime)
{
//今日要执行任务
deviceRouteInspectionPlan_execute_List.Add(item);
break;
}
} while (date <= CurrentTime);
}
}
#endregion
#region 1.2
List<DeviceRouteInspectionPlan> DeviceRouteInspectionPlan_week_list = InitDataList
.Where(it => it.ExcuteCycleType == 2)
.ToList();
Console.WriteLine("每周类型处理" + DeviceRouteInspectionPlan_week_list.Count);
int dayofweek = (int)CurrentTime.DayOfWeek;
if (CurrentTime.DayOfWeek == DayOfWeek.Sunday)
{
dayofweek = 7;
}
if (
DeviceRouteInspectionPlan_week_list != null
&& DeviceRouteInspectionPlan_week_list.Count > 0
)
{
foreach (var item in DeviceRouteInspectionPlan_week_list)
{
string[] cycle_period = item.WeekList.Split(",");
if (cycle_period.Length > 0)
{
for (int i = 0; i < cycle_period.Length; i++)
{
try
{
Console.WriteLine("cycle_period[i]=" + cycle_period[i]);
if (dayofweek == Convert.ToInt32(cycle_period[i]))
{
deviceRouteInspectionPlan_execute_List.Add(
(DeviceRouteInspectionPlan)item
);
break;
}
}
catch (FormatException ex)
{
Console.WriteLine("An error occurred: " + ex.Message);
continue;
}
}
}
}
}
#endregion
#region 1.3
List<DeviceRouteInspectionPlan> DeviceRouteInspectionPlan_month_list = InitDataList
.Where(it => it.ExcuteCycleType == 3)
.ToList();
Console.WriteLine("每月类型处理" + DeviceRouteInspectionPlan_month_list.Count);
if (
DeviceRouteInspectionPlan_month_list != null
&& DeviceRouteInspectionPlan_month_list.Count > 0
)
{
foreach (var item in DeviceRouteInspectionPlan_month_list)
{
try
{
if (CurrentTime.Day == Convert.ToInt32(item.MonthDayList))
{
deviceRouteInspectionPlan_execute_List.Add(
(DeviceRouteInspectionPlan)item
);
continue;
}
}
catch (FormatException ex)
{
Console.WriteLine("An error occurred: " + ex.Message);
continue;
}
}
}
#endregion
// 插入数据库
List<DeviceTaskExecute> executes = new List<DeviceTaskExecute>();
if (deviceRouteInspectionPlan_execute_List.Count > 0)
{
foreach (var item in deviceRouteInspectionPlan_execute_List)
{
DeviceTaskExecute taskExecute = new DeviceTaskExecute();
taskExecute.Id = SnowFlakeSingle.Instance.NextId().ToString();
taskExecute.TaskName = item.Name;
taskExecute.PlanId = item.Id;
taskExecute.Type = 1;
taskExecute.DistributedTime = DateTime.Now;
taskExecute.Status = 0;
taskExecute.CreatedTime = DateTime.Now;
executes.Add(taskExecute);
}
if (executes.Count > 0)
{
result = Context.Insertable(executes).ExecuteCommand();
}
}
return result;
}
/// <summary>
/// 派发点检任务
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public int ExecutionTask_point(string id)
{
DevicePointInspectionPlan point = Context
.Queryable<DevicePointInspectionPlan>()
.Where(it => it.Id == id)
.First();
DeviceTaskExecute taskExecute = new DeviceTaskExecute();
taskExecute.Id = SnowFlakeSingle.Instance.NextId().ToString();
taskExecute.TaskName = point.Name;
taskExecute.PlanId = point.Id;
taskExecute.Type = 2;
taskExecute.DistributedTime = DateTime.Now;
taskExecute.Status = 0;
taskExecute.CreatedTime = DateTime.Now;
return Context.Insertable(taskExecute).ExecuteCommand();
}
/// <summary>
/// 获取任务执行绑定的巡检任务和点检任务绑定的设备
/// </summary>
public List<DeviceAccount> AchieveTaskbindDevice(string id)
{
List<DeviceAccount> resul = null;
DeviceTaskExecute executeTask = Context
.Queryable<DeviceTaskExecute>()
.Where(it => it.Id == id)
.First();
if (executeTask != null)
{
// 类型为巡检
if (executeTask.Type == 1)
{
resul = Context
.Queryable<DeviceRelRpAt>()
.LeftJoin<DeviceAccount>((r, a) => r.FkDeviceAccountId == a.Id)
.Where(r => r.FkRouteInspectionPlanId == executeTask.PlanId)
.Select((r, a) => a)
.ToList();
}
// 类型为点检
else if (executeTask.Type == 2)
{
resul = Context
.Queryable<DeviceRelPpAt>()
.LeftJoin<DeviceAccount>((p, a) => p.FkDeviceAccountId == a.Id)
.Where(p => p.FkPointInspectionPlanId == executeTask.PlanId)
.Select((p, a) => a)
.ToList();
}
}
return resul;
}
/// <summary>
/// 获取设备绑定的检查项
/// </summary>
/// <param name="fk_device_id">设备id</param>
/// <param name="fkPlanId">计划id</param>
/// <param name="planType">计划类型</param>
/// <returns></returns>
public List<DeviceInspect> AchieveDevicebindInspect(int fk_device_id, string fkPlanId, int planType)
{
// 判断是保养/检查吗
int check_type = 1;
if(planType == 1)
{
check_type= Context.Queryable<DeviceRouteInspectionPlan>().Where(it => it.Id == fkPlanId)
.Select(it => it.InnerType.Value).First();
}else if (planType == 2)
{
check_type = Context.Queryable<DevicePointInspectionPlan>().Where(it => it.Id == fkPlanId)
.Select(it => it.InnerType.Value).First();
}
List<DeviceInspect> resul = null;
resul = Context
.Queryable<DeviceRelAccountInspect>()
.LeftJoin<DeviceInspect>((r, i) => r.FkInspectId == i.Id)
.Where(r => r.FkAccountId == fk_device_id)
.Where((r,i)=>i.Type==check_type)
.Select((r, i) => i)
.ToList();
return resul;
}
/// <summary>
/// 获取检查项绑定的检查表单
/// </summary>
public List<DeviceFormConfig> AchieveInspectbindForm(int fk_device_inspect_id)
{
List<DeviceFormConfig> result = null;
result = Context
.Queryable<DeviceFormConfig>()
.Where(it => it.FkDeviceInspectId == fk_device_inspect_id)
.ToList();
return result;
}
/// <summary>
/// 获取表单结果
/// </summary>
/// <returns></returns>
public List<DeviceTaskExecuteResult1_result> AchieveFormResult(
DeviceTaskExecuteResult1QueryDto_TaskExecute query
)
{
List<DeviceTaskExecuteResult1_result> final_result_list =
new List<DeviceTaskExecuteResult1_result>();
List<DeviceTaskExecuteResult> resultList = Context
.Queryable<DeviceTaskExecuteResult>()
.Where(it => it.PlanType == query.PlanType)
.Where(it => it.FkPlanId == query.FkPlanId)
.Where(it => it.FkDeviceId == query.FkDeviceId)
.Where(it => it.FkInspectId == query.FkInspectId)
.ToList();
if (resultList.Count == 0)
{
//初始化结果表
List<DeviceFormConfig> configlist = Context
.Queryable<DeviceFormConfig>()
.Where(it => it.FkDeviceInspectId == query.FkInspectId)
.ToList();
if (configlist.Count > 0)
{
List<DeviceTaskExecuteResult> addResultList =
new List<DeviceTaskExecuteResult>();
string PlanName = Context
.Queryable<DeviceRouteInspectionPlan>()
.Where(it => it.Id == query.FkPlanId)
.First()
?.Name;
string DeviceName = Context
.Queryable<DeviceAccount>()
.Where(it => it.Id == query.FkDeviceId)
.First()
?.DeviceName;
string InspectName = Context
.Queryable<DeviceInspect>()
.Where(it => it.Id == query.FkInspectId)
.First()
?.Name;
foreach (DeviceFormConfig config in configlist)
{
DeviceTaskExecuteResult result1 = new DeviceTaskExecuteResult();
result1.Id = SnowFlakeSingle.Instance.NextId().ToString();
result1.PlanType = query.PlanType;
result1.FkPlanId = query.FkPlanId;
result1.PlanName = PlanName;
result1.FkDeviceId = query.FkDeviceId;
result1.DeviceName = DeviceName;
result1.FkInspectId = query.FkInspectId;
result1.InspectName = InspectName;
result1.FormType = config.Type;
result1.FormTitle = config.Title;
result1.FormName = config.Content;
addResultList.Add(result1);
//生成返回结果
}
Context.Insertable(addResultList).ExecuteCommand();
// 处理初始化返回
if (addResultList.Count > 0)
{
// 1 取出所有的类别
int?[] FormTypeArray = addResultList
.Select(it => it.FormType)
.Distinct()
.ToArray();
//2. 分别处理类别
for (int i = 0; i < FormTypeArray.Length; i++)
{
var temp = addResultList
.Where(it => it.FormType == FormTypeArray[i])
.ToList();
DeviceTaskExecuteResult1_result item =
new DeviceTaskExecuteResult1_result();
item.Id = temp[0].Id;
item.Title = temp[0].FormTitle;
item.Type = temp[0].FormType;
item.Value = "";
item.Children = addResultList
.Where(it => it.FormType == FormTypeArray[i])
.Select(it => it.FormName)
.Distinct()
.ToArray();
item.Value = item.Children[0];
final_result_list.Add(item);
}
}
}
}
else if (resultList.Count > 0)
{
// 直接从结果表中获取
if (resultList.Count > 0)
{
// 1 取出所有的类别
int?[] FormTypeArray = resultList
.Select(it => it.FormType)
.Distinct()
.ToArray();
//2. 分别处理类别
for (int i = 0; i < FormTypeArray.Length; i++)
{
var temp = resultList.Where(it => it.FormType == FormTypeArray[i]).ToList();
DeviceTaskExecuteResult1_result item =
new DeviceTaskExecuteResult1_result();
item.Id = temp[0].Id;
item.Title = temp[0].FormTitle;
item.Type = temp[0].FormType;
item.Value = "";
item.Children = resultList
.Where(it => it.FormType == FormTypeArray[i])
.Select(it => it.FormName)
.Distinct()
.ToArray();
List<DeviceTaskExecuteResult> FormResultArray = resultList
.Where(it => it.FormType == FormTypeArray[i])
.ToList();
if (FormResultArray.Count == 1)
{
item.Value = FormResultArray[0].FormName;
}
else if (FormResultArray.Count > 1)
{
string[] str = new string[FormResultArray.Count];
for (int ii = 0; ii < str.Length; ii++)
{
str[i] = FormResultArray[ii].FormName;
}
item.Value = string.Join(", ", str).ToString();
}
else
{
item.Value = item.Children[0];
}
final_result_list.Add(item);
}
}
}
return final_result_list;
}
/// <summary>
/// 获取表单结果2
/// 结果表只存选中的结果,多选也只有一个结果
/// </summary>
/// <returns></returns>
public List<DeviceTaskExecuteResult1_result> AchieveFormResult2(
DeviceTaskExecuteResult1QueryDto_TaskExecute query
)
{
List<DeviceTaskExecuteResult1_result> final_result_list =
new List<DeviceTaskExecuteResult1_result>();
// 获取 设备检查项 所有表单类型
List<DeviceFormConfig> all_config_list = Context
.Queryable<DeviceFormConfig>()
.Where(it => it.FkDeviceInspectId == query.FkInspectId)
.ToList();
int?[] config_type = all_config_list.Select(it => it.Type).Distinct().ToArray();
DevicePointInspectionPlan handle_point_plan = Context
.Queryable<DevicePointInspectionPlan>()
.Where(it => it.Id == query.FkPlanId)
.First();
DeviceRouteInspectionPlan handle_rounte_plan = Context
.Queryable<DeviceRouteInspectionPlan>()
.Where(it => it.Id == query.FkPlanId)
.First();
DeviceAccount deviceAccount = Context
.Queryable<DeviceAccount>()
.Where(it => it.Id == query.FkDeviceId)
.First();
DeviceInspect inspect = Context
.Queryable<DeviceInspect>()
.Where(it => it.Id == query.FkInspectId)
.First();
if (config_type.Length > 0)
{
for (int i = 0; i < config_type.Length; i++)
{
//在结果表里查看是否有结果
DeviceTaskExecuteResult executeResult = Context
.Queryable<DeviceTaskExecuteResult>()
.Where(it => it.FkTaskId == query.FkTaskId)
.Where(it => it.PlanType == query.PlanType)
.Where(it => it.FkPlanId == query.FkPlanId)
.Where(it => it.FkDeviceId == query.FkDeviceId)
.Where(it => it.FkInspectId == query.FkInspectId)
.Where(it => it.FormType == config_type[i])
.First();
if (executeResult != null)
{
DeviceTaskExecuteResult1_result item =
new()
{
Id = executeResult.Id,
Title = executeResult.FormTitle,
Value = executeResult.FormName,
Type = executeResult.FormType,
Children = all_config_list
.Where(it => it.Type == config_type[i])
.Select(it => it.Content)
.ToArray()
};
final_result_list.Add(item);
}
else
{
DeviceTaskExecuteResult insertData =
new()
{
Id = SnowFlakeSingle.Instance.NextId().ToString(),
FkTaskId = query.FkTaskId,
PlanType = query.PlanType,
FkPlanId = query.FkPlanId
};
//点检
if (query.PlanType == 2)
{
insertData.FkPlanId = query.FkPlanId;
insertData.PlanName = handle_point_plan?.Name;
insertData.InnerType = handle_point_plan?.InnerType;
}
else if (query.PlanType == 1)
{
//巡检
insertData.FkPlanId = query.FkPlanId;
insertData.PlanName = handle_rounte_plan?.Name;
insertData.ExcuteCycleType = handle_rounte_plan?.ExcuteCycleType;
insertData.InnerType = handle_rounte_plan?.InnerType;
}
insertData.FkDeviceId = query.FkDeviceId;
insertData.DeviceName = deviceAccount.DeviceName;
insertData.FkInspectId = query.FkInspectId;
insertData.InspectName = inspect.Name;
insertData.FormType = config_type[i];
insertData.FormTitle = all_config_list
.Where(it => it.Type == config_type[i])
.Select(it => it.Title)
.First();
Context.Insertable(insertData).ExecuteReturnIdentity();
DeviceTaskExecuteResult1_result item =
new()
{
Id = insertData.Id,
Title = insertData.FormTitle,
Value = "",
Type = insertData.FormType,
Children = all_config_list
.Where(it => it.Type == config_type[i])
.Select(it => it.Content)
.ToArray()
};
final_result_list.Add(item);
}
}
}
return final_result_list;
}
/// <summary>
/// 更新结果表单
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
public int UpdateFormResult(DeviceTaskExecuteResultDto result)
{
//if (!string.IsNullOrEmpty(result.taskExecute_id))
// Context.Updateable<DeviceTaskExecute>().Where(it => it.Id == result.taskExecute_id).SetColumns(it => it.Person == result.UpdatedBy).ExecuteCommand();
result.Person = result.UpdatedBy;
DeviceTaskExecuteResult item = result.Adapt<DeviceTaskExecuteResult>();
return Context
.Updateable(item)
.IgnoreColumns(true)
.EnableDiffLogEvent("更新结果表单")
.ExecuteCommand();
}
/// <summary>
/// 增加任务开始时间
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public int AddDeviceTaskExecute(string Id, string name)
{
DateTime dateTime = DateTime.Now;
return Context
.Updateable<DeviceTaskExecute>()
.Where(it => it.Id == Id)
.Where(it => it.StartTime == null)
.SetColumns(it => it.StartTime == dateTime)
.SetColumns(it => it.Person == name)
.ExecuteCommand();
}
/// <summary>
/// 增加任务完成时间
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public int AddTaskFinallyTime(string Id)
{
DateTime dateTime = DateTime.Now;
return Context
.Updateable<DeviceTaskExecute>()
.Where(it => it.Id == Id)
.SetColumns(it => it.EndTime == dateTime)
.ExecuteCommand();
}
}
}