using CMS.Extensions.Variable;
|
using CMS.Plugin.FormulaManagement.Abstractions;
|
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.CommonDto;
|
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
|
using CMS.Plugin.MaterialManagement.Abstractions;
|
using CMS.Plugin.OrderManagement.Abstractions;
|
using CMS.Plugin.OrderManagement.Abstractions.Enums;
|
using CMS.Plugin.OrderManagement.Abstractions.Models;
|
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.CallMaterialOrder;
|
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkPlan;
|
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkTask;
|
using CMS.Plugin.PipeLineLems.Application.Contracts.Services;
|
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrder;
|
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrderRecord;
|
using CMS.Plugin.PipeLineLems.Domain.WorkPlan;
|
using CMS.Plugin.PipeLineLems.Domain.WorkTask;
|
using CMS.Plugin.ProcessManagement.Abstractions;
|
using CMS.Plugin.ProductManagement.Abstractions;
|
using CMS.Plugin.TraceManagement.Abstractions;
|
using CMS.Plugin.TraceManagement.Abstractions.Models.Traces;
|
using CMS.Unit.RuntimeValue.Models;
|
using CmsQueryExtensions;
|
using CmsQueryExtensions.Entitys;
|
using CmsQueryExtensions.Extension;
|
using Humanizer;
|
using KissUtil.Extensions;
|
using Microsoft.Extensions.DependencyInjection;
|
using Newtonsoft.Json;
|
using Volo.Abp;
|
using Volo.Abp.ObjectMapping;
|
using Volo.Abp.Uow;
|
|
namespace CMS.Plugin.PipeLineLems.Application.Implements;
|
|
/// <summary>
|
/// 作业计划表应用服务
|
/// </summary>
|
public class SharedService : CMSPluginAppService
|
{
|
|
|
|
/// <summary>
|
/// 分拣功能
|
/// </summary>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="input"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
public async Task<MesOrderResponse> CommonPick(IServiceProvider _serviceProvider, PickInput input, MyCurrentUser myCurrentUser)
|
{
|
if (string.IsNullOrEmpty(input.TaskCode))
|
{
|
throw new UserFriendlyException("请输入任务编号");
|
};
|
if (string.IsNullOrEmpty(input.PipeSpecCode))
|
{
|
throw new UserFriendlyException("请输入管段编码");
|
};
|
if (string.IsNullOrEmpty(input.ContinerNo))
|
{
|
throw new UserFriendlyException("请输入托盘号");
|
};
|
//1、记录分拣记录表
|
//2、更新作业计划表的状态 =已分拣
|
//3、写入 分拣变量
|
//4、写入追溯报表
|
//5、物料组盘
|
|
|
VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
|
var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
|
var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
|
var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
|
var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
|
var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
|
var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();
|
|
//Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
|
// {
|
// { "分拣托盘号","托盘1"},
|
// { "分拣方向", "短管装配"},
|
// { "分拣人", myCurrentUser.UserAccount }
|
// };
|
//_variableService.WriteValueAsync(keyValuePairs);
|
|
//根据工序名获取工序对象
|
var workSection = await _workSectionManager.GetByNameAsync("分拣工序");
|
var workStation = await _workStationManager.GetByNameAsync("分拣工位");
|
//写入追溯报表
|
var finishTime = DateTime.Now;
|
TraceModel traceModel = new TraceModel()
|
{
|
SerialNumber = input.PipeSpecCode,
|
WorkSectionId = workSection.Id,
|
WorkSectionName = workSection.Name,
|
WorkStationName = workStation.Name,
|
|
FinishTime = finishTime,
|
IsQualified = true,
|
UnqualifiedReason = "",
|
ProductModel = "",
|
ProductName = "",
|
|
};
|
traceModel.Params = new List<TraceParamModel>();
|
foreach (var item in workSection.ProcessParameters)
|
{
|
var value = "ssss";
|
traceModel.Params.Add(new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = value.SafeString()
|
});
|
}
|
//物料参数列表
|
var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
|
var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == firstWorkPlan.DataIdentifier);
|
//TODO:这里调用wms的叫料接口
|
try
|
{
|
//首先判断库存是否存在
|
var dto = await IsExistInWms(input.PipeSpecCode);
|
if (dto != null)
|
{
|
throw new UserFriendlyException($"已经分拣过，库存在库位{dto.PlaceNo},托盘号{dto.ContainerNo}");
|
}
|
|
|
WmsMaterialStockCreateDto param = new WmsMaterialStockCreateDto()
|
{
|
ContainerNo = input.ContinerNo,
|
MaterialModel = firstWorkPlan.MaterialMode,
|
PlaceNo = input.PlaceNo,
|
StockNumber = 1,
|
MaterialBatch = callMaterialOrder.MaterialBatch,
|
|
RedundantField1 = firstWorkPlan.ProcessRouteNumber, //扩展字段显示 工艺流向编号
|
RedundantField2 = firstWorkPlan.PipeSpecCode, //扩展字段显示 管段编码
|
RedundantField3 = firstWorkPlan.PipeSectionName, //扩展字段显示 管段名称
|
|
};
|
string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
|
string url = baseUrl + "LMesOperate/LMesPick";
|
string json = JsonConvert.SerializeObject(param);
|
var result = HttpApiRequest.HttpPost(url, json);
|
var res = JsonConvert.DeserializeObject<CmsApiResponse<WmsMaterialStockDto>>(result);
|
if (res.Code == 200)
|
{
|
var retData = res.Data;
|
//callMaterialOrder.MaterialBatch = retData[0].MaterialBatch;
|
//callMaterialOrder.WmsTaskNo = retData[0].TaskNo;
|
//callMaterialOrder.WmsRetResult = res.Message;
|
}
|
else
|
{
|
throw new UserFriendlyException(res.Message);
|
}
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
|
|
|
|
|
var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
|
var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
|
var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
|
List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
|
foreach (var item in workSection.MaterialParameters)
|
{
|
if (item.Name == "原料管型号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_MaterialMode.MaterialId,
|
MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
|
Value = firstWorkPlan.MaterialMode
|
|
});
|
}
|
if (item.Name == "原料管标识")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_DataIdentifier.MaterialId,
|
MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
|
Value = firstWorkPlan.DataIdentifier,
|
|
});
|
}
|
if (item.Name == "原料管批次")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_Batch.MaterialId,
|
MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
|
Value = callMaterialOrder.MaterialBatch,//批次暂时写死
|
|
});
|
}
|
};
|
|
//配置过程参数(采集参数、配方参数)
|
traceModel.Params = new List<TraceParamModel>();
|
foreach (var item in workSection.ProcessParameters)
|
{
|
string _value = "";
|
if (item.Name == "分拣方向")
|
{
|
_value = "短管分拣";
|
}
|
if (item.Name == "分拣托盘号")
|
{
|
_value = input.ContinerNo;
|
}
|
if (item.Name == "分拣人")
|
{
|
_value = myCurrentUser.UserAccount;
|
}
|
//item.Key
|
TraceParamModel traceParamModel = new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = _value
|
};
|
traceModel.Params.Add(traceParamModel);
|
};
|
foreach (var item in workSection.FormulaParameters)
|
{
|
string _value = "";
|
if (item.Name == "分拣方向")
|
{
|
_value = "短管分拣";
|
}
|
if (item.Name == "分拣托盘号")
|
{
|
_value = input.ContinerNo;
|
}
|
if (item.Name == "分拣人")
|
{
|
_value = myCurrentUser.UserAccount;
|
}
|
//item.Key
|
TraceParamModel traceParamModel = new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = _value
|
};
|
traceModel.Params.Add(traceParamModel);
|
};
|
|
traceModel.MaterialParams = _MaterialParams;
|
|
await traceProvider.CreateTraceAsync(traceModel);
|
|
var response = new MesOrderResponse
|
{
|
Code = "200",
|
Data = "",
|
Message = "处理成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
|
/// <summary>
|
/// 创建作业计划
|
/// </summary>
|
/// <param name="input"></param>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="workPlanAppService"></param>
|
/// <returns></returns>
|
/// <exception cref="UserFriendlyException"></exception>
|
public async Task<MesOrderResponse> CommonCreatebyApsAsync(List<WorkPlanInput> input, IServiceProvider _serviceProvider,
|
WorkPlanAppService workPlanAppService,
|
string userId, string userAccount
|
)
|
{
|
|
if (input == null)
|
{
|
throw new UserFriendlyException("输入参数不能为空");
|
}
|
|
if (input.Count == 0)
|
{
|
throw new UserFriendlyException("输入参数Data不能为空");
|
}
|
|
//写死 打码内容
|
foreach (var item in input)
|
{
|
//格式 管段编码,管段名称,船号,项目号
|
item.MarkingContent = item.PipeSpecCode + "," + item.PipeSectionName + "," + item.ShipNumber + "," + item.ProjectNumber;
|
}
|
|
//校验数据
|
//1、原料标识相同的不能存在于两个 管段编号中
|
//var validationResult = ValidateUniqueDataIdentifierPerPipeSection(input);
|
//if (!validationResult.isValid)
|
//{
|
// 处理验证失败的情况
|
// throw new UserFriendlyException($"验证失败: {validationResult.errorMessage}");
|
// 返回错误信息给客户端或进行其他处理
|
//}
|
|
|
var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();
|
|
var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
|
var productProvider = _serviceProvider.GetRequiredService<IProductProvider>();
|
var formulaProvider = _serviceProvider.GetRequiredService<IFormulaProvider>();
|
|
var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
|
|
List<OrderModel> orderModels = new List<OrderModel>();
|
|
#region 事务
|
|
using var scope = _serviceProvider.CreateScope();
|
var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
|
using var uow = unitOfWorkManager.Begin(requiresNew: true);
|
|
try
|
{
|
#region 数据处理
|
|
//按照 原料标识 分组
|
var groupTask = input.GroupBy(x => x.DataIdentifier);
|
foreach (var gTask in groupTask)
|
{
|
|
|
|
//var product = await productProvider.FindByNameAsync(orderItem.PipeSectionName);
|
//if (product == null)
|
//{
|
// throw new UserFriendlyException($"产品名称[{orderItem.PipeSectionName}]不存在");
|
//}
|
|
//var formula = await formulaProvider.GetFormulaAsync(product.Id);
|
//if (formula == null)
|
//{
|
// throw new UserFriendlyException($"产品型号[{orderItem.MaterialCode}]无关联配方");
|
//}
|
//首先要创建 打码切割的工单
|
var productForCut = await productProvider.FindByNameAsync("切割原料管");
|
if (productForCut == null)
|
{
|
throw new UserFriendlyException($"产品名称[切割原料管]不存在");
|
}
|
var formulaForCut = await formulaProvider.GetFormulaAsync(productForCut.Id);
|
if (formulaForCut == null)
|
{
|
throw new UserFriendlyException($"产品名称[切割原料管]无关联配方");
|
}
|
//按照 管段编号 分组
|
var group = gTask.ToList().GroupBy(x => x.PipeSpecCode);
|
foreach (var item in group)
|
{
|
var prodOrderNo = "Order_" + item.Key;
|
var order = await orderManager.GetByCodeAsync(prodOrderNo);
|
if (order != null)
|
{
|
//throw new UserFriendlyException($"生产工单[{prodOrderNo}]已存在");
|
continue;
|
}
|
|
OrderModel orderModelForCut = new OrderModel()
|
{
|
Id = Guid.NewGuid(),
|
Code = prodOrderNo,
|
Source = "APS推送",
|
PlanStartTime = gTask.ToList().First().PlannedStartTime,
|
PlanFinishTime = gTask.ToList().First().PlannedEndTime,
|
PlanQty = 1,
|
Status = OrderStatus.NotActive,
|
Product = new AssociationProductModel() { Id = productForCut.Id, Name = productForCut.Name, Model = productForCut.Model, ShortNumber = productForCut.ShortNumber },
|
Formula = new AssociationFormulaModel() { Id = formulaForCut.Id, Code = formulaForCut.Code, Name = formulaForCut.Name }
|
};
|
orderModelForCut.ExtraProperties["OuterDiameter"] = gTask.ToList().First().OuterDiameter;//外径
|
orderModelForCut.ExtraProperties["Material"] = gTask.ToList().First().Material;//材质
|
orderModelForCut.ExtraProperties["Length"] = gTask.ToList().First().Length;//长度
|
orderModelForCut.ExtraProperties["DataIdentifier"] = gTask.ToList().First().DataIdentifier;//原料标识
|
orderModelForCut.ExtraProperties["MaterialMode"] = gTask.ToList().First().MaterialMode;//原料类型
|
orderModelForCut.ExtraProperties["PipeFittingCode"] = gTask.ToList().First().PipeFittingCode;//管段编号
|
|
var orderForCut = await orderManager.GetByCodeAsync(orderModelForCut.Code);
|
if (orderForCut != null)
|
{
|
//throw new UserFriendlyException($"工单[{orderModelForCut.Code}]已存在");
|
//不再抛异常，直接跳过
|
break;
|
}
|
|
var orderModelResultForCut = await orderManager.CreateAsync(orderModelForCut);
|
if (orderModelResultForCut == null)
|
{
|
throw new UserFriendlyException($"工单[{orderModelForCut.Code}]创建失败");
|
}
|
orderModels.Add(orderModelResultForCut);
|
|
|
//OrderModel orderModel = new OrderModel();
|
//orderModel.Id = Guid.NewGuid();
|
//orderModel.Code = orderItem.TaskCode;
|
//orderModel.Source = "APS推送";
|
//orderModel.Product = new AssociationProductModel() { Id = product.Id, Name = product.Name, Model = product.Model, ShortNumber = product.ShortNumber };
|
////orderModel.Formula = new AssociationFormulaModel() { Id = formula.Id, Code = formula.Code, Name = formula.Name };
|
//orderModel.PlanStartTime = orderItem.PlannedStartTime;
|
//orderModel.PlanFinishTime = orderItem.PlannedEndTime;
|
//orderModel.PlanQty = (ulong?)orderItem.OrderQty;
|
//orderModel.Status = OrderStatus.NotActive;
|
//orderModel.ExtraProperties["Source"] = "ddd";
|
//var source = orderModel.ExtraProperties["Source"];
|
//var orderModelResult = await orderManager.CreateAsync(orderModel);
|
//if (orderModelResult == null)
|
//{
|
// throw new UserFriendlyException($"工单[{orderItem.TaskCode}]创建失败");
|
//}
|
//orderModels.Add(orderModelResult);
|
}
|
|
|
//保存到 scms_callmaterialorders 表中
|
CallMaterialOrderCreateDto insertObjForOrder = new CallMaterialOrderCreateDto()
|
{
|
CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行,
|
DataIdentifier = gTask.Key,
|
MaterialMode = gTask.ToList().First().MaterialMode,
|
CreatorName = userAccount,
|
Quantity = 1
|
};
|
|
await callMaterialOrderAppService.CreateAsync(insertObjForOrder);
|
}
|
|
|
|
//throw new UserFriendlyException($"主动触发失败");
|
//保存到 scms_workplans 表中
|
foreach (var item in input)
|
{
|
var insertObj = ObjectMapper.Map<WorkPlanInput, WorkPlanCreateDto>(item);
|
//insertObj.OrgMaterialCode = "1111";
|
insertObj.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行;
|
insertObj.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.未生产;
|
insertObj.Sort = 1;
|
insertObj.CreatorName = userAccount;
|
insertObj.Remark = "系统导入";
|
await workPlanAppService.CreateAsync(insertObj);
|
|
//增加新增计划任务表数据 【Editby shaocx,2025-05-20】
|
var org_insertTaskObj = ObjectMapper.Map<WorkPlanCreateDto, WorkTaskCreateDto>(insertObj);
|
org_insertTaskObj.Son_TaskCode = insertObj.TaskCode;
|
await workTaskAppService.CreateAsync(org_insertTaskObj);
|
if (insertObj.ProcessName == "切割工序")
|
{//新建 分拣工序
|
var insertTaskObj = ObjectMapper.Map<WorkPlanCreateDto, WorkTaskCreateDto>(insertObj);
|
insertTaskObj.Son_TaskCode = insertObj.TaskCode + "_1";
|
insertTaskObj.ProcessName = "分拣工序";
|
await workTaskAppService.CreateAsync(insertTaskObj);
|
}
|
else if (insertObj.ProcessName == "装配工序")
|
{//新建 法兰冲码工序(多个)
|
//目前暂时搞成一个法兰
|
var insertTaskObj = ObjectMapper.Map<WorkPlanCreateDto, WorkTaskCreateDto>(insertObj);
|
insertTaskObj.Son_TaskCode = insertObj.TaskCode + "_1";
|
insertTaskObj.ProcessName = "法兰冲码工序";
|
await workTaskAppService.CreateAsync(insertTaskObj);
|
}
|
}
|
|
#endregion
|
|
await uow.CompleteAsync();
|
}
|
catch (Exception ex)
|
{
|
await uow.RollbackAsync();
|
throw ex;
|
}
|
finally
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
// 发布事件
|
//await _eventBus.PublishAsync(new EntityChangedEto("MESCREATE", input, null, EntityChangeType.Add, true));
|
|
var response = new MesOrderResponse
|
{
|
Code = "000000",
|
Data = orderModels,
|
Message = "处理成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
|
/// <summary>
|
/// 验证原料标识相同的记录不能存在于两个不同的管段编号中
|
/// </summary>
|
/// <param name="inputs">作业计划输入参数列表</param>
|
/// <returns>验证结果，包含是否通过验证及错误信息</returns>
|
public static (bool isValid, string errorMessage) ValidateUniqueDataIdentifierPerPipeSection(List<WorkPlanInput> inputs)
|
{
|
if (inputs == null || !inputs.Any())
|
{
|
return (true, string.Empty);
|
}
|
|
// 使用Lookup分组，键为原料标识，值为对应的管段编号集合
|
var dataIdentifierGroups = inputs.ToLookup(x => x.DataIdentifier, x => x.PipeSpecCode);
|
|
foreach (var group in dataIdentifierGroups)
|
{
|
// 忽略空的原料标识
|
if (string.IsNullOrEmpty(group.Key))
|
{
|
continue;
|
}
|
|
// 获取当前原料标识对应的唯一管段编号集合
|
var uniquePipeSections = group.Distinct().ToList();
|
|
// 如果存在多个不同的管段编号，则违反规则
|
if (uniquePipeSections.Count > 1)
|
{
|
return (false, $"原料标识 '{group.Key}' 存在于多个不同的管段编号中: {string.Join(", ", uniquePipeSections)}");
|
}
|
}
|
|
return (true, string.Empty);
|
}
|
|
|
/// <summary>
|
/// 根据原料标识进行叫料操作
|
/// </summary>
|
/// <param name="dataIdentifier">原料标识</param>
|
/// <param name="_serviceProvider">服务提供者</param>
|
/// <returns>操作结果</returns>
|
/// <exception cref="UserFriendlyException">当数据不存在或状态不允许叫料时抛出</exception>
|
public async Task<MesOrderResponse> CallMaterial(CallMaterialByDataIdentifierInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
|
{
|
if (string.IsNullOrEmpty(input.Id.ToString()))
|
{
|
throw new UserFriendlyException("原料标识不能为空");
|
}
|
|
var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
|
var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
|
var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
|
var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
|
var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
|
|
// 查找数据
|
|
var callMaterialOrder = await callMaterialOrderRepository.GetAsync(input.Id);
|
if (callMaterialOrder == null)
|
{
|
throw new UserFriendlyException($"找不到叫料记录");
|
}
|
|
// 验证状态
|
if (callMaterialOrder.CallMaterialStatus != Domain.Shared.Enums.CallMaterialStatusEnum.未执行)
|
{
|
//throw new UserFriendlyException($"原料标识为 '{callMaterialOrder.DataIdentifier}' 的叫料记录状态为 '{callMaterialOrder.CallMaterialStatus}'，不允许叫料");
|
}
|
|
//TODO:这里调用wms的叫料接口
|
try
|
{
|
List<LMesCallMaterialInput> param = new List<LMesCallMaterialInput>() {
|
new LMesCallMaterialInput(){
|
DataIdentifier=callMaterialOrder.DataIdentifier,
|
MaterialMode=callMaterialOrder.MaterialMode,
|
}
|
};
|
string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
|
string url = baseUrl + "lMesOperate/LMesCallMaterial";
|
string json = JsonConvert.SerializeObject(param);
|
var result = HttpApiRequest.HttpPost(url, json);
|
|
var res = JsonConvert.DeserializeObject<CmsApiResponse<List<MyCallMaterialOutput>>>(result);
|
if (res.Code == 200)
|
{
|
var retData = res.Data;
|
callMaterialOrder.MaterialBatch = retData[0].MaterialBatch;
|
callMaterialOrder.WmsTaskNo = retData[0].TaskNo;
|
callMaterialOrder.WmsRetResult = res.Message;
|
}
|
else
|
{
|
throw new UserFriendlyException(res.Message);
|
}
|
//*/
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
|
|
// 更新数据
|
//callMaterialOrder.MaterialBatch = GenerateRandomBatch();//wms返回的原料批次
|
//callMaterialOrder.WmsRetResult = "成功";
|
//callMaterialOrder.WmsTaskNo = GenerateRandomTaskNo();
|
callMaterialOrder.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
|
callMaterialOrder.LastModifierName = "SuperAdmin";
|
|
await callMaterialOrderRepository.UpdateAsync(callMaterialOrder);
|
|
//更新作业计划表
|
var workPlanList = await workPlanRepository.GetListByFilterAsync(x => x.DataIdentifier == callMaterialOrder.DataIdentifier);
|
foreach (var item in workPlanList)
|
{
|
item.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
|
item.LastModifierName = "SuperAdmin";
|
}
|
await workPlanRepository.UpdateManyAsync(workPlanList);
|
|
//更新作业任务表
|
var workTaskList = await workTaskRepository.GetListByFilterAsync(x => x.DataIdentifier == callMaterialOrder.DataIdentifier);
|
foreach (var item in workTaskList)
|
{
|
item.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
|
item.LastModifierName = "SuperAdmin";
|
}
|
await workTaskRepository.UpdateManyAsync(workTaskList);
|
|
//新增叫料记录表
|
var callMaterialOrderRecord = new CallMaterialOrderRecord()
|
{
|
CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成,
|
MaterialBatch = callMaterialOrder.MaterialBatch,
|
MaterialMode = callMaterialOrder.MaterialMode,
|
DataIdentifier = callMaterialOrder.DataIdentifier,
|
Quantity = 1,
|
WmsRetResult = callMaterialOrder.WmsRetResult,
|
WmsTaskNo = callMaterialOrder.WmsTaskNo,
|
CreatorName = "SuperAdmin"
|
};
|
await callMaterialOrderRecordRepository.InsertAsync(callMaterialOrderRecord);
|
|
//更新工单表的状态
|
var pipeSpecCodeList = workPlanList.Select(x => x.PipeSpecCode).Distinct().ToList();
|
foreach (var item in pipeSpecCodeList)
|
{
|
var prodOrderNo = "Order_" + item;
|
var order = await orderManager.GetByCodeAsync(prodOrderNo);
|
if (order != null)
|
{
|
order.ExtraProperties["CallMaterialStatus"] = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成.ToString();
|
}
|
await orderManager.UpdateAsync(order);
|
}
|
|
|
// 返回结果
|
var response = new MesOrderResponse
|
{
|
Code = "200",
|
Message = "叫料成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
|
/// <summary>
|
///装配/焊接开工
|
/// </summary>
|
/// <param name="input"></param>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
/// <exception cref="UserFriendlyException"></exception>
|
public async Task<MesOrderResponse> StartProduction(StartProductionInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
|
{
|
if (string.IsNullOrEmpty(input.TaskCode.ToString()))
|
{
|
throw new UserFriendlyException("任务编码不能为空");
|
}
|
|
string processName = "";
|
|
VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
|
var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
|
var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
|
var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
|
var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
|
var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
|
var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();
|
|
// 查找数据
|
|
var workPlan = await workPlanRepository.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
|
if (workPlan == null)
|
{
|
throw new UserFriendlyException($"找不到作业计划");
|
}
|
var workTask = await workTaskRepository.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode && x.ProcessName == workPlan.ProcessName);
|
if (workTask == null)
|
{
|
throw new UserFriendlyException($"找不到作业任务");
|
}
|
if (workPlan.ProcessName == "装配工序")
|
{
|
processName = "装配";
|
}
|
else if (workPlan.ProcessName == "焊接工序")
|
{
|
processName = "焊接";
|
}
|
|
// 验证状态
|
if (workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.暂停中 && workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.未生产)
|
{
|
//暂时注释
|
//throw new UserFriendlyException($"任务编码 '{input.TaskCode}' 的录状态为 '{workPlan.WorkPlanStatus}'，不允许开工");
|
}
|
|
var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == workPlan.DataIdentifier);
|
#region 事务
|
|
using var scope = _serviceProvider.CreateScope();
|
var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
|
using var uow = unitOfWorkManager.Begin(requiresNew: true);
|
|
try
|
{
|
#region 数据处理
|
|
//1、更新作业计划表为 生产中
|
//2、给PLC发工艺参数指令,并写入 plc中 产品id
|
//if (workPlan.ProcessName == "装配工序")
|
//{
|
// workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
|
//}
|
//else if (workPlan.ProcessName == "焊接工序")
|
//{
|
// workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
|
//}
|
workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
|
workTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
|
|
await workPlanRepository.UpdateAsync(workPlan);
|
|
Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
|
{
|
{ $"{processName}_ProductID", workPlan.PipeSpecCode },
|
{ $"{processName}管段编码", workPlan.PipeSpecCode },
|
{ $"{processName}管段名称", workPlan.PipeSectionName },
|
{ $"{processName}原料管批次", callMaterialOrder.MaterialBatch },
|
{ $"{processName}原料管型号", callMaterialOrder.MaterialMode },
|
{ $"{processName}原料管标识", callMaterialOrder.DataIdentifier },
|
{ $"{processName}项目号", workPlan.ProjectNumber },
|
{ $"{processName}船号", workPlan.ShipNumber },
|
|
//采集数据模拟写入
|
{ $"{processName}压力", "10.0 MPa" },
|
{ $"{processName}速度", "18mm/s"},
|
|
{ $"{processName}人", myCurrentUser.UserAccount},
|
{ $"{processName}间隙","15mm"},
|
{ $"{processName}位置", "10,23,24"},
|
};
|
_variableService.WriteValueAsync(keyValuePairs);
|
|
|
#endregion
|
|
await uow.CompleteAsync();
|
|
// 返回结果
|
var response = new MesOrderResponse
|
{
|
Code = "200",
|
Message = "处理成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
catch (Exception)
|
{
|
await uow.RollbackAsync();
|
throw;
|
}
|
finally
|
{
|
|
}
|
|
|
|
#endregion
|
}
|
|
|
|
/// <summary>
|
/// 装配/焊接工序完工
|
/// </summary>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="input"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
public async Task<MesOrderResponse> CompleteAssemblyProcess(IServiceProvider _serviceProvider, CompleteAssemblyProcessInput input, MyCurrentUser myCurrentUser)
|
{
|
//1、记录分拣记录表
|
//2、更新作业计划表的状态 =已分拣
|
//3、写入 分拣变量
|
//4、写入追溯报表
|
//5、物料组盘
|
|
if (string.IsNullOrEmpty(input.PipeSpecCode))
|
{
|
throw new UserFriendlyException($"管段编码不能为空");
|
}
|
|
|
|
|
#region 事务
|
|
using var scope = _serviceProvider.CreateScope();
|
var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
|
using var uow = unitOfWorkManager.Begin(requiresNew: true);
|
|
try
|
{
|
#region 数据处理
|
|
VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
|
var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
|
var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
|
var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
|
var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
|
var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
|
var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
|
var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
|
var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
|
var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();
|
|
string processName = "";
|
var firstWorkTask = await workTaskAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
|
if (firstWorkTask == null)
|
{
|
throw new UserFriendlyException($"找不到作业计划");
|
}
|
//物料参数列表
|
var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
|
if (firstWorkPlan == null)
|
{
|
throw new UserFriendlyException($"找不到作业计划");
|
}
|
if (firstWorkPlan.ProcessName == "装配工序")
|
{
|
processName = "装配";
|
}
|
else if (firstWorkPlan.ProcessName == "焊接工序")
|
{
|
processName = "焊接";
|
}
|
|
await CompleteHandleOutStoreFinish(_serviceProvider, processName, true);
|
|
//根据工序名获取工序对象
|
var workSection = await _workSectionManager.GetByNameAsync($"{processName}工序");
|
var workStation = await _workStationManager.GetByNameAsync($"{processName}工位");
|
//写入追溯报表
|
var finishTime = DateTime.Now;
|
TraceModel traceModel = new TraceModel()
|
{
|
SerialNumber = input.PipeSpecCode,
|
WorkSectionId = workSection.Id,
|
WorkSectionName = workSection.Name,
|
WorkStationName = workStation.Name,
|
|
FinishTime = finishTime,
|
IsQualified = true,
|
UnqualifiedReason = "",
|
ProductModel = "",
|
ProductName = "",
|
|
};
|
traceModel.Params = new List<TraceParamModel>();
|
foreach (var item in workSection.ProcessParameters)
|
{
|
var value = "ssss";
|
traceModel.Params.Add(new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = value.SafeString()
|
});
|
}
|
|
firstWorkTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
|
await workTaskRepository.UpdateAsync(firstWorkTask);
|
|
firstWorkPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
|
await workPlanRepository.UpdateAsync(firstWorkPlan);
|
|
var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == firstWorkPlan.DataIdentifier);
|
|
var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
|
var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
|
var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
|
var rawPipe_ProjectNumber = await materialProvider.FindByNameAsync("项目号");
|
var rawPipe_ShipNumber = await materialProvider.FindByNameAsync("船号");
|
List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
|
foreach (var item in workSection.MaterialParameters)
|
{
|
if (item.Name == "原料管型号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_MaterialMode.MaterialId,
|
MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
|
Value = firstWorkPlan.MaterialMode
|
|
});
|
}
|
if (item.Name == "原料管标识")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_DataIdentifier.MaterialId,
|
MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
|
Value = firstWorkPlan.DataIdentifier,
|
|
});
|
}
|
if (item.Name == "原料管批次")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_Batch.MaterialId,
|
MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
|
Value = callMaterialOrder.MaterialBatch,//批次暂时写死
|
|
});
|
}
|
if (item.Name == "项目号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_ProjectNumber.MaterialId,
|
MaterialDetailId = rawPipe_ProjectNumber.MaterialDetails.First().Id,
|
Value = firstWorkPlan.ProjectNumber,
|
|
});
|
}
|
if (item.Name == "船号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_ShipNumber.MaterialId,
|
MaterialDetailId = rawPipe_ShipNumber.MaterialDetails.First().Id,
|
Value = firstWorkPlan.ShipNumber,
|
|
});
|
}
|
};
|
|
//配置过程参数(采集参数、配方参数)
|
traceModel.Params = new List<TraceParamModel>();
|
foreach (var item in workSection.ProcessParameters)
|
{
|
string _value = "";
|
|
//采集参数
|
ReadWriteResult<IVariableValue?>? _getValue = null;
|
if (item.Name == $"{processName}压力")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}压力");
|
}
|
if (item.Name == $"{processName}位置")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}位置");
|
}
|
if (item.Name == $"{processName}速度")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}速度");
|
}
|
_value = _getValue?.Content?.Value?.SafeString().ToString();
|
|
if (item.Name == $"{processName}间隙")
|
{
|
_value = "15mm";
|
}
|
if (item.Name == $"{processName}人")
|
{
|
_value = myCurrentUser.UserAccount;
|
}
|
//item.Key
|
TraceParamModel traceParamModel = new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = _value
|
};
|
traceModel.Params.Add(traceParamModel);
|
};
|
foreach (var item in workSection.FormulaParameters)
|
{
|
string _value = "";
|
|
//采集参数
|
ReadWriteResult<IVariableValue?>? _getValue = null;
|
if (item.Name == $"{processName}压力")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}压力");
|
if (item.Name == $"{processName}位置")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}位置");
|
}
|
if (item.Name == $"{processName}速度")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}速度");
|
}
|
_value = _getValue?.Content?.Value?.SafeString().ToString();
|
if (item.Name == $"{processName}间隙")
|
{
|
_value = "15mm";
|
}
|
if (item.Name == $"{processName}人")
|
{
|
_value = myCurrentUser.UserAccount;
|
}
|
//item.Key
|
TraceParamModel traceParamModel = new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = _value
|
};
|
traceModel.Params.Add(traceParamModel);
|
};
|
|
traceModel.MaterialParams = _MaterialParams;
|
|
await traceProvider.CreateTraceAsync(traceModel);
|
|
|
|
#endregion
|
|
await uow.CompleteAsync();
|
|
var response = new MesOrderResponse
|
{
|
Code = "200",
|
Data = "",
|
Message = "处理成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
catch (Exception)
|
{
|
await uow.RollbackAsync();
|
throw;
|
}
|
finally
|
{
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#region 法兰冲码
|
|
|
/// <summary>
|
///下发法兰冲码 开工
|
/// </summary>
|
/// <param name="input"></param>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
/// <exception cref="UserFriendlyException"></exception>
|
public async Task<MesOrderResponse> SendFlangeCode_StartProduction(SendFlangeCodeInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
|
{
|
if (string.IsNullOrEmpty(input.TaskCode.ToString()))
|
{
|
throw new UserFriendlyException("任务编码不能为空");
|
}
|
|
string processName = "法兰冲码";
|
|
VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
|
var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
|
var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
|
var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
|
var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
|
var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
|
var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();
|
|
var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
|
|
|
// 查找数据
|
var workTask = await workTaskRepository.GetSingleByFilterAsync(x => x.Son_TaskCode == input.Son_TaskCode);
|
if (workTask == null)
|
{
|
throw new UserFriendlyException($"没有找到子任务编号{input.Son_TaskCode}的任务数据");
|
}
|
if (workTask.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.未生产)
|
{
|
throw new UserFriendlyException($"子任务编号{input.Son_TaskCode}的任务状态不是'{Domain.Shared.Enums.WorkPlanStatusEnum.未生产.ToString()}'");
|
}
|
var workPlan = await workPlanRepository.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
|
if (workPlan == null)
|
{
|
throw new UserFriendlyException($"找不到作业计划");
|
}
|
|
|
// 验证状态
|
if (workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.暂停中 && workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.未生产)
|
{
|
//暂时注释
|
//throw new UserFriendlyException($"任务编码 '{input.TaskCode}' 的录状态为 '{workPlan.WorkPlanStatus}'，不允许开工");
|
}
|
|
var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == workPlan.DataIdentifier);
|
#region 事务
|
|
using var scope = _serviceProvider.CreateScope();
|
var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
|
using var uow = unitOfWorkManager.Begin(requiresNew: true);
|
|
try
|
{
|
#region 数据处理
|
|
//1、更新作业计划表为 生产中
|
//2、给PLC发工艺参数指令,并写入 plc中 产品id
|
//if (workPlan.ProcessName == "装配工序")
|
//{
|
// workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
|
//}
|
//else if (workPlan.ProcessName == "焊接工序")
|
//{
|
// workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
|
//}
|
workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
|
workTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
|
|
await workPlanRepository.UpdateAsync(workPlan);
|
|
await workTaskRepository.UpdateAsync(workTask);
|
|
Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
|
{
|
{ $"{processName}_ProductID", workPlan.PipeSpecCode },
|
{ $"{processName}管段编码", workPlan.PipeSpecCode },
|
{ $"{processName}管段名称", workPlan.PipeSectionName },
|
{ $"{processName}原料管批次", callMaterialOrder.MaterialBatch },
|
{ $"{processName}原料管型号", callMaterialOrder.MaterialMode },
|
{ $"{processName}原料管标识", callMaterialOrder.DataIdentifier },
|
{ $"{processName}项目号", workPlan.ProjectNumber },
|
{ $"{processName}船号", workPlan.ShipNumber },
|
|
//采集数据模拟写入
|
{ $"{processName}压力", "10.0 MPa" },
|
{ $"{processName}速度", "18mm/s"},
|
|
{ $"{processName}内容", workTask.PipeAllowableStress},
|
|
{ $"{processName}人", myCurrentUser.UserAccount},
|
{ $"{processName}间隙","15mm"},
|
{ $"{processName}位置", "10,23,24"},
|
};
|
_variableService.WriteValueAsync(keyValuePairs);
|
|
|
#endregion
|
|
await uow.CompleteAsync();
|
|
// 返回结果
|
var response = new MesOrderResponse
|
{
|
Code = "200",
|
Message = "处理成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
catch (Exception)
|
{
|
await uow.RollbackAsync();
|
throw;
|
}
|
finally
|
{
|
|
}
|
|
|
|
#endregion
|
}
|
|
|
/// <summary>
|
/// 下发法兰冲码 完工
|
/// </summary>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="input"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
public async Task<MesOrderResponse> SendFlangeCode_CompleteAssemblyProcess(IServiceProvider _serviceProvider, CompleteAssemblyProcessInput input, MyCurrentUser myCurrentUser)
|
{
|
//1、记录分拣记录表
|
//2、更新作业计划表的状态 =已分拣
|
//3、写入 分拣变量
|
//4、写入追溯报表
|
//5、物料组盘
|
|
if (string.IsNullOrEmpty(input.PipeSpecCode))
|
{
|
throw new UserFriendlyException($"管段编码不能为空");
|
}
|
|
|
|
|
#region 事务
|
|
using var scope = _serviceProvider.CreateScope();
|
var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
|
using var uow = unitOfWorkManager.Begin(requiresNew: true);
|
|
try
|
{
|
#region 数据处理
|
|
VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
|
var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
|
var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
|
var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
|
var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
|
var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
|
var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
|
var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
|
var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
|
var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();
|
|
string processName = "法兰冲码";
|
var firstWorkTask = await workTaskAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == (input.ProcessName));
|
if (firstWorkTask == null)
|
{
|
throw new UserFriendlyException($"找不到作业计划");
|
}
|
//物料参数列表
|
var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == "装配工序");
|
if (firstWorkPlan == null)
|
{
|
throw new UserFriendlyException($"找不到作业计划");
|
}
|
|
await CompleteHandleOutStoreFinish(_serviceProvider, processName, true);
|
|
//根据工序名获取工序对象
|
var workSection = await _workSectionManager.GetByNameAsync($"{processName}工序");
|
var workStation = await _workStationManager.GetByNameAsync($"{processName}工位");
|
//写入追溯报表
|
var finishTime = DateTime.Now;
|
TraceModel traceModel = new TraceModel()
|
{
|
SerialNumber = input.PipeSpecCode,
|
WorkSectionId = workSection.Id,
|
WorkSectionName = workSection.Name,
|
WorkStationName = workStation.Name,
|
|
FinishTime = finishTime,
|
IsQualified = true,
|
UnqualifiedReason = "",
|
ProductModel = "",
|
ProductName = "",
|
|
};
|
traceModel.Params = new List<TraceParamModel>();
|
foreach (var item in workSection.ProcessParameters)
|
{
|
var value = "ssss";
|
traceModel.Params.Add(new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = value.SafeString()
|
});
|
}
|
|
firstWorkTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
|
await workTaskRepository.UpdateAsync(firstWorkTask);
|
|
//这个地方不改数据
|
//firstWorkPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
|
//await workPlanRepository.UpdateAsync(firstWorkPlan);
|
|
var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == firstWorkPlan.DataIdentifier);
|
|
var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
|
var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
|
var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
|
var rawPipe_ProjectNumber = await materialProvider.FindByNameAsync("项目号");
|
var rawPipe_ShipNumber = await materialProvider.FindByNameAsync("船号");
|
List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
|
foreach (var item in workSection.MaterialParameters)
|
{
|
if (item.Name == "原料管型号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_MaterialMode.MaterialId,
|
MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
|
Value = firstWorkPlan.MaterialMode
|
|
});
|
}
|
if (item.Name == "原料管标识")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_DataIdentifier.MaterialId,
|
MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
|
Value = firstWorkPlan.DataIdentifier,
|
|
});
|
}
|
if (item.Name == "原料管批次")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_Batch.MaterialId,
|
MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
|
Value = callMaterialOrder.MaterialBatch,//批次暂时写死
|
|
});
|
}
|
if (item.Name == "项目号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_ProjectNumber.MaterialId,
|
MaterialDetailId = rawPipe_ProjectNumber.MaterialDetails.First().Id,
|
Value = firstWorkPlan.ProjectNumber,
|
|
});
|
}
|
if (item.Name == "船号")
|
{
|
_MaterialParams.Add(new TraceMaterialModel()
|
{
|
Key = item.Key,
|
Quantity = 1,
|
MaterialId = rawPipe_ShipNumber.MaterialId,
|
MaterialDetailId = rawPipe_ShipNumber.MaterialDetails.First().Id,
|
Value = firstWorkPlan.ShipNumber,
|
|
});
|
}
|
};
|
|
//配置过程参数(采集参数、配方参数)
|
traceModel.Params = new List<TraceParamModel>();
|
foreach (var item in workSection.ProcessParameters)
|
{
|
string _value = "";
|
|
//采集参数
|
ReadWriteResult<IVariableValue?>? _getValue = null;
|
if (item.Name == $"{processName}压力")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}压力");
|
}
|
if (item.Name == $"{processName}位置")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}位置");
|
}
|
if (item.Name == $"{processName}速度")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}速度");
|
}
|
_value = _getValue?.Content?.Value?.SafeString().ToString();
|
|
if (item.Name == $"{processName}间隙")
|
{
|
_value = "15mm";
|
}
|
if (item.Name == $"{processName}人")
|
{
|
_value = myCurrentUser.UserAccount;
|
}
|
//item.Key
|
TraceParamModel traceParamModel = new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = _value
|
};
|
traceModel.Params.Add(traceParamModel);
|
};
|
foreach (var item in workSection.FormulaParameters)
|
{
|
string _value = "";
|
|
//采集参数
|
ReadWriteResult<IVariableValue?>? _getValue = null;
|
if (item.Name == $"{processName}压力")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}压力");
|
}
|
if (item.Name == $"{processName}位置")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}位置");
|
}
|
if (item.Name == $"{processName}速度")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}速度");
|
}
|
if (item.Name == $"{processName}内容")
|
{
|
_getValue = await _variableService.ReadValueAsync($"{processName}内容");
|
}
|
_value = _getValue?.Content?.Value?.SafeString().ToString();
|
|
if (item.Name == $"{processName}间隙")
|
{
|
_value = "15mm";
|
}
|
if (item.Name == $"{processName}人")
|
{
|
_value = myCurrentUser.UserAccount;
|
}
|
//item.Key
|
TraceParamModel traceParamModel = new TraceParamModel()
|
{
|
Key = item.Key,
|
Value = _value
|
};
|
traceModel.Params.Add(traceParamModel);
|
};
|
|
traceModel.MaterialParams = _MaterialParams;
|
|
await traceProvider.CreateTraceAsync(traceModel);
|
|
|
|
#endregion
|
|
await uow.CompleteAsync();
|
|
var response = new MesOrderResponse
|
{
|
Code = "200",
|
Data = "",
|
Message = "处理成功",
|
Time = DateTime.UtcNow
|
};
|
return response;
|
}
|
catch (Exception)
|
{
|
await uow.RollbackAsync();
|
throw;
|
}
|
finally
|
{
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
/// <summary>
|
/// 公共处理 响应出站完成信号
|
/// </summary>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="input"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
public async Task CompleteHandleOutStoreFinish(IServiceProvider _serviceProvider, string processName, bool isOutResult)
|
{
|
|
VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
|
|
Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
|
{
|
{ $"{processName}出站完成",isOutResult},
|
{ $"{processName}出站结果",isOutResult? "成功":""},
|
};
|
await _variableService.WriteValueAsync(keyValuePairs);
|
|
}
|
|
|
/// <summary>
|
/// 分拣时获取生产计划和分配区域
|
/// </summary>
|
/// <param name="input"></param>
|
/// <param name="_serviceProvider"></param>
|
/// <param name="myCurrentUser"></param>
|
/// <returns></returns>
|
/// <exception cref="UserFriendlyException"></exception>
|
public async Task<CmsApiResponse<PickOutput>> GetPickRetAsync(GetWorkPlanInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
|
{
|
|
|
var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
|
var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
|
var _workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
|
var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
|
var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
|
|
// 查找数据
|
|
WorkPlanDto workPlanDto = await _workPlanAppService.FindSingleByFilterAsync(input);
|
|
//TODO:这里调用wms的库存查询接口
|
try
|
{
|
GetWmsMaterialStockInput param = new GetWmsMaterialStockInput()
|
{
|
RedundantField1 = workPlanDto.ProcessRouteNumber,
|
RedundantField1_FilterMode = SearchFilterModeEnum.精准查询
|
};
|
|
string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
|
string url = baseUrl + "LMesOperate/FindListByFilter";
|
string json = JsonConvert.SerializeObject(param);
|
var result = HttpApiRequest.HttpPost(url, json);
|
var res = JsonConvert.DeserializeObject<CmsApiResponse<List<WmsMaterialStockDto>>>(result);
|
if (res.Code == 200)
|
{
|
var retData = res.Data as List<WmsMaterialStockDto>;
|
var data = new PickOutput()
|
{
|
WorkPlan = workPlanDto,
|
PlaceNo = "",//待赋值
|
ContinerNo = ""//待赋值
|
};
|
if (retData?.Count > 0)
|
{
|
data.PlaceNo = retData.First().PlaceNo;
|
data.ContinerNo = retData.First().ContainerNo;
|
}
|
|
var response = new CmsApiResponse<PickOutput>
|
{
|
Code = 200,
|
Data = data,
|
Message = "处理成功",
|
};
|
return response;
|
|
}
|
else
|
{
|
throw new UserFriendlyException(res.Message);
|
};
|
//*/
|
//模拟
|
//var data = new PickOutput()
|
//{
|
// WorkPlan = workPlanDto,
|
// PlaceNo = "",//待赋值
|
// ContinerNo = ""//待赋值
|
//};
|
//var response = new CmsApiResponse<PickOutput>
|
//{
|
// Code = 200,
|
// Data = data,
|
// Message = "处理成功",
|
//};
|
//return response;
|
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
}
|
|
/// <summary>
|
/// 管段编码是否存在库存中
|
/// </summary>
|
/// <param name="pipeSpecCode"></param>
|
/// <returns></returns>
|
/// <exception cref="UserFriendlyException"></exception>
|
public async Task<WmsMaterialStockDto> IsExistInWms(string pipeSpecCode)
|
{
|
//TODO:这里调用wms的库存查询接口
|
try
|
{
|
GetWmsMaterialStockInput param = new GetWmsMaterialStockInput()
|
{
|
RedundantField2 = pipeSpecCode,
|
RedundantField2_FilterMode = SearchFilterModeEnum.精准查询
|
};
|
|
string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
|
string url = baseUrl + "LMesOperate/FindListByFilter";
|
string json = JsonConvert.SerializeObject(param);
|
var result = HttpApiRequest.HttpPost(url, json);
|
var res = JsonConvert.DeserializeObject<CmsApiResponse<List<WmsMaterialStockDto>>>(result);
|
if (res.Code == 200)
|
{
|
var retData = res.Data as List<WmsMaterialStockDto>;
|
if (retData?.Count > 0)
|
{
|
return retData.First();
|
}
|
return null;
|
|
}
|
else
|
{
|
throw new UserFriendlyException(res.Message);
|
};
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
}
|
|
/// <summary>
|
/// 生成随机的WmsTaskNo
|
/// </summary>
|
/// <returns>随机生成的任务编号</returns>
|
private string GenerateRandomTaskNo()
|
{
|
// 获取当前时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
|
long timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
|
|
// 生成前缀
|
return $"WMS{timestamp}";
|
}
|
|
private string GenerateRandomBatch()
|
{
|
// 获取当前时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
|
long timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
|
|
// 生成前缀
|
return $"Batch{timestamp}";
|
}
|
}
|
