InOutPut
/
Put_MES
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
天津投入产出系统后端
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
144 Commits
1 Branch
0 Tags
143 MiB
 
 
 
 
 
 
Tree: 760c56f8c3
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '760c56f8c3'
${ noResults }
Put_MES/APPQ5/QMAPP.FJC.BLL/Operation/MainOperationBLL.cs

5184 lines
230 KiB
Raw Blame History

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using QMFrameWork.Common.Encrypt;
using QMFrameWork.Data;
using QMAPP.FJC.DAL.Operation;
using QMAPP.FJC.Entity.Operation;
using QMAPP.BLL;
using QMAPP.Entity;
using QMAPP.FJC.BLL.Dict;
using QMAPP.FJC.BLL.Basic;
using QMAPP.FJC.DAL.Basic;
using QMAPP.FJC.Entity.Basic;
using QMFrameWork.Log;
using QMAPP.FJC.Entity;
using QMAPP.FJC.DAL.FileCopy;
using QMFrameWork.Common.Serialization;
using System.Threading;
using QMAPP.FJC.Entity.ProcessParameter;
//using QMAPP.FJC.DAL.ProcessParameter;
using QMAPP.FJC.DAL;
using QMFrameWork.Common.Task;
using QMAPP.MD.Entity;
namespace QMAPP.FJC.BLL.Operation
{
/// <summary>
///　模块编号：M13-2
///　作 用：加工记录
///　作 者：单雨春
///　编写日期：2015年06月04日
///</summary>
public class MainOperationBLL : BaseBLL
{
#region 获取列表
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <param name="page">数据页</param>
/// <returns>数据页</returns>
public DataResult<DataPage> GetListWithParameter(MainOperation condition, DataPage page)
{
DataResult<DataPage> dataResult = new DataResult<DataPage>();
try
{
#region 获得加工参数标准值
var conditionPParameter = new ProcessParameter
{
//MACHINECODDE = condition.MACHINECODDE,
WORKCELL_CODE=condition.WORKCELL_CODE,
};
var listPParameter = new ProcessParameterDAL().GetList(conditionPParameter);
if (listPParameter == null || listPParameter.Count == 0)
{
dataResult.IsSuccess = false;
dataResult.Msg = QMAPP.FJC.Entity.Resource.NotSetProcessParameter;
dataResult.Result = new DataPage();
dataResult.Result.Result = new DataTable();
return dataResult;
}
#endregion
#region 获得加工记录及加工参数
condition.SelectCollumns = String.Join(",", listPParameter.Select(o => o.PARANAME));
condition.PARATABLENAME = listPParameter.FirstOrDefault().PARATABLENAME;
dataResult.Result = new MainOperationDAL().GetListWithParameter(condition, page);
if (dataResult.Result.Result == null)
{
dataResult.IsSuccess = false;
dataResult.Msg = QMAPP.FJC.Entity.Resource.NothingData;
dataResult.Result.Result = new DataTable();
return dataResult;
}
DataTable dtResult = dataResult.Result.Result as DataTable;
DictManageBLL dictColumnName = new DictManageBLL(DictKind.MAINOPERATIONSEARCHFORM);
DictManageBLL dictProcessType = new DictManageBLL(DictKind.PROCESSTYPE);
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
DictManageBLL dictLJStatus = new DictManageBLL(DictKind.LJSTATUS);
DictManageBLL dictOperateState = new DictManageBLL(DictKind.OPERATESTATE);
IList<DataColumn> listDelColumn = new List<DataColumn>();
//转换枚举描述
foreach (DataRow item in dtResult.Rows)
{
item["PROCESSTYPE"] = dictProcessType.GetDictValue(item["PROCESSTYPE"].ToString());
item["PRODUCTTYPE"] = dictProductType.GetDictValue(item["PRODUCTTYPE"].ToString());
item["STATUS"] = dictLJStatus.GetDictValue(item["STATUS"].ToString());
item["OPERATESTATE"] = dictOperateState.GetDictValue(item["OPERATESTATE"].ToString());
}
//设置标题
foreach (var item in dtResult.Columns.Cast<DataColumn>())
{
if (item.ColumnName == "OPERATEDDATESTR" || item.ColumnName == "CREATEDATESTR")
{
//移除原来datetime类型的OPERATEDDATE、CREATEDATE
listDelColumn.Add(item);
}
else
{
var strColumnName = dictColumnName.GetDictValue(item.ColumnName);
if (string.IsNullOrEmpty(strColumnName))
{
var entityParam = listPParameter.FirstOrDefault(o => o.PARANAME == item.ColumnName);
if (entityParam != null)
{
strColumnName = entityParam.PARADESCRIBE;
}
}
if (!string.IsNullOrEmpty(strColumnName))
{
item.ColumnName = strColumnName;
}
else
{
listDelColumn.Add(item);
}
}
}
//移除
foreach (var item in listDelColumn)
{
dtResult.Columns.Remove(item);
}
dataResult.IsSuccess = true;
#endregion
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录-获取列表"
});
dataResult.IsSuccess = false;
dataResult.Msg = Resource.SystemException;
}
return dataResult;
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <param name="page">数据页</param>
/// <returns>数据页</returns>
public DataPage GetList(MainOperation condition, DataPage page)
{
try
{
//获取信息列表
DataPage dataPage = new MainOperationDAL().GetList(condition, page);
#region 转换状态
List<MainOperation> list = dataPage.Result as List<MainOperation>;
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.OPERATESTATE);
foreach (MainOperation item in list)
{
//工序类别
item.OPERATESTATETEXT = operationStatusBll.GetDictValue(item.OPERATESTATE);
}
#endregion
return dataPage;
}
catch (Exception ex)
{
throw ex;
}
}
public DataPage GetOperationList(MainOperation condition, DataPage page)
{
try
{
//获取信息列表
DataPage dataPage = new MainOperationDAL().GetOperationList(condition, page);
#region 转换状态
List<MainOperation> list = dataPage.Result as List<MainOperation>;
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.OPERATESTATE);
foreach (MainOperation item in list)
{
//工序类别
item.OPERATESTATETEXT = operationStatusBll.GetDictValue(item.OPERATESTATE);
}
#endregion
return dataPage;
}
catch (Exception ex)
{
throw ex;
}
}
public DataPage GetOperationListNew(MainOperation condition, DataPage page)
{
try
{
//获取信息列表
DataPage dataPage = new MainOperationDAL().GetOperationListNew(condition, page);
#region 转换状态
List<MainOperation> list = dataPage.Result as List<MainOperation>;
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.OPERATESTATE);
foreach (MainOperation item in list)
{
//工序类别
item.OPERATESTATETEXT = operationStatusBll.GetDictValue(item.OPERATESTATE);
}
#endregion
return dataPage;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <returns>全部数据</returns>
public List<MainOperation> GetAllList(MainOperation condition)
{
try
{
List<MainOperation> list = new MainOperationDAL().GetList(condition);
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.OPERATESTATE);
DictManageBLL processTypeBll = new DictManageBLL(DictKind.PROCESSTYPE);
foreach (MainOperation item in list)
{
//工序类别
item.OPERATESTATETEXT = operationStatusBll.GetDictValue(item.OPERATESTATE);
item.PROCESSTYPETEXT = processTypeBll.GetDictValue(item.PROCESSTYPE);
}
return list;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <returns>全部数据</returns>
public List<MainOperation> GetOperationRecords(string productcode)
{
try
{
List<MainOperation> list = new MainOperationDAL().GetOperationRecords(productcode);
ProcessParameterDAL dal = new ProcessParameterDAL();
var allparms = dal.GetList(new ProcessParameter { });
foreach (var rd in list)
{
rd.ParamColumns = allparms.Where(p => p.MACHINECODDE == rd.MACHINECODDE).ToList();
rd.PARATABLENAME = string.Join(",", rd.ParamColumns.GroupBy(p => p.PARATABLENAME).Select(p => p.Key).ToArray());
rd.SelectCollumns = string.Join(",", rd.ParamColumns.Select(p => p.PARANAME).ToArray());
if (rd.ParamColumns.Count > 0)
{
rd.ViewName = rd.ParamColumns.FirstOrDefault().MEMO;
}
}
return list;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取列表(用于服务)
/// </summary>
/// <param name="condition">条件</param>
/// <returns>全部数据</returns>
public List<MainOperation> GetListUsedByCell(MainOperation condition)
{
try
{
List<MainOperation> list = new MainOperationDAL().GetList(condition);
return list;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 根据扫描条码获取之前工序下拉列表(返修winform)
/// </summary>
/// <param name="condition">条件</param>
/// <returns>全部数据</returns>
public List<MainOperation> GetMainOperationWorkCell(string ProductCode, bool isINJECTION)
{
try
{
List<MainOperation> list = new MainOperationDAL().GetMainOperationWorkCell(ProductCode, isINJECTION);
return list;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取统计列表
/// </summary>
/// <param name="condition">条件</param>
/// <returns>全部数据</returns>
public DataResult<DataTable> GetListForstatistic(MainOperation condition)
{ DataResult<DataTable> dr = new DataResult<DataTable>();
try
{
DataTable dt = new MainOperationDAL().GetListForstatistic(condition);
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.PRODUCTTYPE);
foreach (DataRow row in dt.Rows)
{
//工序类别
row["产品类别"] = operationStatusBll.GetDictValue(row["产品类别"].ToString());
}
dr.IsSuccess = true;
dr.Result = dt;
}
catch (Exception ex)
{
dr.IsSuccess = false;
dr.Msg = ex.Message;
}
return dr;
}
public DataResult<DataTable> GetListForstatisticWithColor(MainOperation condition)
{
DataResult<DataTable> dr = new DataResult<DataTable>();
try
{
DataTable dt = new MainOperationDAL().GetListForStatisticWithColor(condition);
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.PRODUCTTYPE);
foreach (DataRow row in dt.Rows)
{
//工序类别
//row["产品类别"] = operationStatusBll.GetDictValue(row["产品类别"].ToString());
}
dr.IsSuccess = true;
dr.Result = dt;
}
catch (Exception ex)
{
dr.IsSuccess = false;
dr.Msg = ex.Message;
}
return dr;
}
public DataResult<DataTable> GetListForstatisticWithColor2(MainOperation condition)
{
DataResult<DataTable> dr = new DataResult<DataTable>();
try
{
DataTable dt = new MainOperationDAL().GetListForStatisticWithColor2(condition);
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.PRODUCTTYPE);
foreach (DataRow row in dt.Rows)
{
//工序类别
//row["产品类别"] = operationStatusBll.GetDictValue(row["产品类别"].ToString());
}
dr.IsSuccess = true;
dr.Result = dt;
}
catch (Exception ex)
{
dr.IsSuccess = false;
dr.Msg = ex.Message;
}
return dr;
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <returns>全部数据</returns>
public MainOperation GetByCondition(MainOperation condition)
{
try
{
List<MainOperation> list = new MainOperationDAL().GetList(condition);
if (list.Count > 0)
{
DictManageBLL operationStatusBll = new DictManageBLL(DictKind.OPERATESTATE);
//工序类别
list[0].OPERATESTATETEXT = operationStatusBll.GetDictValue(list[0].OPERATESTATE);
return list[0];
}
return null;
}
catch (Exception ex)
{
throw ex;
}
}
#endregion
#region 产品加工追溯
#region 获取列表
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <param name="page">数据页</param>
/// <returns>数据页</returns>
public DataResult<DataPage> GetMainOperationReviewList(MainOperation condition, DataPage page)
{
DataResult<DataPage> result = new DataResult<DataPage>();
DataPage dataPage = null;
try
{
if (string.IsNullOrEmpty(condition.PRODUCTCODE)
&& string.IsNullOrEmpty(condition.MAINCODE)
)
{
dataPage = new DataPage();
dataPage.Result = new List<MainOperation>();
result.Result = dataPage;
return result;
}
dataPage = new MainOperationDAL().GetMainOperationReviewList(condition, page);
#region 转换零件类别、物料类别显示类型
List<MainOperation> machineInfoList = dataPage.Result as List<MainOperation>;
DictManageBLL dictProductStatusBll = new DictManageBLL(DictKind.PRODUCTSTATUS);
DictManageBLL dictProcessStatusBll = new DictManageBLL(DictKind.PROCESSSTATUS);
DictManageBLL dictProcessTypeBll = new DictManageBLL(DictKind.PROCESSTYPE);
foreach (MainOperation m in machineInfoList)
{
//产品状态
m.STATUS = dictProductStatusBll.GetDictValue(m.STATUS);
//加工状态
m.OPERATESTATE = dictProcessStatusBll.GetDictValue(m.OPERATESTATE);
//工序类别
m.CURRENTPROCESS = dictProcessTypeBll.GetDictValue(m.CURRENTPROCESS);
}
#endregion
result.Result = dataPage;
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录逻辑层-产品加工追溯获取列表！"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw ex;
}
result.IsSuccess = true;
return result;
}
public List<Product> GetMainOperations(Product condition)
{
//DataPage dataPage = new DataPage();
//var desult = new List<ProductInjection>();
//DataResult<DataPage> result = new DataResult<DataPage>();
MainBLL mb = new MainBLL();
try
{
if (string.IsNullOrEmpty(condition.PRODUCTCODE))
{
if (string.IsNullOrEmpty(condition.MAINCODE))
{
return null;
}
var m = mb.GetByCondition(new Main { publicCode = condition.MAINCODE });
if (m == null)
{
return null;
}
condition.PRODUCTCODE = m.EPIDERMISCODE;
}
List<Product> machineInfoList = new MainOperationDAL().GetMainOperations(condition);
#region 转换零件类别、物料类别显示类型
DictManageBLL dictProductStatusBll = new DictManageBLL(DictKind.PRODUCTSTATUS);
DictManageBLL dictProcessStatusBll = new DictManageBLL(DictKind.PROCESSSTATUS);
DictManageBLL dictProcessTypeBll = new DictManageBLL(DictKind.PROCESSTYPE);
//foreach (Product m in machineInfoList)
//{
// //产品条码
// m.PRODUCTCODE = condition.PRODUCTCODE;
// //总成条码
// var main = mb.GetByCondition(new Main { publicCode = condition.PRODUCTCODE });
// if (main != null)
// {
// m.MAINCODE = condition.MAINCODE;
// }
// m.CREATEDATESTR = m.OPERATEDDATE.ToString("yyyy-MM-dd HH:mm:ss");
// //产品状态
// m.STATUS = dictProductStatusBll.GetDictValue(m.STATUS);
// //加工状态
// m.OPERATESTATE = dictProcessStatusBll.GetDictValue(m.OPERATESTATE);
// //工序类别
// m.CURRENTPROCESS = dictProcessTypeBll.GetDictValue(m.CURRENTPROCESS);
//}
#endregion
//result.Result = dataPage;
//result.IsSuccess = true;
return machineInfoList;
}
catch (Exception ex)
{
throw ex;
}
}
#endregion
#region 导出数据
/// <summary>
/// 获取导出的数据
/// </summary>
/// <param name="user">查询条件</param>
/// <returns>数据</returns>
public DataResult<DataTable> GetExportDataForMOR(MainOperation model)
{
DataResult<DataTable> result = new DataResult<DataTable>();
try
{
DataTable dt = new MainOperationDAL().GetExportDataForMOR(model);
#region 转换零件类别、物料类别显示类型
DictManageBLL dictProductStatusBll = new DictManageBLL(DictKind.PRODUCTSTATUS);
DictManageBLL dictProcessStatusBll = new DictManageBLL(DictKind.PROCESSSTATUS);
DictManageBLL dictProcessTypeBll = new DictManageBLL(DictKind.PROCESSTYPE);
foreach (DataRow item in dt.Rows)
{
//产品状态
item["STATUS"] = dictProductStatusBll.GetDictValue(item["STATUS"].ToString());
//加工状态
item["OPERATESTATE"] = dictProcessStatusBll.GetDictValue(item["OPERATESTATE"].ToString());
//工序类别
item["CURRENTPROCESS"] = dictProcessTypeBll.GetDictValue(item["CURRENTPROCESS"].ToString());
}
#endregion
result.Result = dt;
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录逻辑层-产品加工追溯获取导出数据！"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw ex;
}
result.IsSuccess = true;
return result;
}
public DataResult<DataTable> GetExportDataForMORNew(MainOperation model)
{
DataResult<DataTable> result = new DataResult<DataTable>();
try
{
MainBLL mb = new MainBLL();
if (string.IsNullOrEmpty(model.PRODUCTCODE))
{
if (string.IsNullOrEmpty(model.MAINCODE))
{
return null;
}
var m = mb.GetByCondition(new Main { publicCode = model.MAINCODE });
if (m == null)
{
return null;
}
model.PRODUCTCODE = m.EPIDERMISCODE;
}
//List<MainOperation> machineInfoList = new MainOperationDAL().GetMainOperations(condition);
DataTable dt = new MainOperationDAL().GetExportDataForMORNew(model);
#region 转换零件类别、物料类别显示类型
DictManageBLL dictProductStatusBll = new DictManageBLL(DictKind.PRODUCTSTATUS);
DictManageBLL dictProcessStatusBll = new DictManageBLL(DictKind.PROCESSSTATUS);
DictManageBLL dictProcessTypeBll = new DictManageBLL(DictKind.PROCESSTYPE);
foreach (DataRow item in dt.Rows)
{
//产品条码
item["PRODUCTCODE"] = model.PRODUCTCODE;
//总成条码
//var main = mb.GetByCondition(new Main { publicCode = model.PRODUCTCODE });
//if (main != null)
//{
// item["MAINCODE"] = model.MAINCODE;
//}
//item["CREATEDATESTR"] = item["OPERATEDDATE"].ToString("yyyy-MM-dd HH:mm:ss");
//产品状态
item["STATUS"] = dictProductStatusBll.GetDictValue(item["STATUS"].ToString());
//加工状态
item["OPERATESTATE"] = dictProcessStatusBll.GetDictValue(item["OPERATESTATE"].ToString());
//工序类别
item["CURRENTPROCESS"] = dictProcessTypeBll.GetDictValue(item["CURRENTPROCESS"].ToString());
}
#endregion
result.Result = dt;
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录逻辑层-产品加工追溯获取导出数据！"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw ex;
}
result.IsSuccess = true;
return result;
}
#endregion
#endregion
#region 设备加工
/// <summary>
/// 判断是否符合设备模具的加工条件
/// </summary>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public DataResult GetMashineStatus(OperationServiceParam operationServiceParam)
{
DataResult result = new DataResult();
string modelStation = "1";//默认第一个模具
//设置当前设备的当前模具
if (string.IsNullOrEmpty(operationServiceParam.machineInfo.MOLDNUMBER))
{
operationServiceParam.machineInfo.MOLDNUMBER = modelStation;
}
//如果设备存在位置扫描标示
if (operationServiceParam.machineInfo.ISSTATION.Equals(EnumGeter.HAVEORNOT.HAVE.GetHashCode()))
{
#region 调用接口------获取当前的模具位置
List<MachineInfoModels> models = operationServiceParam.machineInfo.MODELS;//设备模具列表
if (models != null && models.Count > 0)//证明有多模具，而且需要获取模具
{
//modelStation = "";//调用接口获取当前模具位置
//算出当前放零件的位置
modelStation = ((Convert.ToInt32(modelStation) + operationServiceParam.machineInfo.MODELSTATIONS) % models.Count).ToString();
operationServiceParam.model = models.Find(m => m.MODELSTATION == modelStation);
}
#endregion
}
result.IsSuccess = true;
return result;
}
/// <summary>
/// 处理零件条码返回零件实体
/// </summary>
/// <param name="productCode">零件条码</param>
/// <param name="operationServiceParam">传递参数</param>
/// <returns>Product--result.IsMain=true当前零件为本体 result.IsMain==false为零件</returns>
public DataResult<Product> ExplainProduct(string productCode, OperationServiceParam operationServiceParam)
{
DataResult<Product> result = new DataResult<Product>();
Product product = new Product();
try
{
#region 1.判断是否重复扫描,重复扫描不做任何操作
int exsitCount = operationServiceParam.productList.FindAll(m => m.PRODUCTCODE == productCode).Count;
if (exsitCount > 0)
{
result.IsSuccess = false;
return result;
}
#endregion
#region 2.获取当前零件信息
Product proSearchModel = new Product();
proSearchModel.PRODUCTCODE = productCode;
//获取产品信息
List<Product> products = new ProductBLL().GetListAndAttrByCondition(proSearchModel).OrderBy(o => o.USINGSTATE).ToList<Product>();
//如果产品数量大于1，那么一定风道信息
if (products.Count > 1)
{
//这里需要额外处理一下
//正常先获取处于本工位的条码信息
product = products.Find(m => m.CURRENTPROCESS == operationServiceParam.processSet.PROCESSTYPE);
//红外焊接工位处理
if (operationServiceParam.processSet.PROCESSTYPE == EnumGeter.ProcessType.hongwaihanjie.GetHashCode().ToString())
{
//获取红外焊接工位未使用的风道
product = products.Find(m =>
m.USINGSTATE == EnumGeter.USINGSTATE.UNUSED.GetHashCode().ToString()
&& m.CURRENTPROCESS == operationServiceParam.processSet.PROCESSTYPE);
//获取铆接工位未使用的风道
if (product == null)
{
product = products.Find(m =>
m.USINGSTATE == EnumGeter.USINGSTATE.UNUSED.GetHashCode().ToString());
}
}
//如果前面的条件过滤了所有的条码信息，表示在铆接和红外焊接的工序两个风道都使用完成
if (product == null)
{
product = products[0];
}
}
else if (products.Count == 1)
{
product = products[0];
if (operationServiceParam.machineInfo.PROCESSTYPE
== EnumGeter.ProcessType.maojie.GetHashCode().ToString()
&& product.CURRENTPROCESS != EnumGeter.ProcessType.maojie.GetHashCode().ToString()
&& productCode.IndexOf("B9B") == 0)
{
//20160612不全注塑丢失的条码信息
//闫永刚
product = InsertProductBack(productCode, operationServiceParam);
}
//2016-7-3 当红外焊接设备扫描了风道时，并且该风道已经使用,这时不能提升该风道已经使用
//因为两个风道使用同一个码，应提提示该风道没有进行铆接操作
//闫永刚
if (operationServiceParam.machineInfo.PROCESSTYPE
== EnumGeter.ProcessType.hongwaihanjie.GetHashCode().ToString()
&& product.USINGSTATE == EnumGeter.USINGSTATE.USED.GetHashCode().ToString()
&& productCode.IndexOf("B9B") == 0)
{
result.IsSuccess = false;
result.Msg = string.Format("{0}未进行铆接操作!", product.PRODUCTCODE);
return result;
}
}
else
{
product = null;
//20160612不全注塑丢失的条码信息
//闫永刚
product = InsertProductBack(productCode, operationServiceParam);
}
#endregion
if (product != null)
{
product.productBasic = new ProductBasicBLL().GetByCode(new ProductBasic { PRODUCTTYPE = product.PRODUCTTYPE });
}
#region 2.1 如果不存在当前零件信息，那么判断是否为外购件，并添加外购件信息
if (product == null)
{
//如果未外购件则添加
//根据条码调取服务获得该条码对应的类别
/////////服务
ProductBasic proBasic = new ProductBasic();
proBasic.PRODUCTTYPE = "";
if (productCode.IndexOf("B9H") == 0)//左格栅
{
proBasic.PRODUCTTYPE = "6";
if (productCode.Length != 18)
{
result.IsSuccess = false;
result.Msg = productCode + "左格栅条码格式错误!\r\n请扫描正确的左格栅条码!";
return result;
}
string colorCode=productCode.Substring(12,3);
if (colorCode != "24A" && colorCode != "6PS"
&& colorCode != "RK1" && colorCode != "AY2")
{
result.IsSuccess = false;
result.Msg = productCode + "左格栅条码颜色信息错误!\r\n请扫描正确的左格栅条码!";
return result;
}
}
else if (productCode.IndexOf("B9I") == 0)//右格栅
{
proBasic.PRODUCTTYPE = "10";
if (productCode.Length != 18)
{
result.IsSuccess = false;
result.Msg = productCode + "右格栅条码格式错误!\r\n请扫描正确的右格栅条码!";
return result;
}
string colorCode = productCode.Substring(12, 3);
if (colorCode != "24A" && colorCode != "6PS"
&& colorCode != "RK1" && colorCode != "AY2")
{
result.IsSuccess = false;
result.Msg = productCode + "右格栅条码颜色信息错误!\r\n请扫描正确的右格栅条码!";
return result;
}
}
else if (productCode.IndexOf("B9J") == 0)//中控支架
{
proBasic.PRODUCTTYPE = "7";
}
else if (productCode.IndexOf("B9K") == 0)//HUD支架
{
proBasic.PRODUCTTYPE = "11";
if (productCode.Length != 18)
{
result.IsSuccess = false;
result.Msg = productCode + "HUD支架条码格式错误!\r\n请扫描正确的HUD支架式条码!";
return result;
}
}
else
{
result.IsSuccess = false;
result.Msg = Resource.OperationProNotFound;
return result;
}
proBasic = new ProductBasicBLL().GetByCode(proBasic);
//获取类别出错
if (proBasic == null)
{
result.Msg = Resource.OperationProTypeError;
result.IsSuccess = false;
return result;
}
//获取判断出该条码属于哪个类别
#region 自制件
if (proBasic.PRODUCTSOURCE.Equals(EnumGeter.PRODUCTSOURCE.SELFMADE.GetHashCode().ToString()))//属于自制
{
//判断当前设备是否接受和发送指令
if (!operationServiceParam.machineInfo.ISCONTROL.Equals(EnumGeter.ISCONTROL.NOSENDNOREAD.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProNotFound;
result.IsSuccess = false;
return result;
}
//只有设备既不接受指令也不发送指令才需要添加
//获取当前零件类别的工序设置的第一道工序
ProcessSet processSet = new ProcessSetBLL().GetByModel(new ProcessSet { PRODUCTTYPE = proBasic.PRODUCTTYPE, PROCESSINDEX = 1 }).Result;
//将当前零件插入零件条码表生成原始记录
Product recorder = new Product();
recorder.PRODUCTCODE = productCode;
recorder.PRODUCTSOURCE = EnumGeter.PRODUCTSOURCE.SELFMADE.GetHashCode().ToString();
recorder.PRODUCTTYPE = proBasic.PRODUCTTYPE;
recorder.STATUS = EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString();
recorder.CURRENTPROCESS = processSet.PROCESSTYPE;
recorder.PRODUCELINE = EnumGeter.PRODUCELINE.B9.ToString();
recorder.OUTFLAG = EnumGeter.PRODUCTOUTFLAG.INLIBRARY.GetHashCode().ToString();
recorder.USINGSTATE = EnumGeter.PRODUCTUSESTATE.UNUSED.GetHashCode().ToString();
recorder.CAPACITY = 1;
recorder.USINGCOUNT = 0;
//如果为表皮的话需要拆解表皮属性
if (recorder.PRODUCTTYPE.Equals(EnumGeter.ProductType.biaopi.GetHashCode().ToString()))
{
//解析条码
ProductAttribute productAttribute = new ProductAttribute();
//搪塑机编号
productAttribute.VAL1 = productCode.Substring(10, 7);
//产品类型
productAttribute.VAL2 = productCode.Substring(17, 2);
//高低配
productAttribute.VAL3 = productCode.Substring(19, 1);
//颜色
productAttribute.VAL4 = productCode.Substring(20, 1);
//腔
productAttribute.VAL5 = productCode.Substring(21, 1);
//模腔
productAttribute.VAL6 = productCode.Substring(22);
//加工日期
productAttribute.VAL7 = DateTime.ParseExact(productCode.Substring(0, 10), "yyMMddHHmm", System.Globalization.CultureInfo.CurrentCulture).ToString("yyyy-MM-dd");
DataResult resultInsert = new ProductBLL().InsertEpidermis(recorder);
if (resultInsert.IsSuccess == false)
{
result.Msg = Resource.OperationProNotFound;
result.IsSuccess = false;
return result;
}
}
else
{
DataResult resultInsert = new ProductBLL().Insert(recorder);
if (resultInsert.IsSuccess == false)
{
result.Msg = Resource.OperationProNotFound;
result.IsSuccess = false;
return result;
}
}
product = new ProductBLL().GetAndAttrByCondition(proSearchModel);
result.Result = product;
result.IsSuccess = true;
}
#endregion
#region 采购件
if (proBasic.PRODUCTSOURCE.Equals(EnumGeter.PRODUCTSOURCE.OUTSOURCING.GetHashCode().ToString()))//属于采购
{
Product pAdd = new Product();
pAdd.PRODUCTTYPE = proBasic.PRODUCTTYPE;
pAdd.PRODUCTCODE = productCode;
pAdd.PRODUCTSOURCE = EnumGeter.PRODUCTSOURCE.OUTSOURCING.GetHashCode().ToString();
pAdd.MACHINENAME = operationServiceParam.machineInfo.MACHINENAME;
pAdd.MACHINECODDE = operationServiceParam.machineInfo.MACHINECODDE;
pAdd.STATUS = EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString();
pAdd.CURRENTPROCESS = operationServiceParam.processSet.PROCESSTYPE;
pAdd.PRODUCELINE = EnumGeter.PRODUCELINE.B9.ToString();
pAdd.PRODUCESHIFTTCODE = "";
pAdd.PRODUCESHIFTNAME = "";
pAdd.OUTFLAG = EnumGeter.PRODUCTOUTFLAG.INLIBRARY.GetHashCode().ToString();
pAdd.USINGSTATE = EnumGeter.PRODUCTUSESTATE.USING.GetHashCode().ToString();
pAdd.CAPACITY = proBasic.CAPATITY;
pAdd.USINGCOUNT = 0;
//调用保存接口
DataResult<Product> resultInsert = new ProductBLL().InsertAndReturn(pAdd);
//保存成功
if (!resultInsert.IsSuccess)
{
result.Msg = resultInsert.Msg;
result.IsSuccess = false;
return result;
}
product = resultInsert.Result;
product.productBasic = proBasic;
}
#endregion
}
#endregion
#region 2.2 设置零件是哪种类别本体还是零件
if (product.PRODUCTTYPE.Equals(EnumGeter.ProductType.biaopi.GetHashCode().ToString())
&& product.USINGSTATE.Equals(EnumGeter.USINGSTATE.USED.GetHashCode().ToString())
&& operationServiceParam.machineInfo.PROCESSTYPE!=EnumGeter.ProcessType.lengdaoruohua.GetHashCode().ToString()
)
{
product.IsMain = true; //该零件为本体
}
else
{
product.IsMain = false;//该零件为零件
}
#region
result.Result = product;
result.IsSuccess = true;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
/// <summary>
/// 插入注塑产品信息
/// </summary>
/// <param name="productCode"></param>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public Product InsertProductBack(string productCode,OperationServiceParam operationServiceParam)
{
Product product = null;
if (productCode.IndexOf("B9A") == 0 || productCode.IndexOf("B9B") == 0
|| productCode.IndexOf("B9C") == 0 || productCode.IndexOf("FJC") == 0
|| productCode.IndexOf("AAA") == 0)
{
Product newRecorder = new Product();
newRecorder.PID = Guid.NewGuid().ToString();
newRecorder.PRODUCTCODE = productCode;
newRecorder.PRODUCTSOURCE = EnumGeter.PRODUCTSOURCE.SELFMADE.GetHashCode().ToString();
newRecorder.STATUS = EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString();
newRecorder.CURRENTPROCESS = "";
newRecorder.PRODUCELINE = EnumGeter.PRODUCELINE.B9.ToString();
newRecorder.OUTFLAG = EnumGeter.PRODUCTOUTFLAG.INLIBRARY.GetHashCode().ToString();
newRecorder.USINGSTATE = EnumGeter.PRODUCTUSESTATE.UNUSED.GetHashCode().ToString();
newRecorder.CAPACITY = 1;
newRecorder.USINGCOUNT = 0;
newRecorder.CURRENTPROCESS = operationServiceParam.processSet.PROCESSTYPE;
#region 初始化零件号
//获取产品零件号
List<MaterialCodeInit> initList = new MaterialCodeInitDAL().GetList(new MaterialCodeInit() { PRODUCT_TYPES = productCode.Substring(0,3) });
if (initList.Count > 0)
{
MaterialCodeInit init = initList[0];
newRecorder.WORKCELL_CODE = init.WORKCELL_CODE;
newRecorder.WORKCENTER_CODE = init.WORKCENTER_CODE;
newRecorder.MATERIAL_CODE = init.MATERIAL_CODE;
newRecorder.WORKLOC_CODE = init.WORKLOC_CODE;
newRecorder.MATERIAL_TYPE = init.MATERIAL_TYPE;
}
#endregion
InsertInjectProduct(newRecorder);
List<Product> proList = new ProductBLL().GetListAndAttrByCondition(newRecorder);
product = proList[0];
#endregion
}
return product;
}
#region 插入注塑产品信息及加工记录
//插入产品记录
//插入注塑加工记录
private void InsertInjectProduct(Product newRecorder)
{
try
{
DateTime dt = Convert.ToDateTime("20" + newRecorder.PRODUCTCODE.Substring(3, 2) + "-" + newRecorder.PRODUCTCODE.Substring(5, 2) + "-" + newRecorder.PRODUCTCODE.Substring(7, 2) + " " + newRecorder.PRODUCTCODE.Substring(9, 2) + ":" + newRecorder.PRODUCTCODE.Substring(11, 2) + ":00");
newRecorder.CREATEDATE = dt;
MainOperation main = new MainOperation();
main.PID = Guid.NewGuid().ToString();
main.PDID = newRecorder.PID;
main.PRODUCTCODE = newRecorder.PRODUCTCODE;
if (newRecorder.PRODUCTCODE.IndexOf("B9A") == 0)
{
main.PROCESSTYPE = EnumGeter.ProcessType.gujiazhusu.GetHashCode().ToString();
main.CURRENTPROCESS = EnumGeter.ProcessType.gujiazhusu.GetHashCode().ToString();
newRecorder.PRODUCTTYPE = EnumGeter.ProductType.gujia.GetHashCode().ToString();
}
if (newRecorder.PRODUCTCODE.IndexOf("B9B") == 0)
{
main.PROCESSTYPE = EnumGeter.ProcessType.fengdaozhusu.GetHashCode().ToString();
main.CURRENTPROCESS = EnumGeter.ProcessType.fengdaozhusu.GetHashCode().ToString();
newRecorder.PRODUCTTYPE = EnumGeter.ProductType.fengdao.GetHashCode().ToString();
}
if (newRecorder.PRODUCTCODE.IndexOf("B9C") == 0)
{
main.PROCESSTYPE = EnumGeter.ProcessType.HUDfengdaozhusu.GetHashCode().ToString();
main.CURRENTPROCESS = EnumGeter.ProcessType.HUDfengdaozhusu.GetHashCode().ToString();
newRecorder.PRODUCTTYPE = EnumGeter.ProductType.HUDfengdao.GetHashCode().ToString();
}
if (newRecorder.PRODUCTCODE.IndexOf("FJC") == 0)
{
main.PROCESSTYPE = EnumGeter.ProcessType.qinangzhijiazhusu.GetHashCode().ToString();
main.CURRENTPROCESS = EnumGeter.ProcessType.qinangzhijiazhusu.GetHashCode().ToString();
newRecorder.PRODUCTTYPE = EnumGeter.ProductType.qinangzhijia.GetHashCode().ToString();
}
if (newRecorder.PRODUCTCODE.IndexOf("AAA") == 0)
{
main.PROCESSTYPE = EnumGeter.ProcessType.qinangzhijiazhusu.GetHashCode().ToString();
main.CURRENTPROCESS = EnumGeter.ProcessType.qinangzhijiazhusu.GetHashCode().ToString();
newRecorder.PRODUCTTYPE = EnumGeter.ProductType.qinangzhijia.GetHashCode().ToString();
}
main.PRODUCTTYPE = newRecorder.PRODUCTTYPE;
main.STATUS = "0";
main.OPERATESTATE = EnumGeter.OPERATESTATE.COMPLETED.GetHashCode().ToString();
main.OPERATEDDATE = dt;
main.PRODUCELINE = "B9";
main.CREATEDATE = dt;
//InjectionParameterSampleDAL sampleDal = new InjectionParameterSampleDAL();
InJectionParameter para = new InJectionParameter();
//para = sampleDal.GetInJectionParameterSample(newRecorder);
para.PID = Guid.NewGuid().ToString();
para.PDID = newRecorder.PID;
para.MOID = main.PID;
para.PRODUCTCODE = newRecorder.PRODUCTCODE;
para.CREATEDATE = dt;
para.OPERATEDATE = dt;
//para.EDATE = dt.ToString("yyyy-MM-dd HH:mm:ss");
newRecorder.MACHINECODDE = para.MACHINECODDE;
newRecorder.MACHINENAME = para.MACHINENAME;
main.MACHINECODDE = para.MACHINECODDE;
main.MACHINENAME = para.MACHINENAME;
MainOperationDAL modal = new MainOperationDAL();
ProductDAL prodal = new ProductDAL();
////InjectionParameterDAL ipdal = new InjectionParameterDAL();
using (IDataSession session = AppDataFactory.CreateMainSession())
{
//ipdal.BaseSession = session;
prodal.BaseSession = session;
modal.BaseSession = session;
session.OpenTs();
prodal.Insert(newRecorder);
modal.Insert(main);
//ipdal.Insert(para);
session.CommitTs();
}
}
catch (Exception ex)
{
throw;
}
}
#endregion
/// <summary>
/// 校验零件
/// </summary>
/// <param name="product"></param>
/// <returns>BackStatus=true 代表 Main、 BackStatus=false 代表 Product</returns>
public DataResult<object> ValidateProudct(Product product)
{
DataResult<object> result = new DataResult<object>();
try
{
if (product.IsMain) //当前零件是本体
{
#region 1.获取本体信息
Main mainSearchModel = new Main();
mainSearchModel.EPIDERMISCODE = product.PRODUCTCODE;
List<Main> mainList = new MainBLL().GetAllList(mainSearchModel);
if (mainList.Count <= 0)
{
result.Msg = Resource.OperationMainNotFound;
result.IsSuccess = false;
return result;
}
Main main = mainList[0];
#region 2.校验出库状态 PROCESSSTATE
if (!main.OUTFLAG.Equals(EnumGeter.OUTFLAG.INWAREHOUSE.GetHashCode().ToString()))
{
result.Msg = "该本体已出库!";
result.IsSuccess = false;
return result;
}
#endregion
//判断加工状态
List<MainOperation> excuteList = this.GetAllList(new MainOperation { PDID = main.PID, OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString() });
if (excuteList.Count > 0)
{
result.Msg = excuteList[0].PRODUCTCODE + "正在" + excuteList[0].PROCESSTYPETEXT + "工序加工中!";
result.IsSuccess = false;
return result;
}
//获取当前工序内容
main.processSets = new ProcessSetBLL().GetListByModel(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString() }).Result;
main.processSet = new ProcessSetBLL().GetByModel(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString(),PROCESSTYPE = main.CURRENTPROCESS}).Result;
#endregion
#region 2.校验加工状态 PROCESSSTATE
if (main.PROCESSSTATE.Equals(EnumGeter.OPERATIONSTATE.PROCESSED.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProductProcessing;
result.IsSuccess = false;
return result;
}
#endregion
#region 3.校验是否合格 STATUS
if (!main.STATUS.Equals(EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProductNotQualified;
result.IsSuccess = false;
return result;
}
#endregion
#region 5.校验当前本体是否加工已经完成 COMPLETEFLAG
if (main.COMPLETEFLAG.Equals(EnumGeter.COMPLETEFLAG.COMPLETED.GetHashCode().ToString()))
{
result.Msg = Resource.OperatProductComplete;
result.IsSuccess = false;
return result;
}
#endregion
result.IsSuccess = true;
result.BackStatus = true;
result.Result = main;
}
if (!product.IsMain)//当前零件为零件
{
#region 2.校验出库状态 PROCESSSTATE
if (!product.OUTFLAG.Equals(EnumGeter.OUTFLAG.INWAREHOUSE.GetHashCode().ToString()))
{
result.Msg = "该零件已出库！";
result.IsSuccess = false;
return result;
}
#endregion
//判断加工状态
List<MainOperation> excuteList = this.GetAllList(new MainOperation { PDID = product.PID, OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString() });
if (excuteList.Count > 0)
{
result.Msg = excuteList[0].PRODUCTCODE + "正在" + excuteList[0].PROCESSTYPETEXT + "工序加工中!";
result.IsSuccess = false;
return result;
}
product.processSets = new ProcessSetBLL().GetListByModel(new ProcessSet { PRODUCTTYPE = product.PRODUCTTYPE}).Result;
//获取当前工序内容
product.processSet = new ProcessSetBLL().GetByModel(new ProcessSet { PRODUCTTYPE = product.PRODUCTTYPE, PROCESSTYPE = product.CURRENTPROCESS}).Result;
#region 1.校验零件是否已经被使用 USINGSTATE
if (product.USINGSTATE.Equals(EnumGeter.PRODUCTUSESTATE.USED.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProductUsed;
result.IsSuccess = false;
return result;
}
#endregion
#region 2.校验零件是否合格 STATUS
if (!product.STATUS.Equals(EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProductNotQualified;
result.IsSuccess = false;
return result;
}
#endregion
result.IsSuccess = true;
result.BackStatus = false;
result.Result = product;
}
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
public DataResult<OperationServiceParam> ValidateProudct(Product product, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> result = new DataResult<OperationServiceParam>();
try
{
if (product.IsMain) //当前零件是本体
{
#region 1.获取本体信息
Main mainSearchModel = new Main();
mainSearchModel.EPIDERMISCODE = product.PRODUCTCODE;
List<Main> mainList = new MainBLL().GetAllList(mainSearchModel);
if (mainList.Count <= 0)
{
result.Msg = Resource.OperationMainNotFound;
result.IsSuccess = false;
return result;
}
Main main = mainList[0];
#region 2.校验出库状态 PROCESSSTATE
if (!main.OUTFLAG.Equals(EnumGeter.OUTFLAG.INWAREHOUSE.GetHashCode().ToString()))
{
result.Msg = "该本体已出库!";
result.IsSuccess = false;
return result;
}
#endregion
//判断加工状态
List<MainOperation> excuteList = this.GetAllList(new MainOperation { PDID = main.PID });
operationServiceParam.moList = excuteList;
if (excuteList.Count(o => o.OPERATESTATE == EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) > 0)
{
MainOperation priorMo = excuteList.First(o => o.OPERATESTATE == EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString());
//2016-11-13冲切设备出现不返回加工完成信号的情况
//将自动放行从冲切调整成在铣削方位放行
if (operationServiceParam.machineInfo.PROCESSTYPE == EnumGeter.ProcessType.xixiao.GetHashCode().ToString()
&& priorMo.PROCESSTYPE == EnumGeter.ProcessType.chongqie.GetHashCode().ToString())
{
DataResult res = SetPunchingPassProcess(new Main() { PID = main.PID });
result.IsSuccess = false;
result.Msg = res.Msg;
return result;
}
else
{
result.Msg = priorMo.PRODUCTCODE + "正在" + priorMo.PROCESSTYPETEXT + "工序进行加工!\r\n";
result.Msg += "请等待加工完成或是手动放行!";
result.IsSuccess = false;
return result;
}
}
//获取当前工序内容
main.processSets = new ProcessSetBLL().GetListByModel(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString() }).Result;
main.processSet = new ProcessSetBLL().GetByModel(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString(), PROCESSTYPE = main.CURRENTPROCESS }).Result;
#endregion
#region 2.校验加工状态 PROCESSSTATE
if (main.PROCESSSTATE.Equals(EnumGeter.OPERATIONSTATE.PROCESSED.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProductProcessing;
result.IsSuccess = false;
return result;
}
LogManager.LogHelper.Info(new LogInfo() { Info = "m2" });
#endregion
#region 3.校验是否合格 STATUS
if (!main.STATUS.Equals(EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString()))
{
result.Msg = string.Format("该本体已{1}不能进行{0}!", operationServiceParam.processSet.PROCESSNAME, (main.STATUS.Equals(EnumGeter.PRODUCTSTAUTS.CANCEL.GetHashCode().ToString()) ? "报废" : "返修"));
result.IsSuccess = false;
return result;
}
#endregion
LogManager.LogHelper.Info(new LogInfo() { Info = "m3" });
#region 5.校验当前本体是否加工已经完成 COMPLETEFLAG
if (main.COMPLETEFLAG.Equals(EnumGeter.COMPLETEFLAG.COMPLETED.GetHashCode().ToString()))
{
result.Msg = "该本体已经完成总成装配!";
result.IsSuccess = false;
return result;
}
#endregion
result.IsSuccess = true;
result.BackStatus = true;
operationServiceParam.main = main;
result.Result = operationServiceParam;
}
if (!product.IsMain)//当前零件为零件
{
#region 2.校验出库状态 PROCESSSTATE
if (!product.OUTFLAG.Equals(EnumGeter.OUTFLAG.INWAREHOUSE.GetHashCode().ToString()))
{
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
result.Msg = string.Format("该{0}已出库不能进行{1}！", dictProductType.GetDictValue(product.PRODUCTTYPE), operationServiceParam.processSet.PROCESSNAME);
result.IsSuccess = false;
return result;
}
#endregion
//判断加工状态
List<MainOperation> excuteList = this.GetAllList(new MainOperation { PDID = product.PID });
operationServiceParam.moList = excuteList;
if (excuteList.Count(o => o.OPERATESTATE == EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) > 0)
{
MainOperation priorMo = excuteList.First(o => o.OPERATESTATE == EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString());
result.Msg = priorMo.PRODUCTCODE + "正在" + priorMo.PROCESSTYPETEXT + "工序进行加工!";
result.Msg += "请等待加工完成或是手动放行!";
result.IsSuccess = false;
return result;
}
product.processSets = new ProcessSetBLL().GetListByModel(new ProcessSet { PRODUCTTYPE = product.PRODUCTTYPE }).Result;
//获取当前工序内容
product.processSet = new ProcessSetBLL().GetByModel(new ProcessSet { PRODUCTTYPE = product.PRODUCTTYPE, PROCESSTYPE = product.CURRENTPROCESS }).Result;
#region 1.校验零件是否已经被使用 USINGSTATE
if (product.USINGSTATE.Equals(EnumGeter.PRODUCTUSESTATE.USED.GetHashCode().ToString()))
{
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
result.Msg = string.Format("该{0}已使用不能进行{1}!", dictProductType.GetDictValue(product.PRODUCTTYPE), operationServiceParam.processSet.PROCESSNAME);
result.IsSuccess = false;
return result;
}
#endregion
#region 2.校验零件是否合格 STATUS
if (!product.STATUS.Equals(EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString()))
{
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
result.Msg = Resource.OperationProductNotQualified;
result.Msg = string.Format("该{0}已{2}不能进行{1}!", dictProductType.GetDictValue(product.PRODUCTTYPE), operationServiceParam.processSet.PROCESSNAME, (product.STATUS.Equals(EnumGeter.PRODUCTSTAUTS.CANCEL.GetHashCode().ToString()) ? "报废" : "返修"));
result.IsSuccess = false;
return result;
}
#endregion
result.IsSuccess = true;
result.BackStatus = false;
operationServiceParam.product = product;
result.Result = operationServiceParam;
}
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
/// <summary>
/// 验证先决条件
/// </summary>
/// <param name="product"></param>
/// <returns></returns>
private DataResult<OperationServiceParam> ValidateProcessRules(Main main, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> result = new DataResult<OperationServiceParam>();
try
{
#region 0.校验零件是否符合当前工序
//本体应该根据高低配来筛选先决条件
operationServiceParam.ruleList = operationServiceParam.ruleList.FindAll(m => m.PRODUCTATTR == null || m.PRODUCTATTR == main.HB);
//当本体当前的工序不等于当前工位的工序时，需要判断该本体的工序到工位之间是否为必须的
if (!main.CURRENTPROCESS.Equals(operationServiceParam.processSet.PROCESSTYPE))
{
List<ProcessSet> listCompare = main.processSets.FindAll(m => m.PROCESSINDEX >= main.processSet.PROCESSINDEX && m.PROCESSINDEX < operationServiceParam.processSet.PROCESSINDEX);
if (listCompare.Count > 0)
{
foreach (ProcessSet item in listCompare)
{
if (item.LPNECCESSARY.Equals(EnumGeter.LPNECCESSARY.YES.GetHashCode().ToString()))
{
//result.Msg = Resource.OperationFitProcess;
result.Msg = string.Format("该本体不能进行{0}!\r\n", operationServiceParam.processSet.PROCESSNAME);
result.Msg += "应进行" + new ProcessInfoBLL().GetAllList(new ProcessInfo { PROCESSTYPE = item.PROCESSTYPE })[0].PROCESSNAME + "!";
result.IsSuccess = false;
return result;
}
}
}
else
{
result.Msg = string.Format("该本体不能进行{0}!\r\n", operationServiceParam.processSet.PROCESSNAME);
result.Msg += "应进行" + new ProcessInfoBLL().GetAllList(new ProcessInfo { PROCESSTYPE = main.CURRENTPROCESS })[0].PROCESSNAME + "!";
result.IsSuccess = false;
return result;
}
}
main.CURRENTPROCESS = operationServiceParam.processSet.PROCESSTYPE;
#endregion
#region 1.获取当前设备对应的先决条中中符合当前零件类别的先决条件集合，如果没有找到对应类别的先决条件，出错 PRODUCTTYPE
List<ProcessRule> rules = operationServiceParam.ruleList.FindAll(m => m.PRODUCTTYPE == EnumGeter.ProductType.benti.GetHashCode().ToString());
rules.Sort((a, b) => { return a.RULESORT.CompareTo(b.RULESORT); });
if (rules.Count <= 0)
{
//result.Msg = Resource.OperationNeedProduct;
result.Msg = string.Format(operationServiceParam.processSet.PROCESSNAME + "不需要操作本体!"); ;
result.IsSuccess = false;
return result;
}
#endregion
#region 2.获取当前零件的加工记录，为了前置工序和冷却时间做准备
List<MainOperation> operationList = new List<MainOperation>();
MainOperation operationSearchModel = new MainOperation();
operationList = operationServiceParam.moList;
operationList.Sort((m, n) => { return m.CREATEDATE.CompareTo(n.CREATEDATE); });//加工时间倒叙
#endregion
#region 3.遍历当前零件类别的先决条件
foreach (ProcessRule item in rules)
{
#region 3.1 判断当前工序缺少的零件数量
if (item.RULETYPE.Equals(EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()))//需求零件
{
int counts = item.RULEVALUE - item.RULEVALUENOW;//当前需求零件的数量
if (counts <= 0)
{
result.Msg = Resource.OperationLackProduct;
result.IsSuccess = false;
return result;
}
}
#endregion
#region 3.2 判断前置工序
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.BEFOREPROCESS.GetHashCode().ToString()))//前置工序
{
string beforeProcess = item.RULECONTENT;//前置工序类别 --由于符合了当前工序的匹配那么一定是前置工序是完成的
MainOperation operation = operationList.Find(m => m.PROCESSTYPE == beforeProcess);//找到最后一次该工序的加工记录
if (operation == null)
{
result.Msg = Resource.OperationBeforeProcessNotFound;
result.IsSuccess = false;
return result;
}
if (operation.OPERATESTATE.Equals(EnumGeter.OPERATIONSTATE.PROCESSING.GetHashCode().ToString()))
{
result.Msg = Resource.OperationBeforeProcessing;
result.IsSuccess = false;
return result;
}
}
#endregion
#region 3.3 判断冷却时间
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.COOLINGTIME.GetHashCode().ToString()))//冷却时间
{
int minites = item.RULEVALUE;//需要的冷却时间
string beforeProcess = item.RULECONTENT;//冷却工序类别
MainOperation operation = operationList.Find(m => m.PROCESSTYPE == beforeProcess);//找到最后一次该工序的加工记录
if (operation == null)
{
result.Msg = Resource.OperationBeforeTimeNotFound;
result.IsSuccess = false;
return result;
}
//加工完成时间与当前时间比对
DateTime operatedDate = operation.OPERATEDDATE;
double comperaValue = (DateTime.Now - operatedDate).TotalMinutes;
if (comperaValue < minites)
{
//result.Msg = string.Format(Resource.OperationBeforeTime, (minites - comperaValue).ToString("f2"));
result.Msg = string.Format(item.RULECONTENTTEXT + "工序的" + item.RULETYPETEXT + "还剩{0}分钟!\r\n", (minites - comperaValue).ToString("f2"));
result.Msg += string.Format("请达到{0}后再进行{1}!", item.RULETYPETEXT, operationServiceParam.processSet.PROCESSNAME);
result.IsSuccess = false;
return result;
}
}
#endregion
#region 3.4 判断模具
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.COOLINGTIME.GetHashCode().ToString()))//冷却时间
{
#region 校验3个预制属性
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE1) == false)
{
string value1 = main.GetType().GetProperty(operationServiceParam.model.ATTRBUTE1).GetValue(main, null).ToString();
if (value1.Equals(operationServiceParam.model.VALUE1) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE2) == false)
{
string value2 = main.GetType().GetProperty(operationServiceParam.model.ATTRBUTE2).GetValue(main, null).ToString();
if (value2.Equals(operationServiceParam.model.VALUE2) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE3) == false)
{
string value3 = main.GetType().GetProperty(operationServiceParam.model.ATTRBUTE3).GetValue(main, null).ToString();
if (value3.Equals(operationServiceParam.model.VALUE3) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
#endregion
}
#region 3.3 判断保质期
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.QUALITYTIME.GetHashCode().ToString()))//保质期
{
int minites = item.RULEVALUE;//最大保质期间
string beforeProcess = item.RULECONTENT;//保质工序类别
MainOperation operation = operationList.Find(m => m.PROCESSTYPE == beforeProcess);//找到最后一次该工序的加工记录
if (operation == null)
{
result.Msg = Resource.QualityNotFound;
result.IsSuccess = false;
return result;
}
//加工完成时间与当前时间比对
DateTime operatedDate = operation.OPERATEDDATE;
double comperaValue = (DateTime.Now - operatedDate).TotalMinutes;
if (comperaValue > minites)
{
result.Msg = string.Format(Resource.OperationBehindTime, (minites - comperaValue).ToString("f2"));
result.IsSuccess = false;
return result;
}
}
#endregion
#endregion
}
result.IsSuccess = true;
#endregion
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
/// <summary>
/// 设置本体的先决条件状态
/// </summary>
/// <param name="main"></param>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public DataResult<OperationServiceParam> SetRules(Main main, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> result = new DataResult<OperationServiceParam>();
try
{
#region 4.校验通过，添加入参数，并更新相应先决条件的标识
//加入到零件列表中
operationServiceParam.main = main;
#region 4.1 更新零件数量标识
//判断先决条件类别
List<ProcessRule> rules = operationServiceParam.ruleList.FindAll(m => m.PRODUCTTYPE == EnumGeter.ProductType.benti.GetHashCode().ToString());
ProcessRule itemNum = rules.Find(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString());
if (itemNum.RULETYPE.Equals(EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()))//需求零件
{
int counts = itemNum.RULEVALUE - itemNum.RULEVALUENOW;//当前需求零件的数量
//设置先决工序状态
itemNum.RULEVALUENOW = 1;//数量
if (itemNum.RULEVALUENOW == itemNum.RULEVALUE)//是否满足先决条件
SetResult(itemNum, true);
else
SetResult(itemNum, false);
}
#endregion
//更新先决条件状态
foreach (ProcessRule item in rules)
{
#region 4.2 更新前置工序的标识 只有自制件才需要前置工序以及冷却时间
//只有自制件校验该项
if (item.RULETYPE.Equals(EnumGeter.RULETYPE.BEFOREPROCESS.GetHashCode().ToString()))//前置工序
{
#region 4.2.1 前置工序
//判断零件数量是否满足
int compareCount = rules.FindAll(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()).Sum(m => m.RULEVALUE - m.RULEVALUENOW);
if (compareCount <= 0)//说明零件不缺少
SetResult(item, true);
else
SetResult(item, false);
#endregion
}
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.COOLINGTIME.GetHashCode().ToString()))//冷却时间
{
#region 4.2.2 冷却时间
//满足前置工序
//判断零件数量是否满足
int compareCount = rules.FindAll(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()).Sum(m => m.RULEVALUE - m.RULEVALUENOW);
if (compareCount <= 0)//说明零件不缺少
SetResult(item, true);
else
SetResult(item, false);
#endregion
}
#endregion
#region 3.4 更新模具
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.MODEL.GetHashCode().ToString()))//模具
{
SetResult(item, true);
}
#endregion
#region 3.4 更新有效期
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.QUALITYTIME.GetHashCode().ToString()))//有效期
{
#region 4.2.2 有效期
//满足前置工序
//判断零件数量是否满足
int compareCount = rules.FindAll(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()).Sum(m => m.RULEVALUE - m.RULEVALUENOW);
if (compareCount <= 0)//说明零件不缺少
SetResult(item, true);
else
SetResult(item, false);
#endregion
}
#endregion
}
#endregion
result.IsSuccess = true;
result.Result = operationServiceParam;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
/// <summary>
/// 设置零件的先决条件状态
/// </summary>
/// <param name="main"></param>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public DataResult<OperationServiceParam> SetRules(Product product, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> result = new DataResult<OperationServiceParam>();
try
{
//过滤掉相同类型的产品信息
if (operationServiceParam.productList.Count(o => o.PRODUCTTYPE == product.PRODUCTTYPE) > 0)
{
Product p = operationServiceParam.productList.First(o => o.PRODUCTTYPE == product.PRODUCTTYPE);
operationServiceParam.productList.Remove(p);
}
//加入到零件列表中
operationServiceParam.productList.Add(product);
#region 3.1 更新零件数量
List<ProcessRule> rules = operationServiceParam.ruleList.FindAll(m => m.PRODUCTTYPE == product.PRODUCTTYPE);
ProcessRule itemNum = rules.Find(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString());
int countNum = itemNum.RULEVALUE - itemNum.RULEVALUENOW;//当前需求零件的数量
int proCount = product.CAPACITY - product.USINGCOUNT;//零件剩余数量
int useCount = 0;//实际使用数量
if (proCount >= countNum)
useCount = countNum;
else
useCount = proCount;
//需要判断当前零件是否为加工主零件，如果为加工主零件那么不需要扣减数量 ,并且后面为了风道而设置
if (!product.PRODUCTTYPE.Equals(operationServiceParam.processSet.PRODUCTTYPE) && operationServiceParam.ruleList.Count > 1)
{
product.useCount = useCount;
product.USINGCOUNT = product.USINGCOUNT + useCount;//零件的全部使用状态
if (product.CAPACITY > product.USINGCOUNT)//设置使用零件的状态
product.USINGSTATE = EnumGeter.PRODUCTUSESTATE.USING.GetHashCode().ToString();
else
product.USINGSTATE = EnumGeter.PRODUCTUSESTATE.USED.GetHashCode().ToString();
}
//设置先决工序状态
itemNum.RULEVALUENOW = itemNum.RULEVALUENOW + useCount;//数量
if (itemNum.RULEVALUENOW == itemNum.RULEVALUE)//是否满足先决条件
SetResult(itemNum, true);
else
SetResult(itemNum, false);
#endregion
//更新先决条件状态
foreach (ProcessRule item in rules)
{
#region 3.2 更新前置工序
if (item.RULETYPE.Equals(EnumGeter.RULETYPE.BEFOREPROCESS.GetHashCode().ToString()))//前置工序
{
//满足前置工序
//判断零件数量是否满足
int compareCount = rules.FindAll(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()).Sum(m => m.RULEVALUE - m.RULEVALUENOW);
if (compareCount <= 0)//说明零件不缺少
SetResult(item, true);
else
SetResult(item, false);
}
#endregion
#region 3.3 更新冷却时间
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.COOLINGTIME.GetHashCode().ToString()))//冷却时间
{
//满足前置工序
//判断零件数量是否满足
int compareCount = rules.FindAll(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()).Sum(m => m.RULEVALUE - m.RULEVALUENOW);
if (compareCount <= 0)//说明零件不缺少
SetResult(item, true);
else
SetResult(item, false);
}
#endregion
#region 3.4 更新模具
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.MODEL.GetHashCode().ToString()))//模具
{
if (operationServiceParam.model != null)
{
SetResult(item, true);
}
else
{
SetResult(item, false);
}
}
#region 3.4 更新有效期
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.QUALITYTIME.GetHashCode().ToString()))//有效期
{
#region 4.2.2 有效期
//满足前置工序
//判断零件数量是否满足
int compareCount = rules.FindAll(m => m.RULETYPE == EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()).Sum(m => m.RULEVALUE - m.RULEVALUENOW);
if (compareCount <= 0)//说明零件不缺少
SetResult(item, true);
else
SetResult(item, false);
#endregion
}
#endregion
#endregion
}
#endregion
result.IsSuccess = true;
result.Result = operationServiceParam;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
#endregion
/// <summary>
/// 验证先决条件
/// </summary>
/// <param name="product">零件信息</param>
/// <param name="operationServiceParam">传递参数</param>
/// <returns></returns>
private DataResult ValidateProcessRules(Product product, OperationServiceParam operationServiceParam)
{
DataResult result = new DataResult();
try
{
//专门为风道与HUD风道设置
if (operationServiceParam.main ==null && operationServiceParam.ruleList.Find(m=>m.PRODUCTTYPE == EnumGeter.ProductType.benti.GetHashCode().ToString()) == null)
{
operationServiceParam.ruleList = operationServiceParam.ruleList.FindAll(m => m.PRODUCTATTR == null || m.PRODUCTATTR == product.PRODUCTTYPE);
}
//判断当前零件工序是否为当前工位工序
if (!product.CURRENTPROCESS.Equals(operationServiceParam.processSet.PROCESSTYPE))
{
//获取当前工位工序在当前零件工序的位置
if (product.processSets.Find(m => m.PROCESSTYPE == operationServiceParam.processSet.PROCESSTYPE) == null)
{
DictManageBLL productType = new DictManageBLL(DictKind.PRODUCTTYPE);
result.Msg = string.Format("该{1}不能进行{0}!\r\n", operationServiceParam.processSet.PROCESSNAME, productType.GetDictValue(product.PRODUCTTYPE));
result.Msg += "应进行" + new ProcessInfoBLL().GetAllList(new ProcessInfo { PROCESSTYPE = product.CURRENTPROCESS })[0].PROCESSNAME + "!";
result.IsSuccess = false;
return result;
}
int processIndes = product.processSets.Find(m => m.PROCESSTYPE == operationServiceParam.processSet.PROCESSTYPE).PROCESSINDEX;
List<ProcessSet> listCompare = product.processSets.FindAll(m => m.PROCESSINDEX >= Convert.ToInt32(product.processSet.PROCESSINDEX) && m.PROCESSINDEX < processIndes);
if (listCompare.Count > 0)
{
foreach (ProcessSet item in listCompare)
{
if (item.LPNECCESSARY.Equals(EnumGeter.LPNECCESSARY.YES.GetHashCode().ToString()))
{
result.Msg = string.Format("该{1}不能进行{0}!\r\n", operationServiceParam.processSet.PROCESSNAME, item.PRODUCTNAME);
result.Msg += "应进行" + new ProcessInfoBLL().GetAllList(new ProcessInfo { PROCESSTYPE = product.CURRENTPROCESS })[0].PROCESSNAME + "!";
result.IsSuccess = false;
return result;
}
}
}
else
{
DictManageBLL productType = new DictManageBLL(DictKind.PRODUCTTYPE);
result.Msg = string.Format("该{1}不能进行{0}!\r\n", operationServiceParam.processSet.PROCESSNAME, productType.GetDictValue(product.PRODUCTTYPE));
result.Msg += "应进行" + new ProcessInfoBLL().GetAllList(new ProcessInfo { PROCESSTYPE = product.CURRENTPROCESS })[0].PROCESSNAME + "!";
result.IsSuccess = false;
return result;
}
}
product.CURRENTPROCESS = operationServiceParam.processSet.PROCESSTYPE;
#region 3.获取当前设备对应的先决条中中符合当前零件类别的先决条件集合，如果没有找到对应类别的先决条件，出错 PRODUCTTYPE
List<ProcessRule> rules = operationServiceParam.ruleList.FindAll(m => m.PRODUCTTYPE == product.PRODUCTTYPE);
rules.Sort((a, b) => { return a.RULESORT.CompareTo(b.RULESORT); });
if (rules.Count <= 0)
{
result.Msg = Resource.OperationNeedProduct;
result.IsSuccess = false;
return result;
}
#endregion
#region 4.只有当当前零件为自制件的时候才会获取当前零件的加工记录，为了前置工序和冷却时间做准备
List<MainOperation> operationList = new List<MainOperation>();
if (product.productBasic.PRODUCTSOURCE.Equals(EnumGeter.PRODUCTSOURCE.SELFMADE.GetHashCode().ToString()))
{
#region 4.1 获取零件加工记录
MainOperation operationSearchModel = new MainOperation();
operationList = operationServiceParam.moList;
if (operationList.Count > 0)
{
operationList.Sort((m, n) => { return m.CREATEDATE.CompareTo(n.CREATEDATE); });//加工时间倒叙
//判断最后一道工序是否是加工中
if (operationList[0].OPERATESTATE.Equals(EnumGeter.OPERATIONSTATE.PROCESSING.GetHashCode().ToString()))
{
result.Msg = Resource.OperationProductProcessing;
result.IsSuccess = false;
return result;
}
}
#endregion
#region 4.2 遍历规则校验
foreach (ProcessRule item in rules)
{
#region 4.2.1 校验数量
if (item.RULETYPE.Equals(EnumGeter.RULETYPE.PARTS.GetHashCode().ToString()))//需求零件
{
int counts = item.RULEVALUE - item.RULEVALUENOW;//当前需求零件的数量
if (counts <= 0)
{
result.Msg = Resource.OperationLackProduct;
result.IsSuccess = false;
return result;
}
}
#endregion
#region 4.2.2 校验前置工序
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.BEFOREPROCESS.GetHashCode().ToString()))//前置工序
{
string beforeProcess = item.RULECONTENT;//前置工序类别 --由于符合了当前工序的匹配那么一定是前置工序是完成的
MainOperation operation = operationList.Find(m => m.PROCESSTYPE == beforeProcess);//找到最后一次该工序的加工记录
if (operation == null)
{
result.Msg = Resource.OperationBeforeProcessNotFound;
result.IsSuccess = false;
return result;
}
if (operation.OPERATESTATE.Equals(EnumGeter.OPERATIONSTATE.PROCESSING))
{
result.Msg = Resource.OperationBeforeProcessing;
result.IsSuccess = false;
return result;
}
}
#endregion
#region 4.2.3 校验冷却时间
else if (item.RULETYPE.Equals(EnumGeter.RULETYPE.COOLINGTIME.GetHashCode().ToString()))//冷却时间
{
int minites = item.RULEVALUE;//需要的冷却时间
string beforeProcess = item.RULECONTENT;//冷却工序类别
MainOperation operation = operationList.Find(m => m.PROCESSTYPE == beforeProcess);//找到最后一次该工序的加工记录
if (operation == null)
{
result.Msg = Resource.OperationBeforeTimeNotFound;
result.IsSuccess = false;
return result;
}
//加工完成时间与当前时间比对
DateTime operatedDate = operation.OPERATEDDATE;
double comperaValue = (DateTime.Now - operatedDate).TotalMinutes;
if (comperaValue < minites)
{
//result.Msg = string.Format(Resource.OperationBeforeTime, (minites - comperaValue).ToString("f2"));
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
result.Msg = string.Format(dictProductType.GetDictValue(product.PRODUCTTYPE) + "在" + item.RULECONTENTTEXT + "工序的" + item.RULETYPETEXT + "还剩{0}分钟!\r\n", (minites - comperaValue).ToString("f2"));
result.Msg += string.Format("请达到{0}后再进行{1}!", item.RULETYPETEXT, operationServiceParam.processSet.PROCESSNAME);
result.IsSuccess = false;
return result;
}
}
#endregion
#region 4.2.4 校验模具
if (item.RULETYPE.Equals(EnumGeter.RULETYPE.MODEL.GetHashCode().ToString()))//模具
{
if (product != null && operationServiceParam.model != null)
{
#region 校验3个预制属性
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE1) == false)
{
string value1 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE1).GetValue(product, null).ToString();
if (value1.Equals(operationServiceParam.model.VALUE1) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE2) == false)
{
string value2 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE2).GetValue(product, null).ToString();
if (value2.Equals(operationServiceParam.model.VALUE2) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE3) == false)
{
string value3 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE3).GetValue(product, null).ToString();
if (value3.Equals(operationServiceParam.model.VALUE3) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
#endregion
}
}
#endregion
#region 3.3 判断保质期
if (item.RULETYPE.Equals(EnumGeter.RULETYPE.QUALITYTIME.GetHashCode().ToString()))//保质期
{
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
DictManageBLL dictProcessType = new DictManageBLL(DictKind.PROCESSTYPE);
int minites = item.RULEVALUE;//最大保质期间
string beforeProcess = item.RULECONTENT;//保质工序类别
MainOperation operation = operationList.Find(m => m.PROCESSTYPE == beforeProcess);//找到最后一次该工序的加工记录
if (operation == null)
{
result.Msg = Resource.QualityNotFound;
result.IsSuccess = false;
return result;
}
//加工完成时间与当前时间比对
DateTime operatedDate = operation.OPERATEDDATE;
double comperaValue = (DateTime.Now - operatedDate).TotalMinutes;
if (comperaValue > minites)
{
result.Msg = dictProductType.GetDictValue(product.PRODUCTTYPE) + product.PRODUCTCODE + "已经超出" + dictProcessType.GetDictValue(beforeProcess) + "工序的保质期!\r\n不能继续使用!";
result.IsSuccess = false;
return result;
}
}
#endregion
}
#endregion
}
#endregion
result.IsSuccess = true;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
/// <summary>
/// 设置通过
/// </summary>
/// <param name="item">当前规则</param>
/// <param name="result">规则结果</param>
/// <returns></returns>
public void SetResult(ProcessRule item, bool result)
{
//设置是否ok
item.isValid = true;
item.isOk = result;
if (result)
{
item.isOkTEXT = Resource.OperationPass;
}
else
{
item.isOkTEXT = Resource.OperationUnpass;
}
}
/// <summary>
/// 校验是否全部通过
/// </summary>
/// <param name="operationServiceParam">传递参数</param>
/// <returns></returns>
public bool ValidateResult(OperationServiceParam operationServiceParam)
{
//判断所有先决是否全ok
foreach (ProcessRule item in operationServiceParam.ruleList)
{
if (item.isOk == false)
{
return false;
}
}
return true;
}
/// <summary>
/// 调取保存，并发送指令
/// </summary>
/// <param name="operationServiceParam">传递参数</param>
/// <returns></returns>
public DataResult SaveAndSendOrder(OperationServiceParam operationServiceParam)
{
DataResult result = new DataResult();
try
{
//填充数据
result = GetParamModels(operationServiceParam);
if (result.IsSuccess)
{
DataResult<int> resultInt = this.MachineOperation(operationServiceParam);//更新零件状态
if (resultInt.IsSuccess)
{
result.IsSuccess = true;
result.Msg = Resource.OperationSendSuccess;
if (operationServiceParam.machineInfo.ISCONTROL.Equals("0"))//如果不需要返回参数的那么直接后台放行,读取设备的标示operationServiceParam.machineInfo.ISCONTROL
{
string pcode = operationServiceParam.main == null? operationServiceParam.productList[0].PRODUCTCODE:operationServiceParam.main.EPIDERMISCODE;
string productid = "";
if (operationServiceParam.main == null)
{
productid = operationServiceParam.productList[0].PID;
}
SetPassProcessToNext(new Product { PRODUCTCODE = pcode, PID = productid });
result.Msg = "加工完成!";
}
}
else
{
result.Msg = resultInt.Msg;
result.IsSuccess = false;
}
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工操作保存发送-插入信息"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw;
}
return result;
}
/// <summary>
/// 加工操作全流程
/// </summary>
/// <param name="productCode"></param>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public DataResult<OperationServiceParam> OperationForReturn(string productCode, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> resultFinal = new DataResult<OperationServiceParam>();
resultFinal = this.Operation( productCode, operationServiceParam);
//获取指令方法
Process.ProcessOrderSend proOrderSend = new Process.ProcessOrderSend();
MachineInfo mInfo = operationServiceParam.machineInfo;
mInfo.MOLDNUMBER = operationServiceParam.machineInfo.MOLDNUMBER.Trim();
///////////////
//mInfo.MOLDNUMBER = "1";
//List<ParameterConfig> listParam1 = proOrderSend.Get(mInfo, true);
//if (listParam1.Count > 0)
//{
// string jstring1 = QMFrameWork.Common.Serialization.JsonConvertHelper.GetSerializes(listParam1);
// resultFinal.MsgCode = jstring1;
// return resultFinal;
//}
////////////////
return resultFinal;
}
/// <summary>
/// 获取指令参数
/// </summary>
/// <param name="mInfo"></param>
/// <param name="orderFlag"></param>
/// <returns></returns>
public DataResult<string> GetSendOrder(MachineInfo mInfo, bool orderFlag)
{
DataResult<string> str = new DataResult<string>();
Process.ProcessOrderSend proOrderSend = new Process.ProcessOrderSend();
List<ParameterConfig> listParam = proOrderSend.Get(mInfo, orderFlag);
if (listParam.Count > 0)
{
string jstring = QMFrameWork.Common.Serialization.JsonConvertHelper.GetSerializes(listParam);
str.Result = jstring;
}
return str;
}
/// <summary>
/// 加工操作全流程
/// </summary>
/// <param name="productCode"></param>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public DataResult<OperationServiceParam> Operation(string productCode, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> resultFinal = new DataResult<OperationServiceParam>();
DataResult result = new DataResult();
try
{
resultFinal.IsSuccess = true;
resultFinal.Result = operationServiceParam;
resultFinal.Result.isPass = false;
//添加线程锁
using (MutexLock stockLock = new MutexLock(operationServiceParam.machineInfo.MACHINECODDE + ":Check"))
{
#region 0.判断当前设备加工状态
DataResult resultMachine = this.GetMashineStatus(operationServiceParam);
if (resultMachine.IsSuccess == false)//零件处理失败
{
//设备正在加工中需要判断是否暂停，需要继续加工，并重新发送指令
if (resultMachine.Msg.Equals(Resource.OperationMachineWorking))
{
//并且符合零件组合
//需要判断是否全部符合当前工序
//并且全都是加工中的状态
}
resultFinal.Msg = resultMachine.Msg;
return resultFinal;
}
#endregion
#region 1.判断条码类别
if (productCode.Length < 3)//为模具条码
{
#region
operationServiceParam.model = new MachineInfoModels();
operationServiceParam.model.MODELCODE = productCode;
operationServiceParam.model.MODELSTATION = productCode;
operationServiceParam.machineInfo.MOLDNUMBER = productCode;
DataResult modelResult = this.ValidateModel(operationServiceParam);
if (modelResult.IsSuccess == false)
{
resultFinal.Msg = modelResult.Msg;
return resultFinal;
}
#endregion
}
if (productCode.Length > 3)//为零件条码
{
#region 判断与服务器交互的设备是否加工完成
//2016-6-27 闫永刚 获取模架号加工状态信息
//如果该模架正在加工中，那么不能进行操作，
if (operationServiceParam.machineInfo.ISCONTROL == "3"
&& operationServiceParam.machineInfo.PROCESSTYPE != EnumGeter.ProcessType.jiaozhu.GetHashCode().ToString())
{
#region 模架使用校验
MainMolderStatus entity = new MainMolderStatusDAL().Get(
new MainMolderStatus()
{
MACHINECODDE = operationServiceParam.machineInfo.MACHINECODDE,
MOLDNUMBER = "1"
}
);
if (entity.OPERATIONFLAG.ToString() == EnumGeter.OPERATIONFLAG.BUSY.GetHashCode().ToString()
&& entity.BARCODE.Trim().ToUpper().Contains(productCode.Trim().ToUpper()) == false)
{
//闫永刚2016-10-18 因为冲切设备总是不反回加工结果，所以这里重新调整
//当冲切设备在使用中做额外处理
//if (operationServiceParam.machineInfo.PROCESSTYPE != EnumGeter.ProcessType.chongqie.GetHashCode().ToString())
//{
// resultFinal.Msg = string.Format("设备正在加工中,请等待加工完成或是手动放行!");
// return resultFinal;
//}
//else
//{
// DataResult res = SetPunchingPassProcess();
// if (res.IsSuccess == false)
// {
// resultFinal.Msg = string.Format("Releas Punch exception!");
// return resultFinal;
// }
//}
resultFinal.Msg = string.Format("设备正在加工中,请等待加工完成或是手动放行!");
return resultFinal;
}
#endregion
}
#endregion
#region 1.处理零件信息，添加外购件，设置零件类别
DataResult<Product> resultProduct = this.ExplainProduct(productCode, operationServiceParam);
if (resultProduct.IsSuccess == false)//零件处理失败
{
resultFinal.Msg = resultProduct.Msg;
return resultFinal;
}
#endregion
#region 2.零件的属性校验，是否合格
DataResult<OperationServiceParam> dataResultObject = this.ValidateProudct(resultProduct.Result, operationServiceParam);
operationServiceParam = dataResultObject.Result as OperationServiceParam;
if (dataResultObject.IsSuccess == false)//零件校验不通过
{
resultFinal.Msg = dataResultObject.Msg;
return resultFinal;
}
#endregion
#region 3.校验零件是否符合加工先决条件
if (dataResultObject.BackStatus)//为本体
{
Main main = operationServiceParam.main;
#region 本体
//校验先决条件
DataResult<OperationServiceParam> dataResultRule = this.ValidateProcessRules(main, operationServiceParam);
if (dataResultRule.IsSuccess == false)
{
if (dataResultRule.Result != null)
operationServiceParam.ruleList = dataResultRule.Result.ruleList;
resultFinal.Msg = dataResultRule.Msg;
return resultFinal;
}
//更新先决条件列表
DataResult<OperationServiceParam> resultRules = this.SetRules(main, operationServiceParam);
if (resultRules.IsSuccess == false)
{
resultFinal.Msg = resultRules.Msg;
return resultFinal;
}
#endregion
operationServiceParam = resultRules.Result;
}
else//为零件
{
Product product = operationServiceParam.product;
//校验先决条件
#region 零件
result = this.ValidateProcessRules(product, operationServiceParam);
if (result.IsSuccess == false)
{
resultFinal.Msg = result.Msg;
return resultFinal;
}
//更新先决条件列表
DataResult<OperationServiceParam> resultRules = this.SetRules(product, operationServiceParam);
if (resultRules.IsSuccess == false)
{
resultFinal.Msg = resultRules.Msg;
return resultFinal;
}
#endregion
operationServiceParam = resultRules.Result;
}
resultFinal.Result = operationServiceParam;//更新完先决条件就加入返回值中
#endregion
}
#endregion
#region 处理批量件
//
//判断当前工序是否存在批量件
List<ProcessRule> listRule = operationServiceParam.ruleList.FindAll
(m => m.PRODUCTUNIT.Equals(EnumGeter.PRODUCTUNIT.SET.GetHashCode().ToString())
&& m.RULEVALUE > m.RULEVALUENOW);
if (listRule != null && listRule.Count > 0)
{
foreach (ProcessRule item in listRule)
{
ProductBLL pBll = new ProductBLL();
List<Product> listP = pBll.GetAllList(new Product { PRODUCTTYPE = item.PRODUCTTYPE, USINGSTATE = EnumGeter.PRODUCTUSESTATE.USING.GetHashCode().ToString() });
listP.Sort((m, n) => n.UPDATEDATE.CompareTo(m.UPDATEDATE));
//如果为总成装配工序需要判断外购件颜色（格栅需要判断颜色）
if (operationServiceParam.processSet.PROCESSTYPE.Equals(EnumGeter.ProcessType.zongchengzhuangpei.GetHashCode().ToString())
&& (item.PRODUCTTYPE.Equals(EnumGeter.ProductType.geshan.GetHashCode().ToString()) || item.PRODUCTTYPE.Equals(EnumGeter.ProductType.yougeshan.GetHashCode().ToString())))
{
DictManageBLL dictCOLORTOGESHANBll = new DictManageBLL(DictKind.COLORTOGESHAN);
DictManageBLL dictCOLORBll = new DictManageBLL(DictKind.COLOR);
if (operationServiceParam.main == null)
{
resultFinal.Msg = "请先扫描本体条码！";
return resultFinal;
}
string maincolorText = dictCOLORBll.GetDictValue(operationServiceParam.main.COLOR);
string colorText = "";
foreach (Product p in listP)
{
LogManager.LogHelper.Info(new LogInfo() { Info = "---------" + p.PRODUCTCODE + " / " + productCode });
if (p.PRODUCTCODE.Length != 18)
{
resultFinal.Msg = item.PRODUCTTYPETEXT + "条码" + p.PRODUCTCODE + "格式错误，请扫码准确的" + item.PRODUCTTYPETEXT + "条码!";
return resultFinal;
}
string color = p.PRODUCTCODE.Substring(12, 3);
//颜色代码——“24A”代表注塑黑色，“6PS”代表喷漆黑色，“RK1”代表灰色，“AY2”代表棕色
string mainColor = dictCOLORTOGESHANBll.GetDictValue(color);
colorText = dictCOLORBll.GetDictValue(mainColor);
if (string.IsNullOrEmpty(colorText))
{
resultFinal.Msg = p.PRODUCTCODE + "颜色码不正确！";
return resultFinal;
}
if (operationServiceParam.main == null)
{
resultFinal.Msg = "继续扫描本体码！";
return resultFinal;
}
LogManager.LogHelper.Info(new LogInfo() { Info = "mainColor:" + mainColor.ToString() + " / " + "operationServiceParam.main.COLOR:" + operationServiceParam.main.COLOR.ToString()});
if (mainColor.Equals(operationServiceParam.main.COLOR))
{
LogManager.LogHelper.Info(new LogInfo() { Info = "SetRules" });
//设置零件状态
SetRules(p, operationServiceParam);
}
if (item.RULEVALUE <= item.RULEVALUENOW) { break; }
}
if (item.RULEVALUE > item.RULEVALUENOW)
{
LogManager.LogHelper.Info(new LogInfo() { Info = "RULEVALUE:" + item.RULEVALUE.ToString() + " / " + "RULEVALUENOW:" + item.RULEVALUENOW.ToString()});
Dictionary<string, string> dict = new DictManageBLL(DictKind.COLORTOGESHAN).GetModelDictionary(DictKind.COLORTOGESHAN);
string colorinfo = "";
foreach (var v in dict)
{
if (v.Value == operationServiceParam.main.COLOR)
{
colorinfo += v.Key;
colorinfo += ",";
}
}
colorinfo = colorinfo.Substring(0, colorinfo.Length - 1);
resultFinal.Msg = "缺少" + item.PRODUCTTYPETEXT + Environment.NewLine + "请扫描以" + (item.PRODUCTTYPE == EnumGeter.ProductType.geshan.GetHashCode().ToString() ? "B9H" : "B9I") + string.Format("开头并且条码中包含{0}的", colorinfo) + maincolorText + "色" + item.PRODUCTTYPETEXT + "条码!";
return resultFinal;
}
}
else
{
if (operationServiceParam.main == null)
{
resultFinal.Msg = "继续扫描本体码！";
return resultFinal;
}
foreach (Product p in listP)
{
//设置零件状态
SetRules(p, operationServiceParam);
if (item.RULEVALUE <= item.RULEVALUENOW) { break; }
}
if (item.RULEVALUE > item.RULEVALUENOW)
{
resultFinal.Msg = "缺少" + item.PRODUCTTYPETEXT + "，请添加并取消操作重新扫码！";
return resultFinal;
}
}
}
}
#endregion
#region 4.判断加工先决条件是否全部通过
if (this.ValidateResult(operationServiceParam) == false)
{
resultFinal.Msg = "";
return resultFinal;
}
#endregion
//判断是否该零件存在于先决条件中，否则删除该零件
for (int i = 0; i < operationServiceParam.productList.Count; i++)
{
Product item = operationServiceParam.productList[i];
if (operationServiceParam.ruleList.Find(m => m.RULETYPE.Equals("2") && m.PRODUCTTYPE.Equals(item.PRODUCTTYPE)) == null)
{
operationServiceParam.productList.Remove(item);
i--;
}
}
#region 5.更新加工零件状态并发送设备指令
result = this.SaveAndSendOrder(operationServiceParam);
if (result.IsSuccess == false)
{
resultFinal.Msg = result.Msg;
return resultFinal;
}
#endregion
}
resultFinal.Result.isPass = true;
resultFinal.Msg = Resource.OperationSendSuccess;
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工操作-流程加工"
});
result.IsSuccess = false;
resultFinal.Msg = Resource.SystemException;
}
return resultFinal;
}
public DataResult<Main> GetPrintCode(Product product)
{
DataResult<Main> result = new DataResult<Main>();
Main main = new Main();
//string mainCode = new MainDAL().GetMaxMainCode();
//20190402屏蔽
string mainCode = "屏蔽";
if (string.IsNullOrEmpty(mainCode))
{
mainCode = "1";
}
else
{
mainCode = (Convert.ToInt32(mainCode) + 1) + "";
}
main.MAINCODE = "052 M3G" + mainCode.PadLeft(7, '0');
main.MAINCODE = new FileCopyRecordDAL().GetBarcode(main.MAINCODE);
main.COMPLETETIME = DateTime.Now;
PrintCode pc = new PrintCode();
pc.PID = Guid.NewGuid().ToString();
pc.PRODUCTCODE = product.PRODUCTCODE;
pc.MAINCODE = main.MAINCODE;
pc.ISCOMPLETE = 0;
pc.CREATETIME = System.DateTime.Now;
PrintCodeDAL dal = new PrintCodeDAL();
dal.Insert(pc);
result.Result = main;
return result;
}
/// <summary>
/// 成都注塑条码打印
/// </summary>
/// <param name="product"></param>
/// <returns></returns>
public DataResult<List<PrintCode>> GetPrintCodeForChengdu(List<Material> materialList,MachineInfoModels model, int proNum)
{
DataResult<List<PrintCode>> result = new DataResult<List<PrintCode>>();
List<PrintCode> printCodeList = new List<PrintCode>();
PrintCodeDAL dal = new PrintCodeDAL();
foreach (Material item in materialList)
{
PrintCode proCodeInfo = new PrintCode();
proCodeInfo.PRODUCTCODE = item.MATERIAL_CODE;
//获取PrinCode信息
for (int i = 0; i < proNum; i++)
{
proCodeInfo = new PrintCodeDAL().GetPrintCodeInfo(proCodeInfo);
if (proCodeInfo != null)
{
if (proCodeInfo.UPDATETIME.ToShortDateString() != DateTime.Now.ToShortDateString())
{
proCodeInfo.SERIAL_NUM = 0;
dal.UpdateBySql(proCodeInfo);
}
string modelcode = "0";
if (model != null && !string.IsNullOrEmpty(model.PID))
{
modelcode = model.MODELSTATION;
}
string time = DateTime.Now.ToString("yyMMddHHmm");
proCodeInfo.SERIAL_NUM = proCodeInfo.SERIAL_NUM + 1;
string serialnumber = (proCodeInfo.SERIAL_NUM).ToString().PadLeft(4, '0');
proCodeInfo.MAINCODE = proCodeInfo.PRECODE + modelcode + time + serialnumber;
dal.Update(proCodeInfo);
printCodeList.Add(proCodeInfo);
}
}
}
result.Result = printCodeList;
return result;
}
/// <summary>
/// 成都注塑条码打印带注塑参数
/// </summary>
/// <param name="product"></param>
/// <returns></returns>
public DataResult<List<PrintCode>> GetPrintCodeWithParam(List<Material> materialList,MachineInfo machine,MachineInfoModels model,string tableName,Dictionary<string,string> param)
{
DataResult<List<PrintCode>> result = new DataResult<List<PrintCode>>();
List<PrintCode> printCodeList = new List<PrintCode>();
List<MainOperation> molist = new List<MainOperation>();
List<string> paramsqls = new List<string>();
PrintCodeDAL dal = new PrintCodeDAL();
StringBuilder sql = new StringBuilder();
foreach (Material item in materialList)
{
PrintCode proCodeInfo = new PrintCode();
proCodeInfo.PRODUCTCODE = item.MATERIAL_CODE;
proCodeInfo = new PrintCodeDAL().GetPrintCodeInfo(proCodeInfo);
if (proCodeInfo != null)
{
var sssss = proCodeInfo.UPDATETIME.ToShortDateString();
if (proCodeInfo.UPDATETIME.ToShortDateString() != DateTime.Now.ToShortDateString())
{
proCodeInfo.SERIAL_NUM = 0;
dal.UpdateBySql(proCodeInfo);
}
string modelcode="0";
if (model != null&&!string.IsNullOrEmpty(model.PID))
{
modelcode = model.MODELSTATION;
}
string time = DateTime.Now.ToString("yyMMddHHmm");
proCodeInfo.SERIAL_NUM = proCodeInfo.SERIAL_NUM + 1;
string serialnumber = (proCodeInfo.SERIAL_NUM).ToString().PadLeft(4, '0');
proCodeInfo.MAINCODE = proCodeInfo.PRECODE + modelcode + time + serialnumber;
dal.Update(proCodeInfo);
printCodeList.Add(proCodeInfo);
string pid=Guid.NewGuid().ToString();
MainOperation mo = new MainOperation
{
PID = pid,
PDID = pid,
PRODUCTCODE = proCodeInfo.MAINCODE,
MACHINENAME = machine.MACHINENAME,
MACHINECODDE = machine.MACHINECODDE,
MOLDNUMBER = model.MODELCODE,
STATUS = "0",
OPERATESTATE = string.IsNullOrEmpty(tableName)?"2":"1",//如果不包含参数信息则认为是手动打印
OPERATEDDATE = DateTime.Now,
MODELSTATION = model.MODELSTATION,
CREATEUSER = base.LoginUser.UserID,
CREATEDATE = DateTime.Now,
UPDATEDATE = DateTime.Now,
MATERIAL_CODE = item.MATERIAL_CODE,
MATERIAL_TYPE_CODE = item.MATERIAL_TYPE_CODE,
WORKCENTER_CODE = machine.WORKCENTER_CODE,
WORKCELL_CODE = machine.WORKCELL_CODE
};
molist.Add(mo);
if (!string.IsNullOrEmpty(tableName))
{
StringBuilder columns = new StringBuilder();
StringBuilder values = new StringBuilder();
columns.Append("[PID],[PDID],[PRODUCTCODE],[MOID],[MACHINENAME],[MACHINECODDE],[MOLDNUMBER],[CREATEDATE],[OPERATEDATE]");
values.Append(string.Format("'{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}'"
, pid, pid, mo.PRODUCTCODE, mo.PID, mo.MACHINENAME, mo.MACHINECODDE, mo.MOLDNUMBER, mo.CREATEDATE, mo.OPERATEDDATE));
foreach (var pa in param)
{
columns.Append(string.Format(",[{0}]", pa.Key));
values.Append(string.Format(",'{0}'", pa.Value));
}
sql.AppendLine(string.Format("INSERT INTO [{0}]({1}) VALUES({2}) "
, tableName
, columns.ToString()
, values.ToString()));
}
}
}
using (var session = AppDataFactory.CreateMainSession())
{
session.Insert(molist);
if (sql.Length > 0)
{
session.ExecuteSql(sql.ToString());
}
}
result.Result = printCodeList;
return result;
}
/// <summary>
/// 加工操作全流程
/// </summary>
/// <param name="productCode"></param>
/// <param name="operationServiceParam"></param>
/// <returns></returns>
public DataResult<OperationServiceParam> OperationList(List<string> productCodes, OperationServiceParam operationServiceParam)
{
DataResult<OperationServiceParam> resultFinal = new DataResult<OperationServiceParam>();
DataResult result = new DataResult();
try
{
string productCode = "";
for (int i = 0; i < productCodes.Count; i++)
{
productCode = productCodes[i];
resultFinal.IsSuccess = true;
resultFinal.Result = operationServiceParam;
#region 0.判断当前设备加工状态
if (i == 0)//当参数为列表时候只有第一个参数需要校验设备状态
{
DataResult resultMachine = this.GetMashineStatus(operationServiceParam);
if (resultMachine.IsSuccess == false)//零件处理失败
{
//设备正在加工中需要判断是否暂停，需要继续加工，并重新发送指令
if (resultMachine.Msg.Equals(Resource.OperationMachineWorking))
{
//并且符合零件组合
//需要判断是否全部符合当前工序
//并且全都是加工中的状态
foreach (string pCode in productCodes)
{
Main mian = new MainDAL().GetMain(new Main { publicCode = productCode });
//当本体存在并且工序为当前工序，并且状态为正在加工中，那么只需要重新发送指令
if (mian != null && mian.CURRENTPROCESS.Equals(operationServiceParam.processSet.PROCESSTYPE) && mian.PROCESSSTATE.Equals(EnumGeter.OPERATESTATE.COMPLETED.GetHashCode().ToString()))
{
resultFinal.IsSuccess = true;
resultFinal.Result.isPass = true;
resultFinal.Msg = Resource.OperationSendSuccess;
return resultFinal;
}
}
}
resultFinal.Msg = resultMachine.Msg;
return resultFinal;
}
}
#endregion
#region 1.判断条码类别
if (productCode.Length < 3)//为模具条码
{
#region
operationServiceParam.model = new MachineInfoModels();
operationServiceParam.model.MODELCODE = productCode;
DataResult modelResult = this.ValidateModel(operationServiceParam);
if (modelResult.IsSuccess == false)
{
resultFinal.Msg = modelResult.Msg;
return resultFinal;
}
#endregion
}
if (productCode.Length > 3)//为零件条码
{
#region 1.处理零件信息，添加外购件，设置零件类别
DataResult<Product> resultProduct = this.ExplainProduct(productCode, operationServiceParam);
if (resultProduct.IsSuccess == false)//零件处理失败
{
resultFinal.Msg = resultProduct.Msg;
return resultFinal;
}
#endregion
//OperationServiceParam operationServiceParam
#region 2.零件的属性校验，是否合格
DataResult<OperationServiceParam> dataResultObject = this.ValidateProudct(resultProduct.Result, operationServiceParam);
operationServiceParam = dataResultObject.Result as OperationServiceParam;
if (dataResultObject.IsSuccess == false)//零件校验不通过
{
resultFinal.Msg = dataResultObject.Msg;
return resultFinal;
}
#endregion
#region 3.校验零件是否符合加工先决条件
if (dataResultObject.BackStatus)//为本体
{
Main main = operationServiceParam.main;
//校验先决条件
DataResult<OperationServiceParam> dataResultRule = this.ValidateProcessRules(main, operationServiceParam);
if (dataResultRule.IsSuccess == false)
{
if (dataResultRule.Result != null)
operationServiceParam.ruleList = dataResultRule.Result.ruleList;
resultFinal.Msg = dataResultRule.Msg;
return resultFinal;
}
//更新先决条件列表
DataResult<OperationServiceParam> resultRules = this.SetRules(main, operationServiceParam);
if (resultRules.IsSuccess == false)
{
resultFinal.Msg = resultRules.Msg;
return resultFinal;
}
operationServiceParam = resultRules.Result;
}
else//为零件
{
Product product = operationServiceParam.product;
//校验先决条件
result = this.ValidateProcessRules(product, operationServiceParam);
if (result.IsSuccess == false)
{
resultFinal.Msg = result.Msg;
return resultFinal;
}
//更新先决条件列表
DataResult<OperationServiceParam> resultRules = this.SetRules(product, operationServiceParam);
if (resultRules.IsSuccess == false)
{
resultFinal.Msg = resultRules.Msg;
return resultFinal;
}
operationServiceParam = resultRules.Result;
}
resultFinal.Result = operationServiceParam;//更新完先决条件就加入返回值中
#endregion
}
#endregion
#region 4.判断加工先决条件是否全部通过
if (this.ValidateResult(operationServiceParam) == false)
{
resultFinal.Msg = "";
return resultFinal;
}
#endregion
#region 5.更新加工零件状态并发送设备指令
result = this.SaveAndSendOrder(operationServiceParam);
if (result.IsSuccess == false)
{
resultFinal.Msg = result.Msg;
return resultFinal;
}
#endregion
resultFinal.Result.isPass = true;
resultFinal.Msg = Resource.OperationSendSuccess;
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工操作-流程加工"
});
result.IsSuccess = false;
resultFinal.Msg = Resource.SystemException;
}
return resultFinal;
}
/// <summary>
/// 校验模具
/// </summary>
/// <returns></returns>
public DataResult ValidateModel(OperationServiceParam operationServiceParam)
{
DataResult result = new DataResult();
if (operationServiceParam.machineInfo.MODELS == null || operationServiceParam.machineInfo.MODELS.Count == 0)
{
result.Msg = Resource.NotHaveMoreModel;
result.IsSuccess = false;
return result;
}
//获取模具内容
if ( !string.IsNullOrEmpty(operationServiceParam.model.MODELCODE))
{
operationServiceParam.model = operationServiceParam.machineInfo.MODELS.Find(m => m.MODELCODE == operationServiceParam.model.MODELCODE);
}
if ( operationServiceParam.model == null)
{
result.Msg = Resource.NotHaveThisModel;
result.IsSuccess = false;
return result;
}
#region 模架使用校验
//2016-6-27 闫永刚 获取模架号加工状态信息
//如果该模架正在加工中，那么不能进行操作，
if (operationServiceParam.machineInfo.ISCONTROL == "3")
{
MainMolderStatus entity = new MainMolderStatusDAL().Get(
new MainMolderStatus()
{
MACHINECODDE = operationServiceParam.machineInfo.MACHINECODDE,
MOLDNUMBER = operationServiceParam.model.MODELCODE
}
);
if (entity.OPERATIONFLAG.ToString() == EnumGeter.OPERATIONFLAG.BUSY.GetHashCode().ToString()
)
{
result.Msg = string.Format("模架{0}正在加工中,请等待加工完成或是手动放行!", operationServiceParam.model.MODELCODE);
result.IsSuccess = false;
return result;
}
}
#endregion
ProcessRule roleModel = operationServiceParam.ruleList.Find(m=>m.RULETYPE==EnumGeter.RULETYPE.MODEL.GetHashCode().ToString());
roleModel.RULECONTENTTEXT = operationServiceParam.model.MODELNAME;
//加入模具对零件的校验
if (operationServiceParam.model.ISVALIDATE.Equals(EnumGeter.YESORNO.YES.GetHashCode().ToString()))//当前模具有条件判断
{
//判断零件类别
if (operationServiceParam.model.PRODUCTTYPE.Equals(EnumGeter.ProductType.benti.GetHashCode().ToString()))//如果是本体的话
{
//一共预置了3个零件的属性条件
if (operationServiceParam.main != null)
{
#region 校验3个预制属性
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE1) == false)
{
string value1 = operationServiceParam.main.GetType().GetProperty(operationServiceParam.model.ATTRBUTE1).GetValue(operationServiceParam.main, null).ToString();
if (value1.Equals(operationServiceParam.model.VALUE1) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE2) == false)
{
string value2 = operationServiceParam.main.GetType().GetProperty(operationServiceParam.model.ATTRBUTE2).GetValue(operationServiceParam.main, null).ToString();
if (value2.Equals(operationServiceParam.model.VALUE2) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE3) == false)
{
string value3 = operationServiceParam.main.GetType().GetProperty(operationServiceParam.model.ATTRBUTE3).GetValue(operationServiceParam.main, null).ToString();
if (value3.Equals(operationServiceParam.model.VALUE3) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
#endregion
//设置先决条件为通过
ProcessRule rule = operationServiceParam.ruleList.Find(m => m.RULETYPE == EnumGeter.RULETYPE.MODEL.GetHashCode().ToString());
if (rule != null)//前置工序
{
SetResult(rule, true);
}
}
else//加工零件为本体但是却没有本体只有找表皮
{
Product product = operationServiceParam.productList.Find(m => m.PRODUCTTYPE == EnumGeter.ProductType.biaopi.GetHashCode().ToString());
if (product != null)
{
#region 校验3个预制属性
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE1) == false)
{
string value1 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE1).GetValue(product, null).ToString();
if (value1.Equals(operationServiceParam.model.VALUE1) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE2) == false)
{
string value2 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE2).GetValue(product, null).ToString();
if (value2.Equals(operationServiceParam.model.VALUE2) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE3) == false)
{
string value3 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE3).GetValue(product, null).ToString();
if (value3.Equals(operationServiceParam.model.VALUE3) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
#endregion
//设置先决条件为通过
ProcessRule rule = operationServiceParam.ruleList.Find(m => m.RULETYPE == EnumGeter.RULETYPE.MODEL.GetHashCode().ToString());
if (rule != null)//前置工序
{
SetResult(rule, true);
}
}
}
}
else//为零件
{
Product product = operationServiceParam.productList.Find(m => m.PRODUCTTYPE == operationServiceParam.model.PRODUCTTYPE);
if (product != null)
{
#region 校验3个预制属性
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE1) == false)
{
string value1 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE1).GetValue(product, null).ToString();
if (value1.Equals(operationServiceParam.model.VALUE1) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE2) == false)
{
string value2 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE2).GetValue(product, null).ToString();
if (value2.Equals(operationServiceParam.model.VALUE2) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
if (string.IsNullOrEmpty(operationServiceParam.model.ATTRBUTE3) == false)
{
string value3 = product.GetType().GetProperty(operationServiceParam.model.ATTRBUTE3).GetValue(product, null).ToString();
if (value3.Equals(operationServiceParam.model.VALUE3) == false)
{
result.Msg = Resource.OperationFitModel;
return result;
}
}
#endregion
//设置先决条件为通过
ProcessRule rule = operationServiceParam.ruleList.Find(m => m.RULETYPE == EnumGeter.RULETYPE.MODEL.GetHashCode().ToString());
if (rule != null)//前置工序
{
SetResult(rule, true);
}
}
}
}
result.Msg = Resource.SuccessGetModel;
result.IsSuccess = true;
return result;
}
public DataResult<Main> GetMainCode(Product entity)
{
DataResult<Main> result = new DataResult<Main>();
Main main = new Main();
string mainCode = "";
PrintCode printcode = new MainDAL().GetMaxMainCode(entity.MATERIAL_CODE);
if (string.IsNullOrEmpty(printcode.MAINCODE))
{
mainCode = "1";
}
else
{
mainCode = (Convert.ToInt32(mainCode) + 1) + "";
}
main.MAINCODE = "052 4XR" + mainCode.PadLeft(7, '0');
main.MAINCODE = new FileCopyRecordDAL().GetBarcode(main.MAINCODE);
result.Result = main;
return result;
}
/// <summary>
/// 填充传递参数
/// </summary>
/// <returns></returns>
public DataResult GetParamModels(OperationServiceParam operationServiceParam)
{
DataResult result = new DataResult();
try
{
#region 1. 获取当前设备工序所对应的工序类别
string mainProductType = operationServiceParam.processSet.PRODUCTTYPE.ToString();
//根据类别获取productBasic
ProductBasic basic = new ProductBasicBLL().GetByCode(new ProductBasic { PRODUCTTYPE = mainProductType });
if (basic == null)
{
result.Msg = Resource.OperationProTypeError;
result.IsSuccess = false;
return result;
}
#endregion
try
{
if (operationServiceParam.machineInfo.PROCESSTYPE == EnumGeter.ProcessType.jiaozhu.GetHashCode().ToString())
{
//LogManager.LogHelper.Info(new LogInfo() { Info = "mainProductType=" + mainProductType.ToString() });
//LogManager.LogHelper.Info(new LogInfo() { Info = "ISPARENT=" + basic.ISPARENT.ToString() });
//LogManager.LogHelper.Info(new LogInfo() { Info = "operationServiceParam.main:" + (operationServiceParam.main == null ? "null" : " No null") });
//LogManager.LogHelper.Info(new LogInfo() { Info = "basic.ISPARENT:" + basic.ISPARENT.ToString() });
//LogManager.LogHelper.Info(new LogInfo() { Info = "PRODUCTISPARENT.yes:" + EnumGeter.PRODUCTISPARENT.yes.GetHashCode().ToString() });
}
}
catch (Exception)
{
LogManager.LogHelper.Info(new LogInfo() { Info = "异常" });
}
#region 2.根据是否为父级标识，以及是否存在本体 ，判断是否新增本体数据
//if (basic.ISPARENT.Equals(EnumGeter.PRODUCTISPARENT.yes.GetHashCode().ToString())
// && operationServiceParam.main == null)//是父级
//LogManager.LogHelper.Info(new LogInfo() { Info = "operationServiceParam.main:" + (operationServiceParam.main == null ? "null" : " No null") });
if (operationServiceParam.machineInfo.PROCESSTYPE == EnumGeter.ProcessType.jiaozhu.GetHashCode().ToString())
{
//闫永刚 2016-9-14 增加一个额外处理,浇注扫描表皮和骨架两个码，
//实际情况中个别时候出现两个表皮和一个骨架的情况，winform的校验有时候会失效，无法找到原因
//所以在这里加一段代码把第一个表皮或是第一个骨架去除
try
{
foreach (var p in operationServiceParam.productList)
{
LogManager.LogHelper.Info(new LogInfo() { Info = "PRODUCTOCDE:" + ((p.PRODUCTCODE != null ? p.PRODUCTCODE : "")) + "PRODUCTTYPE:" + ((p.PRODUCTTYPE != null ? p.PRODUCTTYPE : "")) });
}
}
catch (Exception ex)
{
LogManager.LogHelper.Info(new LogInfo() { Info = "异常" });
}
Main main = new Main();
main.PID = "";//新id
//获取骨架
Product pSk = operationServiceParam.productList.Find(m => m.PRODUCTTYPE == EnumGeter.ProductType.gujia.GetHashCode().ToString());
if (pSk == null)
{
result.Msg = Resource.OperationNotFoundGuJia;
result.IsSuccess = false;
return result;
}
main.SKID = pSk.PID;//骨架
main.SKELETONCODE = pSk.PRODUCTCODE;//骨架条码
//获取表皮
Product pEP = operationServiceParam.productList.Find(m => m.PRODUCTTYPE == EnumGeter.ProductType.biaopi.GetHashCode().ToString());
if (pEP == null)
{
result.Msg = Resource.OperationNotFoundBiaoPi;
result.IsSuccess = false;
return result;
}
main.EID = pEP.PID;//表皮
main.EPIDERMISCODE = pEP.PRODUCTCODE;//表皮条码
main.HB = pEP.VAL3;//高低配
main.COLOR = pEP.VAL4;//颜色
main.MACHINECODDE = operationServiceParam.machineInfo.MACHINECODDE;
main.PROCESSSTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
main.STATUS = EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString();
main.CURRENTPROCESS = operationServiceParam.processSet.PROCESSTYPE;
main.COMPLETEFLAG = EnumGeter.COMPLETEFLAG.PROCESSING.GetHashCode().ToString();
main.PRODUCELINE = EnumGeter.PRODUCELINE.B9.ToString();
main.PRODUCESHIFTNAME = operationServiceParam.produceShift.PRODUCESHIFTNAME;
main.PRODUCESHIFTTCODE = operationServiceParam.produceShift.PRODUCESHIFTTCODE;
main.OUTFLAG = EnumGeter.OUTFLAG.INWAREHOUSE.GetHashCode().ToString();
main.CREATEUSER = this.LoginUser.UserID;
main.CREATEDATE = DateTime.Now;
main.UPDATEUSER = main.CREATEUSER;
main.UPDATEDATE = main.CREATEDATE;
operationServiceParam.main = main;
}
if (operationServiceParam.main != null)
{
operationServiceParam.main.PROCESSSTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
}
#endregion
#region 判断是否装配，如果为装配那么需要生成装配条码
if (operationServiceParam.processSet.PROCESSTYPE.Equals(EnumGeter.ProcessType.zongchengzhuangpei.GetHashCode().ToString()))
{
//string mainCode = new MainDAL().GetMaxMainCode();
//if (string.IsNullOrEmpty(mainCode))
//{
// mainCode = "1";
//}
PrintCode printCode = new MainDAL().GetMaxMainCode(operationServiceParam.mainOperation.MATERIAL_CODE);
string mainCode = "";
if (string.IsNullOrEmpty(printCode.MAINCODE))
{
mainCode = "1";
}
else
{
mainCode = (Convert.ToInt32(mainCode) + 1) + "";
}
operationServiceParam.main.MAINCODE = "052 4XR" + mainCode.PadLeft(7, '0');
operationServiceParam.main.MAINCODE = new FileCopyRecordDAL().GetBarcode(operationServiceParam.main.MAINCODE);
operationServiceParam.main.COMPLETETIME = DateTime.Now;
//调用打印方法
//string xmlPath = "../../XMLResources/Biaopi.xml";
//BarcodeLib.BarCodeGenerate generate = new BarcodeLib.BarCodeGenerate();
//generate.PrintBarCode(operationServiceParam.main.MAINCODE, xmlPath);
}
#endregion
#region 3.处理零件与本体关联关系
//处理零件
//零件在判断先决条件的时候已做处理
//处理本体与零件关系
List<MainProduct> mainProducts = new List<MainProduct>();
if (operationServiceParam.main != null)
{
foreach (Product item in operationServiceParam.productList)
{
MainProduct mainProduct = new MainProduct();
mainProduct.MID = "";
mainProduct.PDID = item.PID;
mainProduct.COUNT = item.useCount;
mainProduct.MOID = "";//加工记录pid
mainProduct.CREATEUSER = this.LoginUser.UserID;
mainProduct.CREATEDATE = DateTime.Now;
mainProduct.UPDATEUSER = mainProduct.CREATEUSER;
mainProduct.UPDATEDATE = mainProduct.CREATEDATE;
mainProducts.Add(mainProduct);
}
}
operationServiceParam.mainProductList = mainProducts;
#endregion
#region 4.处理生产记录
//处理生产记录
MainOperation mainOperation = new MainOperation();
mainOperation.PID = "";
mainOperation.PDID = "";//判断生产类别 如果是本体 或者零件
if (operationServiceParam.processSet.PRODUCTTYPE.Equals(EnumGeter.ProductType.benti.GetHashCode().ToString()))
{
mainOperation.PDID = operationServiceParam.main.PID;
mainOperation.PRODUCTCODE = operationServiceParam.main.EPIDERMISCODE;//采用表皮的条码
if(operationServiceParam.productList.Count>0)
{
List<Product> prolist = operationServiceParam.productList.OrderBy(o => o.PRODUCTCODE).ToList<Product>();
foreach (var p in prolist)
{
if (p.PRODUCTCODE != mainOperation.PRODUCTCODE)
{
mainOperation.PRODUCTCODESTR += p.PRODUCTCODE;
mainOperation.PRODUCTCODESTR += ":";
}
}
if (mainOperation.PRODUCTCODESTR.Length > 0)
{
mainOperation.PRODUCTCODESTR = mainOperation.PRODUCTCODESTR.Substring(0, mainOperation.PRODUCTCODESTR.Length - 1);
}
}
}
else
{
//找到加工零件类别
Product p;
if (operationServiceParam.productList.Count > 1)
{
p = operationServiceParam.productList.Find(m => m.PRODUCTTYPE == operationServiceParam.processSet.PRODUCTTYPE.ToString());
}
else//为了风道设置
{
p = operationServiceParam.productList[0];
mainOperation.PRODUCTTYPE = p.PRODUCTTYPE;
}
mainOperation.PDID = p.PID;
mainOperation.PRODUCTCODE = p.PRODUCTCODE;
}
if (string.IsNullOrEmpty(mainOperation.PRODUCTTYPE))
{
mainOperation.PRODUCTTYPE = operationServiceParam.processSet.PRODUCTTYPE.ToString();
}
mainOperation.PROCESSTYPE = operationServiceParam.processSet.PROCESSTYPE.ToString();
mainOperation.MACHINECODDE = operationServiceParam.machineInfo.MACHINECODDE;
mainOperation.MACHINENAME = operationServiceParam.machineInfo.MACHINENAME;
mainOperation.STATUS = EnumGeter.PRODUCTSTAUTS.QUALIFIED.GetHashCode().ToString();
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation.CURRENTPROCESS = operationServiceParam.processSet.PROCESSTYPE.ToString();
mainOperation.PRODUCESHIFTNAME = operationServiceParam.produceShift.PRODUCESHIFTNAME;
mainOperation.PRODUCESHIFTTCODE = operationServiceParam.produceShift.PRODUCESHIFTTCODE;
mainOperation.MOLDNUMBER = operationServiceParam.machineInfo.MOLDNUMBER;
if (string.IsNullOrEmpty(mainOperation.MOLDNUMBER ))
{
mainOperation.MOLDNUMBER = "1";
}
mainOperation.CREATEUSER = this.LoginUser.UserID;
mainOperation.CREATEDATE = DateTime.Now;
mainOperation.UPDATEUSER = mainOperation.CREATEUSER;
mainOperation.UPDATEDATE = mainOperation.CREATEDATE;
mainOperation.PRODUCELINE = EnumGeter.PRODUCELINE.B9.ToString();
//mainOperation.PRODUCELINE = EnumGeter.PRODUCELINE.B9.ToString();
if (operationServiceParam.model != null)
{
mainOperation.MODELSTATION = operationServiceParam.model.MODELCODE;//模具
}
else
{
mainOperation.MODELSTATION = "1";
}
operationServiceParam.mainOperation = mainOperation;
#endregion
#region 设置设备模架加工状态
//2016-6-27 闫永刚
//设置模架加工状态
if (operationServiceParam.machineInfo.ISCONTROL == "3")
{
MainMolderStatus mainMolderStatus = new MainMolderStatus();
mainMolderStatus.MACHINECODDE = operationServiceParam.machineInfo.MACHINECODDE;
mainMolderStatus.MOLDNUMBER = mainOperation.MOLDNUMBER;
mainMolderStatus.OPERATIONFLAG = Convert.ToInt32(EnumGeter.OPERATIONFLAG.BUSY.GetHashCode().ToString());
mainMolderStatus.BARCODE = "";
operationServiceParam.mainMolderStatus = mainMolderStatus;
}
#endregion
result.IsSuccess = true;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Msg = ex.Message;
throw;
}
return result;
}
/// <summary>
/// 插入信息(单表)
/// </summary>
/// <param name="">信息</param>
/// <returns>插入行数</returns>
public DataResult<int> MachineOperation(OperationServiceParam model)
{
DataResult<int> result = new DataResult<int>();
int count = 0;
using (IDataSession session = AppDataFactory.CreateMainSession())
{
try
{
session.OpenCon();
#region 1. 更新插入主体表
MainDAL mainDAL = new MainDAL();
mainDAL.BaseSession = session;
if (model.main != null)
{
if (string.IsNullOrEmpty(model.main.PID))
{
model.main.PID = Guid.NewGuid().ToString();
model.main.CREATEUSER = this.LoginUser.UserID;
model.main.CREATEDATE = DateTime.Now;
model.main.UPDATEUSER = model.main.CREATEUSER;
model.main.UPDATEDATE = DateTime.Now;
count = mainDAL.Insert(model.main);
if (model.machineInfo.ISCONTROL == "3")
{
model.mainMolderStatus.BARCODE += model.main.SKELETONCODE;
}
}
else
{
model.main.UPDATEUSER = model.main.CREATEUSER;
count = mainDAL.Update(model.main);
}
if (model.machineInfo.ISCONTROL == "3")
{
model.mainMolderStatus.BARCODE += model.main.EPIDERMISCODE;
}
}
#endregion
#region 2.补充更新零件的属性
//填充加工记录
if (model.mainOperation != null)
{
if (model.main != null)
{
model.mainOperation.PDID = model.main.PID;
}
else
{
model.mainOperation.PDID = model.productList[0].PID;
}
model.mainOperation.PID = Guid.NewGuid().ToString();
model.mainOperation.CREATEUSER = this.LoginUser.UserID;
model.mainOperation.CREATEDATE = DateTime.Now;
model.mainOperation.UPDATEUSER = model.mainOperation.CREATEUSER;
model.mainOperation.UPDATEDATE = DateTime.Now;
}
#endregion
#region 3.填充本体零件关系
if (model.mainProductList != null && model.mainProductList.Count > 0)
{
foreach (var item in model.mainProductList)
{
item.PID = Guid.NewGuid().ToString();
item.MID = model.main.PID;
item.MOID = model.mainOperation.PID;
item.CREATEUSER = this.LoginUser.UserID;
item.CREATEDATE = DateTime.Now;
item.UPDATEUSER = item.CREATEUSER;
item.UPDATEDATE = DateTime.Now;
}
}
#endregion
#region 4. 保存主体零件关系表
if (model.mainProductList != null && model.mainProductList.Count > 0)
{
MainProductDAL mainProductDAL = new MainProductDAL();
mainProductDAL.BaseSession = session;
count = mainProductDAL.Insert(model.mainProductList);
}
#endregion
#region 5.更新零件表
if (model.productList != null && model.productList.Count > 0)
{
ProductDAL productDAL = new ProductDAL();
productDAL.BaseSession = session;
count = productDAL.Update(model.productList);
if (model.machineInfo.ISCONTROL == "3")
{
foreach (var p in model.productList)
{
if (model.mainMolderStatus.BARCODE.Contains(p.PRODUCTCODE) == false)
{
model.mainMolderStatus.BARCODE += p.PRODUCTCODE;
}
}
}
}
#endregion
#region 6. 插入记录表
MainOperationDAL mainOperationDAL = new MainOperationDAL();
mainOperationDAL.BaseSession = session;
count = mainOperationDAL.Insert(model.mainOperation);
#endregion
#region 更新模架加工状态
//2016-6-27 闫永刚
//更新模架加工状态
if (model.machineInfo.ISCONTROL == "3")
{
//2016-6-27 闫永刚
//更新
MainMolderStatusDAL mmdal = new MainMolderStatusDAL();
mmdal.BaseSession = session;
mmdal.Update(model.mainMolderStatus);
}
#endregion
session.CommitTs();
result.Result = count;
result.IsSuccess = true; ;
result.Msg = Resource.MsgSuccess;
}
catch (Exception ex)
{
session.RollbackTs();
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工操作保存发送-插入信息"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw;
}
}
return result;
}
#region 放行
/// <summary>
/// 放行零件
/// </summary>
/// <param name="partCode">传递参数</param>
/// <returns></returns>
public DataResult SetPassProcess(Product product)
{
DataResult result = new DataResult();
try
{
//获取零件信息
Main main = new Main();
MainOperation mainOperation = new MainOperation();
product = new ProductBLL().GetByCondition(product);
if (product == null)//没有找到零件
{
result.IsSuccess = false;
result.Msg = Resource.OperationProNotFound;
return result;
}
if (product.PRODUCTTYPE.Equals(EnumGeter.ProductType.biaopi.GetHashCode().ToString()) && product.USINGSTATE.Equals(EnumGeter.USINGSTATE.UNUSED.GetHashCode().ToString()) == false)
{
#region 该零件为本体
product.IsMain = true;
main.publicCode = product.PRODUCTCODE.Trim();
main = new MainBLL().GetByCondition(main);
mainOperation.PDID = main.PID;
mainOperation.PROCESSTYPE = main.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = "没有找到生产记录,请先进行撤销操作!";
return result;
}
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
//1.更新零件状态
//获取当前零件类别的工序
List<ProcessSet> listProcess = new ProcessSetBLL().GetAllList(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString() });
listProcess.Sort((m, n) => { return m.PROCESSINDEX.CompareTo(n.PROCESSINDEX); });
int currentIndex = listProcess.FindIndex(m => m.PROCESSTYPE == main.CURRENTPROCESS);
if (currentIndex >= listProcess.Count-1)//最后一道工序，做完结操作
{
main.COMPLETEFLAG = EnumGeter.COMPLETEFLAG.COMPLETED.GetHashCode().ToString();
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
else//设置到下一道工序
{
main.CURRENTPROCESS = listProcess[currentIndex + 1].PROCESSTYPE;
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
//2.更新生产记录
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
mainOperation.OPERATEDDATE = DateTime.Now;
#endregion
}
else
{
#region 该零件为零件
product.IsMain = false;
mainOperation.PDID = product.PID;
mainOperation.PROCESSTYPE = product.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = "没有找到生产记录,请先进行撤销操作!";
return result;
}
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
//1.更新零件状态
//获取当前零件类别的工序
List<ProcessSet> listProcess = new ProcessSetBLL().GetAllList(new ProcessSet { PRODUCTTYPE = product.PRODUCTTYPE });
listProcess.Sort((m, n) => { return m.PROCESSINDEX.CompareTo(n.PROCESSINDEX); });
int currentIndex = listProcess.FindIndex(m => m.PROCESSTYPE == product.CURRENTPROCESS);
if (currentIndex >= listProcess.Count)//最后一道工序，做完结操作
{
if (product.CAPACITY <= product.USINGCOUNT)
{
product.USINGSTATE = EnumGeter.USINGSTATE.USED.GetHashCode().ToString();
}
}
else//设置到下一道工序
{
product.CURRENTPROCESS = listProcess[currentIndex + 1].PROCESSTYPE;
}
//2.更新生产记录
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
mainOperation.OPERATEDDATE = DateTime.Now;
#endregion
}
using (IDataSession session = AppDataFactory.CreateMainSession())
{
session.OpenCon();
int count = 0;
#region 1. 更新插入主体表
if (product.IsMain)
{
count = new MainDAL().Update(main);
}
else
{
count = new ProductDAL().Update(product);
}
#endregion
#region 2. 更新记录表
MainOperationDAL mainOperationDAL = new MainOperationDAL();
mainOperationDAL.BaseSession = session;
count = mainOperationDAL.Update(mainOperation);
#endregion
#region
//2016-06-27 闫永刚
//设置模架状态为空闲
MainMolderStatusDAL mmdal = new MainMolderStatusDAL();
mmdal.BaseSession = session;
mmdal.Update(new MainMolderStatus() { MACHINECODDE = mainOperation.MACHINECODDE, OPERATIONFLAG = Convert.ToInt32(EnumGeter.OPERATIONFLAG.FREE.GetHashCode().ToString()), MOLDNUMBER = mainOperation.MOLDNUMBER ,BARCODE=""});
#endregion
session.CommitTs();
result.IsSuccess = true;
result.Msg = Resource.SetPassSuccess;
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "零件工序放行"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw;
}
return result;
}
public DataResult SetPunchingPassProcess()
{
DataResult result = new DataResult();
try
{
//获取零件信息
Main main = new Main();
main.CURRENTPROCESS = EnumGeter.ProcessType.chongqie.GetHashCode().ToString();
main.PROCESSSTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
main = new MainBLL().GetByCondition(main);
if (main != null && string.IsNullOrEmpty(main.PID) == false)
{
main = new MainBLL().Get(main);
}
LogManager.LogHelper.Info(new LogInfo() { Info = "t1" });
MainOperation mainOperation = new MainOperation();
#region 该零件为本体
mainOperation.PDID = main.PID;
mainOperation.PROCESSTYPE = main.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = "没有找到生产记录,请先进行撤销操作!";
return result;
}
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
//1.更新零件状态
//获取当前零件类别的工序
List<ProcessSet> listProcess = new ProcessSetBLL().GetAllList(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString() });
listProcess.Sort((m, n) => { return m.PROCESSINDEX.CompareTo(n.PROCESSINDEX); });
int currentIndex = listProcess.FindIndex(m => m.PROCESSTYPE == main.CURRENTPROCESS);
if (currentIndex >= listProcess.Count - 1)//最后一道工序，做完结操作
{
main.COMPLETEFLAG = EnumGeter.COMPLETEFLAG.COMPLETED.GetHashCode().ToString();
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
else//设置到下一道工序
{
main.CURRENTPROCESS = listProcess[currentIndex + 1].PROCESSTYPE;
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
//2.更新生产记录
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.COMPLETED.GetHashCode().ToString();
mainOperation.OPERATEDDATE = DateTime.Now;
#endregion
LogManager.LogHelper.Info(new LogInfo() { Info = "t2" });
using (IDataSession session = AppDataFactory.CreateMainSession())
{
session.OpenCon();
int count = 0;
#region 1. 更新插入主体表
count = new MainDAL().Update(main);
#endregion
#region 2. 更新记录表
MainOperationDAL mainOperationDAL = new MainOperationDAL();
mainOperationDAL.BaseSession = session;
count = mainOperationDAL.Update(mainOperation);
#endregion
#region
//2016-06-27 闫永刚
//设置模架状态为空闲
MainMolderStatusDAL mmdal = new MainMolderStatusDAL();
mmdal.BaseSession = session;
mmdal.Update(new MainMolderStatus() { MACHINECODDE = mainOperation.MACHINECODDE, OPERATIONFLAG = Convert.ToInt32(EnumGeter.OPERATIONFLAG.FREE.GetHashCode().ToString()), MOLDNUMBER = mainOperation.MOLDNUMBER, BARCODE = "" });
#endregion
#region
PunchParameter parameter = new PunchParameter(mainOperation.PRODUCTCODE);
parameter.PID = Guid.NewGuid().ToString();
parameter.MOID = mainOperation.PID;
parameter.PDID = mainOperation.PDID;
parameter.PRODUCTTYPE = mainOperation.PRODUCTTYPE;
parameter.PRODUCTCODE = mainOperation.PRODUCTCODE;
parameter.MACHINECODDE = mainOperation.MACHINECODDE;
parameter.MACHINENAME = mainOperation.MACHINENAME;
parameter.CREATEDATE = System.DateTime.Now;
//PunchParameterDAL paraDal = new PunchParameterDAL();
//paraDal.BaseSession = session;
//paraDal.Insert(parameter);
#endregion
session.CommitTs();
result.IsSuccess = false;
result.Msg = "自动放行冲切工序,请再次扫描该条码!";
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "Punch realse unpunch exception"
});
result.IsSuccess = false;
result.Msg = "冲切工序已自动放行,请再次扫描该条码!";
throw;
}
return result;
}
public DataResult SetPunchingPassProcess(Main model)
{
DataResult result = new DataResult();
try
{
//获取零件信息
Main main = new Main();
main = new MainBLL().Get(model);
MainOperation mainOperation = new MainOperation();
#region 该零件为本体
mainOperation.PDID = main.PID;
mainOperation.PROCESSTYPE = main.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = "没有找到生产记录,请先进行撤销操作!";
return result;
}
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
//1.更新零件状态
//获取当前零件类别的工序
List<ProcessSet> listProcess = new ProcessSetBLL().GetAllList(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString() });
listProcess.Sort((m, n) => { return m.PROCESSINDEX.CompareTo(n.PROCESSINDEX); });
int currentIndex = listProcess.FindIndex(m => m.PROCESSTYPE == main.CURRENTPROCESS);
if (currentIndex >= listProcess.Count - 1)//最后一道工序，做完结操作
{
main.COMPLETEFLAG = EnumGeter.COMPLETEFLAG.COMPLETED.GetHashCode().ToString();
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
else//设置到下一道工序
{
main.CURRENTPROCESS = listProcess[currentIndex + 1].PROCESSTYPE;
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
//2.更新生产记录
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.COMPLETED.GetHashCode().ToString();
mainOperation.OPERATEDDATE = DateTime.Now;
#endregion
using (IDataSession session = AppDataFactory.CreateMainSession())
{
session.OpenCon();
int count = 0;
#region 1. 更新插入主体表
count = new MainDAL().Update(main);
#endregion
#region 2. 更新记录表
MainOperationDAL mainOperationDAL = new MainOperationDAL();
mainOperationDAL.BaseSession = session;
count = mainOperationDAL.Update(mainOperation);
#endregion
#region
//2016-06-27 闫永刚
//设置模架状态为空闲
MainMolderStatusDAL mmdal = new MainMolderStatusDAL();
mmdal.BaseSession = session;
mmdal.Update(new MainMolderStatus() { MACHINECODDE = mainOperation.MACHINECODDE, OPERATIONFLAG = Convert.ToInt32(EnumGeter.OPERATIONFLAG.FREE.GetHashCode().ToString()), MOLDNUMBER = mainOperation.MOLDNUMBER, BARCODE = "" });
#endregion
#region
PunchParameter parameter = new PunchParameter(mainOperation.PRODUCTCODE);
parameter.PID = Guid.NewGuid().ToString();
parameter.MOID = mainOperation.PID;
parameter.PDID = mainOperation.PDID;
parameter.PRODUCTTYPE = mainOperation.PRODUCTTYPE;
parameter.PRODUCTCODE = mainOperation.PRODUCTCODE;
parameter.MACHINECODDE = mainOperation.MACHINECODDE;
parameter.MACHINENAME = mainOperation.MACHINENAME;
parameter.CREATEDATE = System.DateTime.Now;
//PunchParameterDAL paraDal = new PunchParameterDAL();
//paraDal.BaseSession = session;
//paraDal.Insert(parameter);
#endregion
session.CommitTs();
result.IsSuccess = false;
result.Msg = "自动放行冲切工序,请再次扫描该条码进行铣削操作!";
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "Mill realse UnPunch exception"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException + "Mill realse UnPunch exception";
throw;
}
return result;
}
#endregion
#region 撤销加工
/// <summary>
/// 撤销加工
/// </summary>
/// <param name="partCode">传递参数</param>
/// <returns></returns>
public DataResult SetRecovery(Product product)
{
DataResult result = new DataResult();
try
{
//获取零件信息
Main main = new Main();
MainOperation mainOperation = new MainOperation();
product = new ProductBLL().GetByCondition(product);
if (product == null)//没有找到零件
{
result.IsSuccess = false;
result.Msg = Resource.OperationProNotFound;
return result;
}
if (product.PRODUCTTYPE.Equals(EnumGeter.ProductType.biaopi.GetHashCode().ToString()) && product.USINGSTATE.Equals(EnumGeter.USINGSTATE.UNUSED.GetHashCode().ToString()) == false)
{
#region 该零件为本体
product.IsMain = true;
main.publicCode = product.PRODUCTCODE.Trim();
main = new MainBLL().GetByCondition(main);
mainOperation.PDID = main.PID;
mainOperation.PROCESSTYPE = main.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = Resource.NotHaveOperation;
//return result;
}
else
{
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
}
#endregion
}
else
{
#region 该零件为零件
product.IsMain = false;
mainOperation.PDID = product.PID;
mainOperation.PROCESSTYPE = product.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = Resource.NotHaveOperation;
return result;
}
else
{
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
//return result;
}
}
#endregion
}
using (IDataSession session = AppDataFactory.CreateMainSession())
{
session.OpenCon();
MainOperationDAL mainOpDal = new MainOperationDAL();
mainOpDal.BaseSession = session;
MainProductDAL mainProDal = new MainProductDAL();
mainProDal.BaseSession = session;
ProductDAL proDal = new ProductDAL();
proDal.BaseSession = session;
//获取零件关系表
List<MainProduct> listMainPro = mainProDal.GetList(new MainProduct { MOID = mainOperation.PID });
if (listMainPro.Count > 0)
{
foreach (MainProduct item in listMainPro)
{
Product pro = proDal.Get(new Product { PID = item.PDID });
if (pro != null)
{
pro.USINGCOUNT = pro.USINGCOUNT - item.COUNT;
if (pro.USINGCOUNT == 0)
{
pro.USINGSTATE = EnumGeter.USINGSTATE.UNUSED.GetHashCode().ToString();
}
else
{
pro.USINGSTATE = EnumGeter.USINGSTATE.USING.GetHashCode().ToString();
}
proDal.Update(pro);//更新零件
}
//删除零件关系
mainProDal.Delete(item);
}
}
//删除加工记录
if (mainOperation != null)
{
mainOpDal.Delete(mainOperation);
}
if (product.IsMain)
{
//更新本体状态
MainDAL mainDal = new MainDAL();
mainDal.BaseSession = session;
if (main.CURRENTPROCESS.Equals(EnumGeter.ProcessType.jiaozhu.GetHashCode().ToString()))
{
mainDal.Delete(main);
}
else
{
main.PROCESSSTATE = "1";
mainDal.Update(main);
}
}
#region 更新设备模架的加工状态为空闲
//2016-6-27 闫永刚
//设置模架状态为空闲
MainMolderStatusDAL mmdal = new MainMolderStatusDAL();
mmdal.BaseSession = session;
mmdal.Update(new MainMolderStatus() { MACHINECODDE = mainOperation.MACHINECODDE, OPERATIONFLAG = Convert.ToInt32(EnumGeter.OPERATIONFLAG.FREE.GetHashCode().ToString()), MOLDNUMBER = mainOperation.MOLDNUMBER, BARCODE = "" });
#endregion
session.CommitTs();
result.IsSuccess = true;
result.Msg = "撤销成功";
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "零件撤销"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw;
}
return result;
}
#endregion
#region 跳到下一工序不存在加工参数
/// <summary>
/// 零件
/// </summary>
/// <param name="partCode">传递参数</param>
/// <returns></returns>
public DataResult SetPassProcessToNext(Product product)
{
DataResult result = new DataResult();
try
{
//获取零件信息
Main main = new Main();
MainOperation mainOperation = new MainOperation();
product = new ProductBLL().GetByCondition(product);
if (product == null)//没有找到零件
{
result.IsSuccess = false;
result.Msg = Resource.OperationProNotFound;
return result;
}
if (product.PRODUCTTYPE.Equals(EnumGeter.ProductType.biaopi.GetHashCode().ToString())
&& product.USINGSTATE.Equals(EnumGeter.USINGSTATE.USED.GetHashCode().ToString())
)
{
#region 该零件为本体
product.IsMain = true;
main.publicCode = product.PRODUCTCODE.Trim();
main = new MainBLL().GetByCondition(main);
mainOperation.PDID = main.PID;
mainOperation.PROCESSTYPE = main.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = "没有找到生产记录,请先进行撤销操作!";
return result;
}
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
//1.更新零件状态
//获取当前零件类别的工序
List<ProcessSet> listProcess = new ProcessSetBLL().GetAllList(new ProcessSet { PRODUCTTYPE = EnumGeter.ProductType.benti.GetHashCode().ToString() });
listProcess.Sort((m, n) => { return m.PROCESSINDEX.CompareTo(n.PROCESSINDEX); });
int currentIndex = listProcess.FindIndex(m => m.PROCESSTYPE == main.CURRENTPROCESS);
if (currentIndex >= listProcess.Count - 1)//最后一道工序，做完结操作
{
main.COMPLETEFLAG = EnumGeter.COMPLETEFLAG.COMPLETED.GetHashCode().ToString();
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
else//设置到下一道工序
{
main.CURRENTPROCESS = listProcess[currentIndex + 1].PROCESSTYPE;
main.PROCESSSTATE = EnumGeter.OPERATESTATE.RELEASED.GetHashCode().ToString();
}
//2.更新生产记录
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.COMPLETED.GetHashCode().ToString();
mainOperation.OPERATEDDATE = DateTime.Now;
#endregion
}
else
{
#region 该零件为零件
product.IsMain = false;
mainOperation.PDID = product.PID;
mainOperation.PROCESSTYPE = product.CURRENTPROCESS;
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString();
mainOperation = this.GetByCondition(mainOperation);
if (mainOperation == null)//出错没有找到生产记录
{
result.IsSuccess = false;
result.Msg = "没有找到生产记录,请先进行撤销操作!";
return result;
}
if (mainOperation.OPERATESTATE.Equals(EnumGeter.OPERATESTATE.OPERATING.GetHashCode().ToString()) == false)//出错不是加工中
{
result.IsSuccess = false;
result.Msg = Resource.NotInOperating;
return result;
}
//1.更新零件状态
//获取当前零件类别的工序
List<ProcessSet> listProcess = new ProcessSetBLL().GetAllList(new ProcessSet { PRODUCTTYPE = product.PRODUCTTYPE });
listProcess.Sort((m, n) => { return m.PROCESSINDEX.CompareTo(n.PROCESSINDEX); });
int currentIndex = listProcess.FindIndex(m => m.PROCESSTYPE == product.CURRENTPROCESS);
if (currentIndex >= listProcess.Count)//最后一道工序，做完结操作
{
if (product.CAPACITY <= product.USINGCOUNT)
{
product.USINGSTATE = EnumGeter.USINGSTATE.USED.GetHashCode().ToString();
}
}
else//设置到下一道工序
{
product.CURRENTPROCESS = listProcess[currentIndex + 1].PROCESSTYPE;
}
//2.更新生产记录
mainOperation.OPERATESTATE = EnumGeter.OPERATESTATE.COMPLETED.GetHashCode().ToString();
mainOperation.OPERATEDDATE = DateTime.Now;
#endregion
}
using (IDataSession session = AppDataFactory.CreateMainSession())
{
session.OpenCon();
int count = 0;
#region 1. 更新插入主体表
if (product.IsMain)
{
count = new MainDAL().Update(main);
}
else
{
count = new ProductDAL().Update(product);
}
#endregion
#region 2. 更新记录表
MainOperationDAL mainOperationDAL = new MainOperationDAL();
mainOperationDAL.BaseSession = session;
count = mainOperationDAL.Update(mainOperation);
#endregion
session.CommitTs();
result.IsSuccess = true;
result.Msg = Resource.SetPassSuccess;
}
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "零件工序放行"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw;
}
return result;
}
#endregion
#region 获取加工记录列表（WEB根据工序查找设备加工参数）
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <param name="page">数据页</param>
/// <returns>数据页</returns>
public DataResult<DataPage> GetListWithParameterForWeb(MainOperation condition, DataPage page)
{
DataResult<DataPage> dataResult = new DataResult<DataPage>();
try
{
#region 获得加工参数标准值
var conditionPParameter = new ProcessParameter
{
WORKCELL_CODE=condition.WORKCELL_CODE,
};
var listPParameter = new ProcessParameterDAL().GetList(conditionPParameter);
//如果没有获取到参数，则无参数字段显示
if (listPParameter == null || listPParameter.Count == 0 || string.IsNullOrEmpty(condition.WORKCELL_CODE))
{
dataResult.Result = new MainOperationDAL().GetListWithOutParameter(condition, page);
}
#endregion
#region 获得加工记录及加工参数
else
{
condition.SelectCollumns = String.Join(",", listPParameter.Select(o => o.PARANAME));
condition.PARATABLENAME = listPParameter.FirstOrDefault().PARATABLENAME;
dataResult.Result = new MainOperationDAL().GetListWithParameter(condition, page);
}
if (dataResult.Result.Result == null)
{
dataResult.IsSuccess = false;
dataResult.Msg = QMAPP.FJC.Entity.Resource.NothingData;
dataResult.Result.Result = new DataTable();
return dataResult;
}
DataTable dtResult = dataResult.Result.Result as DataTable;
DictManageBLL dictColumnName = new DictManageBLL(DictKind.MAINOPERATIONSEARCHFORM);
DictManageBLL dictProcessType = new DictManageBLL(DictKind.PROCESSTYPE);
DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
DictManageBLL dictLJStatus = new DictManageBLL(DictKind.LJSTATUS);
DictManageBLL dictOperateState = new DictManageBLL(DictKind.OPERATESTATE);
DictManageBLL dictPSStatus = new DictManageBLL(DictKind.PRODUCTSTATUS);
IList<DataColumn> listDelColumn = new List<DataColumn>();
//转换枚举描述
foreach (DataRow item in dtResult.Rows)
{
//item["PROCESSTYPE"] = dictProcessType.GetDictValue(item["PROCESSTYPE"].ToString());
//item["PRODUCTTYPE"] = dictProductType.GetDictValue(item["PRODUCTTYPE"].ToString());
item["STATUS"] = dictPSStatus.GetDictValue(item["STATUS"].ToString());
item["OPERATESTATE"] = dictOperateState.GetDictValue(item["OPERATESTATE"].ToString());
//因为日期类型转成json绑定到页面显示格式错误，所以在datatable加上两个字符串型的操作时间和加工完成时间用于显示在页面上
if (!string.IsNullOrEmpty(item["OPERATEDDATESTR"].ToString()))
{
item["OPERATEDDATE"] = (Convert.ToDateTime(item["OPERATEDDATESTR"].ToString())).ToString("yyyy-MM-dd HH:mm:ss").Replace('/','-');
}
if (!string.IsNullOrEmpty(item["CREATEDATESTR"].ToString()))
{
item["CREATEDATE"] = Convert.ToDateTime(item["CREATEDATESTR"].ToString()).ToString("yyyy-MM-dd HH:mm:ss");
}
}
//设置标题
foreach (var item in dtResult.Columns.Cast<DataColumn>())
{
if (item.ColumnName == "OPERATEDDATE" || item.ColumnName == "CREATEDATE")
{
//移除原来datetime类型的OPERATEDDATE、CREATEDATE
//listDelColumn.Add(item);
}
else
{
var strColumnName = dictColumnName.GetDictValue(item.ColumnName);
if (string.IsNullOrEmpty(strColumnName))
{
var entityParam = listPParameter.FirstOrDefault(o => o.PARANAME == item.ColumnName);
if (entityParam != null)
{
strColumnName = entityParam.PARADESCRIBE;
}
}
if (!string.IsNullOrEmpty(strColumnName))
{
//item.ColumnName = strColumnName;
}
else
{
listDelColumn.Add(item);
}
}
}
//移除
foreach (var item in listDelColumn)
{
dtResult.Columns.Remove(item);
}
dataResult.Result.Result = dtResult;
//dataResult.Result.Result = GetJsonSource(dtResult);
dataResult.IsSuccess = true;
#endregion
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录-获取列表"
});
dataResult.IsSuccess = false;
dataResult.Msg = Resource.SystemException;
}
return dataResult;
}
#endregion
/// <summary>
///
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
public string GetJsonSource(System.Data.DataTable dt)
{
string pa = ",";
try
{
StringBuilder returnValue = new StringBuilder("{ \"total\":\" " + dt.Rows.Count.ToString() + "\", \"rows\":[");
if (dt.Rows.Count > 0)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
if (i != 0)
{
returnValue.AppendLine(pa);
}
string josnItem = "";
List<string> itemValue = new List<string>();
foreach (DataColumn item in dt.Columns)
{
object value = dt.Rows[i][item.ColumnName];
itemValue.Add(string.Format("\"{0}\":\"{1}\"", item.ColumnName, value != null && value != System.DBNull.Value ? value : string.Empty));
}
if (itemValue.Count > 0)
{
josnItem = "{" + string.Join(",", itemValue.ToArray()) + "}";
}
else
{
josnItem = string.Empty;
}
returnValue.AppendLine(josnItem);
}
}
returnValue.Append("]");
returnValue.Append("}");
return returnValue.ToString();
}
catch (Exception)
{
throw;
}
}
#region 获取加工记录列表Title（WEB根据工序查找设备加工参数）
/// <summary>
/// 获取列表
/// </summary>
/// <param name="condition">条件</param>
/// <param name="page">数据页</param>
/// <returns>数据页</returns>
public DataResult<DataTable> GetListWithParameterForWebTitle(MainOperation condition)
{
DataResult<DataTable> dataResult = new DataResult<DataTable>();
ProcessParameter conditionPParameter = new ProcessParameter();
try
{
#region 获得加工参数标准值
//if (!string.IsNullOrEmpty(condition.PROCESSTYPES))
//{
// conditionPParameter.PROCESSTYPES = condition.PROCESSTYPES;
//}
//else
//{
// conditionPParameter.PROCESSTYPE = condition.PROCESSTYPE;
//}
if (!string.IsNullOrEmpty(condition.WORKCELL_CODE))
{
conditionPParameter.WORKCELL_CODE = condition.WORKCELL_CODE;
}
//获取加工参数表中每个工序类别的信息
var listPParameter = new ProcessParameterDAL().GetList(conditionPParameter);
#endregion
if (listPParameter == null || listPParameter.Count == 0)
{
dataResult.Result = new MainOperationDAL().GetListWithOutParameterTitle(condition);
}
#region 获得加工记录及加工参数
else
{
condition.SelectCollumns = String.Join(",", listPParameter.Select(o => o.PARANAME));
condition.PARATABLENAME = listPParameter.FirstOrDefault().PARATABLENAME;
//获取加工操作与对应加工参数表联合
dataResult.Result = new MainOperationDAL().GetListWithParameterTitle(condition);
}
if (dataResult.Result == null)
{
dataResult.IsSuccess = false;
dataResult.Msg = QMAPP.FJC.Entity.Resource.NothingData;
return dataResult;
}
DataTable dtResult = dataResult.Result;
DictManageBLL dictColumnName = new DictManageBLL(DictKind.MAINOPERATIONSEARCHFORM);
IList<DataColumn> listDelColumn = new List<DataColumn>();
//设置标题
foreach (var item in dtResult.Columns.Cast<DataColumn>())
{
if (item.ColumnName == "OPERATEDDATE" || item.ColumnName == "CREATEDATE")
{
//移除原来datetime类型的OPERATEDDATE、CREATEDATE
listDelColumn.Add(item);
}
else
{
string nameCode = item.ColumnName;
var strColumnName = dictColumnName.GetDictValue(item.ColumnName);
if (string.IsNullOrEmpty(strColumnName))
{
var entityParam = listPParameter.FirstOrDefault(o => o.PARANAME == item.ColumnName);
if (entityParam != null)
{
strColumnName = entityParam.PARADESCRIBE;
}
}
if (!string.IsNullOrEmpty(strColumnName))
{
item.ColumnName = strColumnName;
}
else
{
listDelColumn.Add(item);
}
}
}
//移除
foreach (var item in listDelColumn)
{
dtResult.Columns.Remove(item);
}
dataResult.IsSuccess = true;
#endregion
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录-获取列表"
});
dataResult.IsSuccess = false;
dataResult.Msg = Resource.SystemException;
}
return dataResult;
}
/// <summary>
/// 前台显示字段
/// </summary>
/// <param name="condition">工序</param>
/// <returns></returns>
public List<ProcessParameter> GetParameterForWebTitle(MainOperation condition)
{
//定义返回信息
List<ProcessParameter> resultList = new List<ProcessParameter>();
//加载字典表中信息
DictManageBLL dictColumnName = new DictManageBLL(DictKind.MAINOPERATIONSEARCHFORM);
DictManageBLL dictColumnSet = new DictManageBLL(DictKind.MAINOPERATIONSEARCHFORMSET);
try
{
//获取参数配置中的加工记录的相关信息
Dictionary<string, string> dict = dictColumnName.GetModelDictionary(DictKind.MAINOPERATIONSEARCHFORM);
//将结果结果添加到resultList
foreach (string key in dict.Keys)
{
List<string> columnSetList = dictColumnSet.GetDictValue(key + "COLUMN").Split(':').ToList<string>();
resultList.Add(new ProcessParameter() { PARANAME = key, PARADESCRIBE = dictColumnName.GetDictValue(key), ALIGNVALUE = columnSetList[0], WIDTH = Convert.ToInt32(columnSetList[1]) });
}
//获取将
ProcessParameter conditionPParameter = new ProcessParameter();
//if (!string.IsNullOrEmpty(condition.PROCESSTYPES))
//{
// conditionPParameter.PROCESSTYPES = condition.PROCESSTYPES;
//}
//else
//{
// conditionPParameter.PROCESSTYPE = condition.PROCESSTYPE;
//}
if (!string.IsNullOrEmpty(condition.WORKCELL_CODE))
{
conditionPParameter.WORKCELL_CODE = condition.WORKCELL_CODE;
}
//获取加工参数表中每个工序类别的信息
if (!string.IsNullOrEmpty(condition.WORKCELL_CODE))
//if (!string.IsNullOrEmpty(condition.PROCESSTYPE))
{
var listPParameter = new ProcessParameterDAL().GetList(conditionPParameter);
listPParameter = listPParameter.OrderBy(o => o.SHOWINDEX).ToList<ProcessParameter>();
foreach (var para in listPParameter)
{
resultList.Add(
new ProcessParameter()
{
PARANAME = para.PARANAME,
PARADESCRIBE = para.PARADESCRIBE,
WIDTH = para.WIDTH,
ALIGNVALUE = para.ALIGNVALUE,
SHOWINDEX = para.SHOWINDEX
});
}
}
return resultList;
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加载动态列失败！"
});
return resultList;
}
}
#endregion
#region 统计
/// <summary>
/// 产量趋势统计
/// </summary>
/// <param name="condition"></param>
/// <returns></returns>
public DataResult<List<MainOperation>> GetListGroupBy(MainOperation condition)
{
DataResult<List<MainOperation>> result = new DataResult<List<MainOperation>>();
try
{
result.Result = new MainOperationDAL().GetListGroupBy(condition);
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "产量趋势统计-获取列表(产量趋势统计）！"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw ex;
}
result.IsSuccess = true;
return result;
}
/// <summary>
/// 合格率
/// </summary>
/// <param name="condition"></param>
/// <returns></returns>
public DataResult<List<MainOperation>> GetListGroupByStauts(MainOperation condition)
{
DataResult<List<MainOperation>> result = new DataResult<List<MainOperation>>();
try
{
result.Result = new MainOperationDAL().GetListGroupByStauts(condition);
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "合格率-获取列表(合格率统计）！"
});
result.IsSuccess = false;
result.Msg = Resource.SystemException;
throw ex;
}
result.IsSuccess = true;
return result;
}
#endregion
#region 产品返修
public DataResult MendProudct(MainOperation condition)
{
DataResult result = new DataResult();
MainOperationDAL modal = new MainOperationDAL();
MainOperation mo = modal.Get(condition);
ProductDAL prodal = new ProductDAL();
Product entity = prodal.Get(new Product() { PID = mo.PDID });
//判断状态是否正确
if (entity.STATUS != EnumGeter.STATUS.SCRAP.GetHashCode().ToString())
{
result.IsSuccess = false;
result.Msg = "该表皮为正常件!";
return result;
}
entity.STATUS = EnumGeter.STATUS.QUALIFIED.GetHashCode().ToString();
mo.PRODUCTCODESTR = "是";
using (IDataSession session = AppDataFactory.CreateMainSession())
{
session.OpenTs();
prodal.BaseSession = session;
modal.BaseSession = session;
prodal.Update(entity);
modal.Update(mo);
session.CommitTs();
}
result.IsSuccess = true;
result.Msg = "返修完成!";
return result;
}
#endregion
public DataResult<DataTable> GetExportData(MainOperation condition)
{
DataResult<DataTable> dataResult = new DataResult<DataTable>();
dataResult.IsSuccess = true;
try
{
#region 获得加工参数标准值
var conditionPParameter = new ProcessParameter
{
WORKCELL_CODE = condition.WORKCELL_CODE,
};
var listPParameter = new ProcessParameterDAL().GetList(conditionPParameter);
if (listPParameter == null || listPParameter.Count == 0 || string.IsNullOrEmpty( condition.WORKCELL_CODE))
{
dataResult.Result = new MainOperationDAL().GetListWithOutParameterDt(condition);
}
#endregion
#region 获得加工记录及加工参数
else
{
condition.SelectCollumns = String.Join(",", listPParameter.Select(o => o.PARANAME));
condition.PARATABLENAME = listPParameter.FirstOrDefault().PARATABLENAME;
dataResult.Result = new MainOperationDAL().GetListWithParameterDt(condition);
}
if (dataResult.Result == null)
{
dataResult.IsSuccess = false;
dataResult.Msg = QMAPP.FJC.Entity.Resource.NothingData;
dataResult.Result = new DataTable();
return dataResult;
}
DataTable dtResult = dataResult.Result as DataTable;
//DictManageBLL dictColumnName = new DictManageBLL(DictKind.MAINOPERATIONSEARCHFORM);
//DictManageBLL dictProcessType = new DictManageBLL(DictKind.PROCESSTYPE);
//DictManageBLL dictProductType = new DictManageBLL(DictKind.PRODUCTTYPE);
//DictManageBLL dictLJStatus = new DictManageBLL(DictKind.LJSTATUS);
//DictManageBLL dictOperateState = new DictManageBLL(DictKind.OPERATESTATE);
//DictManageBLL dictPSStatus = new DictManageBLL(DictKind.PRODUCTSTATUS);
//IList<DataColumn> listDelColumn = new List<DataColumn>();
//转换枚举描述
//foreach (DataRow item in dtResult.Rows)
//{
// item["PROCESSTYPE"] = dictProcessType.GetDictValue(item["PROCESSTYPE"].ToString());
// item["PRODUCTTYPE"] = dictProductType.GetDictValue(item["PRODUCTTYPE"].ToString());
//item["STATUS"] = dictPSStatus.GetDictValue(item["STATUS"].ToString());
//item["OPERATESTATE"] = dictOperateState.GetDictValue(item["OPERATESTATE"].ToString());
// //因为日期类型转成json绑定到页面显示格式错误，所以在datatable加上两个字符串型的操作时间和加工完成时间用于显示在页面上
// if (!string.IsNullOrEmpty(item["OPERATEDDATESTR"].ToString()))
// {
// item["OPERATEDDATE"] = (Convert.ToDateTime(item["OPERATEDDATESTR"].ToString())).ToString("yyyy-MM-dd HH:mm:ss").Replace('/', '-');
// }
// if (!string.IsNullOrEmpty(item["CREATEDATESTR"].ToString()))
// {
// item["CREATEDATE"] = ((DateTime)item["CREATEDATESTR"]).ToString("yyyy-MM-dd HH:mm:ss");
// }
//}
////设置标题
//foreach (var item in dtResult.Columns.Cast<DataColumn>())
//{
// if (item.ColumnName == "OPERATEDDATE" || item.ColumnName == "CREATEDATE")
// {
// //移除原来datetime类型的OPERATEDDATE、CREATEDATE
// //listDelColumn.Add(item);
// }
// else
// {
// var strColumnName = dictColumnName.GetDictValue(item.ColumnName);
// if (string.IsNullOrEmpty(strColumnName))
// {
// var entityParam = listPParameter.FirstOrDefault(o => o.PARANAME == item.ColumnName);
// if (entityParam != null)
// {
// strColumnName = entityParam.PARADESCRIBE;
// }
// }
// if (!string.IsNullOrEmpty(strColumnName))
// {
// //item.ColumnName = strColumnName;
// }
// else
// {
// listDelColumn.Add(item);
// }
// }
//}
////移除
//foreach (var item in listDelColumn)
//{
// dtResult.Columns.Remove(item);
//}
dataResult.Result = dtResult;
//dataResult.Result.Result = GetJsonSource(dtResult);
dataResult.IsSuccess = true;
#endregion
}
catch (Exception ex)
{
LogManager.LogHelper.Error(new LogInfo()
{
ErrorInfo = ex,
Tag = ex.StackTrace,
Info = "加工记录-获取列表"
});
dataResult.IsSuccess = false;
dataResult.Msg = Resource.SystemException;
}
return dataResult;
//return new DataResult<DataTable>();
}
#region 加工操作（总成打印条码）成都 临时打印
/// <summary>
/// 加工操作（总成打印条码）
/// 20181104gzf
/// </summary>
/// <param name="barcode"></param>
/// <returns></returns>
public DataResult<Main> GetFinalPrintCode(string material)
{
DataResult<Main> result = new DataResult<Main>();
Main main = new Main();
PrintCode condition = new MainDAL().GetFinalMaxMainCodePrint(material);
//string mainCode = (Convert.ToInt32(condition.MAINCODE) + 1) + "";
main.MAINCODE = condition.MAINCODE;
//main.MAINCODE = "052 8KY" + mainCode.PadLeft(7, '0');
//main.MAINCODE = new FileCopyRecordDAL().GetBarcode(main.MAINCODE);
main.publicCode = condition.COLOR_CODE;
//PrintCode pc = new PrintCode();
//pc.PID = condition.PID;
//pc.MAINCODE = main.MAINCODE;
//pc.ISCOMPLETE = 0;
//pc.PRODUCTCODE = condition.PRODUCTCODE;
//pc.CREATETIME = System.DateTime.Now;
//PrintCodeDAL dal = new PrintCodeDAL();
//dal.Insert(pc);
result.Result = main;
return result;
}
#endregion
}
}