using PadApplication.DB;
|
using PadApplication.Entites.DbModels;
|
using PadApplication.Entites.Dto;
|
using System.Net.Http;
|
using System.Text;
|
using Newtonsoft.Json;
|
using SqlSugar;
|
|
namespace PadApplication.Services;
|
|
/// <summary>
|
/// 工单状态管理类,负责工单状态相关的数据操作
|
/// 继承自Repository<MesOrderSta>基类,包含基础的CRUD操作
|
/// </summary>
|
public class MesOrderStaManager : Repository<MesOrderSta>
|
{
|
private readonly MesQaItemsDetect02Manager
|
mesQaItemsDetect02Manager = new();
|
|
/// <summary>
|
/// 更新不良品ID
|
/// </summary>
|
/// <param name="dto">包含不良品ID(ngId)和状态ID(staId)的数据传输对象</param>
|
/// <returns>更新是否成功</returns>
|
public bool UpdateNg(OrderMachineDto dto)
|
{
|
// 更新MesOrderSta表中指定ID记录的不良品ID
|
return Db.Updateable<MesOrderSta>()
|
// 设置NgId字段为传入的ngId值
|
.SetColumns(s => s.NgId == dto.ngId)
|
// 根据主键Id匹配记录
|
.Where(s => s.Id == dto.staId)
|
// 执行更新并判断影响行数是否大于0
|
.ExecuteCommand() > 0;
|
}
|
|
/// <summary>
|
/// 根据工单号查找工单状态信息
|
/// </summary>
|
/// <param name="query">包含工单ID的查询条件</param>
|
/// <returns>工单状态信息,包含工单状态等详细信息</returns>
|
public MesOrderSta FindByOrderNo(OrderMachineDto query)
|
{
|
// 查询MesOrderSta表获取工单状态记录
|
var mesOrderSta = Db.Queryable<MesOrderSta>()
|
.Where(s => s.OrderId == query.OrderId)
|
.First();
|
|
// 如果未找到记录,返回空对象
|
if (mesOrderSta == null) return new MesOrderSta();
|
|
// 查询Womdaa表获取工单主表信息
|
var womdaa = Db.Queryable<Womdaa>()
|
.Where(a => a.Id == query.OrderId).First();
|
|
// 判空处理，避免空引用异常
|
mesOrderSta.OrderStatus = womdaa != null ? womdaa.Daa018 : null;
|
return mesOrderSta;
|
}
|
|
/// <summary>
|
/// 更新换模时间
|
/// </summary>
|
/// <param name="entity">工单状态实体,包含换模开始/结束时间</param>
|
/// <returns>更新是否成功</returns>
|
public bool ChangeMoldTime(MesOrderSta entity)
|
{
|
var vWom = Db.Queryable<VWom>()
|
.Where(s => s.MachineNo == entity.MachineNo)
|
.OrderByDescending(s => s.WGSJ)
|
.First();
|
|
return Db.Updateable<MesOrderSta>()
|
// 如果有换模开始时间则更新
|
// .SetColumnsIF(entity.ChangeMoldStartTime != null,
|
// s => s.ChangeMoldStartTime == entity.ChangeMoldStartTime)
|
// 如果有换模结束时间则更新
|
.SetColumnsIF(entity.ChangeMoldEndTime != null,
|
s => s.ChangeMoldEndTime == entity.ChangeMoldEndTime)
|
// 如果标记为1则更新机器开始时间为当前时间
|
.SetColumnsIF(entity.Flag == 1,
|
s => s.MaStartTime ==
|
DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
|
.SetColumnsIF(entity.Flag == 1 && vWom.WGSJ.Value < DateTime.Now,
|
s => s.ChangeMoldStartTime ==
|
vWom.WGSJ.Value.ToString("yyyy-MM-dd HH:mm:ss"))
|
// 根据ID匹配记录
|
.Where(s => s.Id == entity.Id)
|
// 执行更新并判断影响行数是否大于0
|
.ExecuteCommand() > 0;
|
}
|
|
/// <summary>
|
/// 更新机器时间并处理首检
|
/// 逻辑说明：
|
/// 1) 首检结果“不合格”不立即重建，等待用户再次点击送检呼叫（送检时间变化）触发重建
|
/// 2) 首次无首检单或“不合格”且送检时间变化 => 调用存储过程重建首检单
|
/// 3) 重建后保留当前送检时间，不清空
|
/// 4) 不合格但送检时间未变化 => 提示用户需要重新送检
|
/// 5) 合格且送检时间 >= 调机开始时间 => 写入开工与调机完成时间
|
/// 可选扩展：支持 ForceRebuild 强制重建（如果前端加字段）
|
/// </summary>
|
public bool ChangeMachineTime(MesOrderSta entity)
|
{
|
const string FirstCheckType = "首检";
|
const string FirstCheckResultOK = "合格";
|
const string FirstCheckResultNG = "不合格";
|
|
var womdaa = Db.Queryable<Womdaa>().Where(s => s.Id == entity.OrderId).First();
|
if (womdaa == null) throw new Exception("工单不存在");
|
|
// 当前数据库状态（用于对比送检时间是否变化）
|
var dbSta = Db.Queryable<MesOrderSta>().Where(s => s.Id == entity.Id).First();
|
|
// 行级锁防并发
|
Db.Ado.ExecuteCommand("SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
|
new SugarParameter("BILL_NO", womdaa.Daa001));
|
|
// 最新首检单
|
var latestFirst = Db.Queryable<MesQaItemsDetect02>()
|
.Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == FirstCheckType && (s.Fcancel == null || s.Fcancel != "Y"))
|
.OrderBy(s => s.CreateDate, OrderByType.Desc)
|
.First();
|
|
var latestResult = latestFirst?.FcheckResu?.Trim();
|
|
// 送检时间是否变化（表示用户重新点击了送检呼叫）
|
var isShoutTimeChanged = !string.IsNullOrEmpty(entity.MaShoutTime)
|
&& entity.MaShoutTime != dbSta?.MaShoutTime;
|
|
// 可选：如果前端以后加 ForceRebuild，可在 DTO 中增加 bool? ForceRebuild
|
// var forceRebuild = (entity as dynamic)?.ForceRebuild == true;
|
|
// 重建条件：首次 / 不合格且送检时间变化
|
var needRebuild = latestFirst == null ||
|
(string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase) && isShoutTimeChanged);
|
// || forceRebuild;
|
|
if (needRebuild)
|
{
|
var previousState = latestResult == null ? "首次创建"
|
: (latestResult == FirstCheckResultNG ? "不合格后重建" : "重建");
|
|
Db.Ado.ExecuteCommand(
|
"BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
|
new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));
|
|
// 重取最新首检单
|
latestFirst = Db.Queryable<MesQaItemsDetect02>()
|
.Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == FirstCheckType && (s.Fcancel == null || s.Fcancel != "Y"))
|
.OrderBy(s => s.CreateDate, OrderByType.Desc)
|
.First();
|
|
if (latestFirst != null)
|
{
|
var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
Db.Updateable<MesQaItemsDetect02>()
|
.SetColumns(s => s.Remeke == $"工控机于{ts}自动创建的首检单({previousState})")
|
.Where(s => s.Id == latestFirst.Id)
|
.ExecuteCommand();
|
}
|
|
if (previousState.Contains("不合格"))
|
entity.remark = "不合格已重建，等待检验";
|
}
|
else
|
{
|
// 不合格但送检时间未变化 => 提示重新送检
|
if (latestFirst != null
|
&& string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase)
|
&& !isShoutTimeChanged)
|
{
|
entity.remark = "上一首检不合格，请重新点击送检呼叫以生成新的首检单";
|
}
|
else if (latestFirst != null)
|
{
|
var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
Db.Updateable<MesQaItemsDetect02>()
|
.SetColumns(s => s.Remeke == $"工控机于{ts}首检结果：{latestResult}")
|
.Where(s => s.Id == latestFirst.Id)
|
.ExecuteCommand();
|
}
|
}
|
|
// 报工锚点逻辑
|
var mesReporting = Db.Queryable<MesReporting>()
|
.Where(s => s.BillNo == womdaa.Daa001)
|
.OrderByDescending(s => s.Id)
|
.First();
|
|
var editDate = DateTime.Now.ToString("yyyy-MM-dd");
|
MesNumericalBycl mesNumerical = null;
|
try
|
{
|
using var httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
|
var content = new StringContent(
|
JsonConvert.SerializeObject(new { machineNo = entity.MachineNo }),
|
Encoding.UTF8, "application/json");
|
var response = httpClient.PostAsync("http://192.168.0.94:9095/Numerical/RefreshDevBycl", content)
|
.GetAwaiter().GetResult();
|
if (response.IsSuccessStatusCode)
|
{
|
var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
|
var responseObj = JsonConvert.DeserializeObject<dynamic>(responseString);
|
if (responseObj != null && responseObj.code == 200)
|
{
|
mesNumerical = Db.Queryable<MesNumericalBycl>()
|
.Where(s => s.EditDate == editDate && s.MachineNo == entity.MachineNo)
|
.OrderByDescending(s => s.Id)
|
.First();
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
Console.WriteLine($"发送数据刷新请求时出错: {ex.Message}");
|
}
|
|
Db.Deleteable<MesAnchors>()
|
.Where(a => a.EditDate == editDate && a.OrderId == womdaa.Id)
|
.ExecuteCommand();
|
|
var eAnchors = new MesAnchors
|
{
|
OrderId = womdaa.Id,
|
OrderNo = womdaa.Daa001,
|
EditDate = editDate,
|
Qty = mesReporting == null ? 0 : (long?)(mesReporting.DyQty ?? 0),
|
InitialValue = mesNumerical == null ? 0 : mesNumerical.CjNum
|
};
|
Db.Insertable<MesAnchors>(eAnchors).ExecuteCommand();
|
|
// 合格且送检时间 >= 调机开始时间 => 写调机完成与开工时间
|
if (!string.IsNullOrEmpty(entity.MaShoutTime)
|
&& DateTime.TryParse(entity.MaShoutTime, out var sjTime)
|
&& DateTime.TryParse(entity.MaStartTime, out var startTime)
|
&& sjTime >= startTime
|
&& latestFirst != null
|
&& string.Equals(latestFirst.FcheckResu?.Trim(), FirstCheckResultOK, StringComparison.OrdinalIgnoreCase))
|
{
|
QualifiedInspection(new OrderMachineDto
|
{
|
OrderId = entity.OrderId,
|
orderNo = entity.OrderNo,
|
machineNo = entity.MachineNo
|
});
|
entity.StartTime = entity.MaShoutTime;
|
entity.MaEndTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
}
|
|
// 更新工单状态
|
return Db.Updateable<MesOrderSta>()
|
.SetColumnsIF(entity.MaShoutTime != null, s => s.MaShoutTime == entity.MaShoutTime)
|
.SetColumnsIF(entity.MaStartTime != null, s => s.MaStartTime == entity.MaStartTime)
|
.SetColumnsIF(entity.MaEndTime != null, s => s.MaEndTime == entity.MaEndTime)
|
.SetColumnsIF(entity.StartTime != null, s => s.StartTime == entity.StartTime)
|
.SetColumnsIF(entity.Flag == 1 && entity.remark != null, s => s.remark == entity.remark)
|
.Where(s => s.Id == entity.Id)
|
.ExecuteCommand() > 0;
|
}
|
|
/// <summary>
|
/// 初始化工单状态
|
/// </summary>
|
/// <param name="query">包含工单信息的查询条件</param>
|
/// <returns>初始化是否成功</returns>
|
public bool init(OrderMachineDto query)
|
{
|
// 查询是否已存在该工单的状态记录
|
var count = Db.Queryable<MesOrderSta>()
|
.Where(s => s.OrderId == query.OrderId).Count();
|
|
// 如果已存在则返回true
|
if (count > 0) return true;
|
|
// 创建新的工单状态记录
|
var mesOrderSta = new MesOrderSta
|
{
|
OrderId = query.OrderId.Value,
|
OrderNo = query.orderNo,
|
MachineNo = query.machineNo,
|
StartTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
|
};
|
// 插入新记录
|
return Insert(mesOrderSta);
|
}
|
|
/// <summary>
|
/// 绑定工单到机器
|
/// </summary>
|
/// <param name="entity">工单状态实体,包含机器编号等信息</param>
|
/// <returns>绑定是否成功</returns>
|
public bool Binding(MesOrderSta entity)
|
{
|
// 验证ID是否有效
|
if (entity.Id <= 0) return true;
|
// 验证机器编号是否为空
|
if (string.IsNullOrEmpty(entity.MachineNo)) return false;
|
|
// 将该机器上其他显示的工单状态设为不显示
|
var executeCommand = Db.Updateable<MesOrderSta>()
|
.SetColumns(s => s.IsShow == 0)
|
.Where(s => s.IsShow == 1 && s.MachineNo == entity.MachineNo)
|
.ExecuteCommand();
|
|
// 将当前工单状态设为显示
|
var sql = "UPDATE MES_ORDER_STA SET IS_SHOW = 1 WHERE ID = " +
|
entity.Id;
|
executeCommand += Db.Ado.ExecuteCommand(sql);
|
|
// 判断是否至少有一条记录被更新
|
return executeCommand >= 1;
|
}
|
|
/// <summary>
|
/// 更新工单时间和状态
|
/// </summary>
|
/// <param name="entity">工单状态实体,包含时间和状态信息</param>
|
/// <returns>更新是否成功</returns>
|
public bool UpdateTime(MesOrderSta entity)
|
{
|
// 验证ID是否有效
|
if (entity.Id <= 0) return true;
|
// 验证机器编号是否为空
|
if (string.IsNullOrEmpty(entity.MachineNo)) return false;
|
|
var executeCommand = 0;
|
|
// 使用事务处理更新操作
|
executeCommand += UseTransaction(db =>
|
{
|
// 根据标记获取对应的状态文本
|
var daa018 = entity.Flag switch
|
{
|
0 => "开工",
|
1 => "完工", // 这里将daa018设置为完工
|
2 => "暂停",
|
3 => "未开工",
|
_ => ""
|
};
|
|
// 如果状态无效则返回0
|
if ("".Equals(daa018)) return 0;
|
|
var date = DateTime.Now.ToString("yyyy-MM-dd");
|
|
// 查询当前机器上的工单选择记录
|
var list = Db.Queryable<MesOrderSelect>()
|
.Where(a => a.MachineNo == entity.MachineNo
|
&& a.EditDate == date
|
&& a.IsShow == 0).ToList();
|
|
// 获取工单ID列表
|
var orderIds = list.Select(s => s.OrderId).ToList();
|
// 初始化每个工单的状态
|
list.ForEach(s =>
|
{
|
var query = new OrderMachineDto
|
{
|
OrderId = s.OrderId,
|
orderNo = s.OrderNo,
|
machineNo = s.MachineNo
|
};
|
init(query);
|
});
|
|
var updateable = 0;
|
var endDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
// 根据不同状态执行相应的处理
|
switch (daa018)
|
{
|
case "开工":
|
// 开工时绑定工单
|
Binding(entity);
|
break;
|
case "暂停":
|
foreach (var orderId in orderIds)
|
{
|
var womdaa = db.Queryable<Womdaa>()
|
.Where(s => s.Id == orderId).First();
|
|
var btnLog = new MesWorkorderBtnLog
|
{
|
WorkNo = womdaa.Daa001,
|
BtnType = "工控暂停工单",
|
BtnDate = DateTime.Now
|
};
|
db.Insertable<MesWorkorderBtnLog>(btnLog)
|
.ExecuteCommand();
|
|
updateable += db.Updateable<Womdaa>()
|
.SetColumns(s => s.Daa018 == daa018)
|
.SetColumnsIF("暂停".Equals(daa018),
|
s => s.Daa034 == DateTime.Now)
|
.Where(s => s.Id == orderId).ExecuteCommand();
|
|
db.Updateable<MesOrderSelect>()
|
.SetColumns(a => a.IsShow == 1)
|
.Where(a => a.OrderId == orderId)
|
.ExecuteCommand();
|
|
//更新工单状态表
|
db.Updateable<MesOrderSta>()
|
.SetColumns(a => a.IsShow == 0)
|
.SetColumns(a => a.SuspendTime == endDate)
|
.Where(a => a.OrderId == orderId)
|
.ExecuteCommand();
|
}
|
|
break;
|
case "完工":
|
{
|
// 更新工单选择表显示状态
|
// Db.Updateable<MesOrderSelect>()
|
// .SetColumns(a => a.IsShow == 1)
|
// .Where(a => orderIds.Contains(a.OrderId))
|
// .ExecuteCommand();
|
|
// 更新工单状态表
|
// Db.Updateable<MesOrderSta>()
|
// .SetColumns(a => a.IsShow == 0)
|
// .SetColumns(a => a.EndTime == endDate)
|
// .Where(a => orderIds.Contains(a.OrderId))
|
// .ExecuteCommand();
|
|
// 处理每个工单的报工数据
|
foreach (var orderId in orderIds)
|
{
|
// 查询工单主表信息
|
var womdaa = Db.Queryable<Womdaa>()
|
.Where(s => s.Id == orderId).First();
|
|
//当已生成数不等于完工数是就跳过
|
if (womdaa.Daa008 > womdaa.Daa011)
|
{
|
updateable += 1;
|
continue;
|
}
|
|
var btnLog = new MesWorkorderBtnLog
|
{
|
WorkNo = womdaa.Daa001,
|
BtnType = "工控自动完工",
|
BtnDate = DateTime.Now
|
};
|
db.Insertable<MesWorkorderBtnLog>(btnLog)
|
.ExecuteCommand();
|
|
// 更新工单主表状态 - 这里将Womdaa表的daa018更新为完工状态
|
updateable = db.Updateable<Womdaa>()
|
.SetColumns(s => s.Daa018 == daa018)
|
.SetColumnsIF("完工".Equals(daa018),
|
s => s.Daa017 == DateTime.Now)
|
.SetColumnsIF("暂停".Equals(daa018),
|
s => s.Daa034 == DateTime.Now)
|
.Where(s => s.Id == orderId).ExecuteCommand();
|
|
// Db.Deleteable<MesOrderSelect>()
|
// .Where(a => a.OrderId == orderId)
|
// .ExecuteCommand();
|
//
|
// Db.Deleteable<MesOrderSta>()
|
// .Where(a => a.OrderId == orderId)
|
// .ExecuteCommand();
|
//更新工单选择表显示状态
|
db.Updateable<MesOrderSelect>()
|
.SetColumns(a => a.IsShow == 1)
|
.Where(a => a.OrderId == orderId)
|
.ExecuteCommand();
|
|
//更新工单状态表
|
db.Updateable<MesOrderSta>()
|
.SetColumns(a => a.IsShow == 0)
|
.SetColumns(a => a.EndTime == endDate)
|
.Where(a => a.OrderId == orderId)
|
.ExecuteCommand();
|
|
// 查询已报工数量
|
var reporting = db.Queryable<MesReporting>()
|
.Where(s => s.BillNo == womdaa.Daa001)
|
.Select(s => new MesReporting
|
{
|
OkQty = SqlFunc.AggregateSum(s.OkQty),
|
BfQty = SqlFunc.AggregateSum(s.BfQty)
|
}).First();
|
|
reporting.OkQty ??= 0;
|
reporting.BfQty ??= 0;
|
|
// 查询工单视图信息
|
// var vOrder = db.Queryable<VOrder>()
|
// .Where(s => s.ID == orderId).First();
|
|
// 计算待报工数量
|
// var reportingOkQty =
|
// Convert.ToDecimal(vOrder.todayOutput) -
|
// reporting.OkQty;
|
var CjQty = Db.Queryable<MesNumericalBycl>()
|
.Where(s => s.MachineNo == entity.MachineNo && s.EditDate == date)
|
.OrderByDescending(s=>s.CjTiem)
|
.Select<long?>(s=>s.CjNum).First();
|
|
// 计算待报工数量
|
var reportingOkQty = CjQty - reporting.OkQty;
|
|
// 如果有待报工数量则创建报工记录
|
if (!(reportingOkQty > 0)) continue;
|
var mesReporting = new MesReporting
|
{
|
CheckType = 1,
|
BgDate = DateTime.Now,
|
AddressCode = womdaa.AddressCode,
|
MachineNo = womdaa.MachineNo,
|
// BfQty = reportingOkQty,
|
BfQty = 0,
|
BlQty = reportingOkQty,
|
OkQty = 0,
|
ItemNo = womdaa.Daa002,
|
BillNo = womdaa.Daa001,
|
CjQty = CjQty,
|
DyQty = reporting.OkQty
|
};
|
|
// 插入报工记录
|
db.Insertable(mesReporting)
|
.IgnoreColumns(true).ExecuteCommand();
|
}
|
|
break;
|
}
|
}
|
|
|
// 判断更新是否成功
|
if (updateable >= 1) return updateable;
|
|
throw new Exception("工单状态更新错误");
|
});
|
|
return executeCommand >= 1;
|
}
|
|
/// <summary>
|
/// 检查工单状态是否允许操作
|
/// </summary>
|
/// <param name="query">包含工单信息和操作标识的查询条件</param>
|
/// <returns>是否允许操作</returns>
|
public bool StateCheck(OrderMachineDto query)
|
{
|
// 查询工单视图信息
|
var vOrder = Db.Queryable<VOrderBycl>()
|
.Where(s => s.ID == query.OrderId).First();
|
|
// 根据不同操作标识进行检查
|
switch (query.Flag)
|
{
|
case 0: // 开工检查
|
vOrder.BGQTY ??= 0;
|
// 判断是否已完工
|
if (vOrder.Daa008 > vOrder.BGQTY) return true;
|
throw new Exception("当前工单已经完工，不允许再开工");
|
|
case 1: // 完工检查
|
return true;
|
|
case 2: // 暂停检查
|
// 判断是否处于开工状态
|
if (!"开工".Equals(vOrder.Daa018))
|
throw new Exception("只有开工状态下才允许暂停");
|
return true;
|
|
case 3: // 反完工检查
|
// 判断是否处于完工状态
|
if (!"完工".Equals(vOrder.Daa018))
|
throw new Exception("只有完工状态下才允许反完工");
|
return true;
|
|
default:
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 检验合格时更新工单状态
|
/// </summary>
|
/// <param name="query">包含工单信息的查询条件</param>
|
/// <returns>更新是否成功</returns>
|
public bool QualifiedInspection(OrderMachineDto query)
|
{
|
var endDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
|
// 查询工单主表信息
|
var womdaa = Db.Queryable<Womdaa>()
|
.Where(s => s.Id == query.OrderId).First();
|
|
// 根据是否有首检时间更新不同的字段
|
if (!womdaa.Daa016.HasValue)
|
// 首次首检更新
|
Db.Updateable<Womdaa>()
|
.SetColumns(s => s.Daa018 == "开工")
|
.SetColumns(s => s.Daa022 == 1)
|
.SetColumns(s => s.Daa016 == DateTime.Now)
|
.SetColumns(s => s.Daa032 == DateTime.Now)
|
.Where(s => s.Id == query.OrderId).ExecuteCommand();
|
else
|
// 非首次首检更新
|
Db.Updateable<Womdaa>()
|
.SetColumns(s => s.Daa018 == "开工")
|
.SetColumns(s => s.Daa022 == 1)
|
.SetColumns(s => s.Daa032 == DateTime.Now)
|
.Where(s => s.Id == query.OrderId).ExecuteCommand();
|
|
// 查询工单状态信息
|
var entity = Db.Queryable<MesOrderSta>()
|
.Where(s => s.OrderId == query.OrderId).First();
|
|
// 绑定工单并更新时间
|
var binding = Binding(entity);
|
|
var btnLog = new MesWorkorderBtnLog
|
{
|
WorkNo = womdaa.Daa001,
|
BtnType = "工控首检开工",
|
BtnDate = DateTime.Now
|
};
|
Db.Insertable<MesWorkorderBtnLog>(btnLog).ExecuteCommand();
|
|
if (binding)
|
return Db.Updateable<MesOrderSta>()
|
.SetColumns(s => s.MaEndTime == endDate) // 自动写入调机完成时间
|
.SetColumns(s => s.StartTime == entity.MaShoutTime)
|
.Where(s => s.OrderId == query.OrderId).ExecuteCommand() > 0;
|
|
return false;
|
}
|
|
/// <summary>
|
/// 检验不合格时清空首检时间
|
/// </summary>
|
/// <param name="query">包含工单信息的查询条件</param>
|
/// <returns>清空是否成功</returns>
|
public bool InspectionIsUnqualified(OrderMachineDto query)
|
{
|
// 清空工单状态表的送检时间
|
return Db.Updateable<MesOrderSta>()
|
.SetColumns(s => s.MaShoutTime == null)
|
.Where(s => s.OrderId == query.OrderId).ExecuteCommand() > 0;
|
}
|
|
/// <summary>
|
/// 完工检查
|
/// </summary>
|
/// <param name="query">包含工单信息的查询条件</param>
|
/// <returns>完工处理是否成功</returns>
|
public bool Completed(OrderMachineDto query)
|
{
|
// 查询工单状态信息
|
var entity = Db.Queryable<MesOrderSta>()
|
.Where(s => s.OrderId == query.OrderId).First();
|
// 设置完工标记
|
entity.Flag = 1;
|
// 更新工单时间和状态
|
return UpdateTime(entity);
|
}
|
}
|
