public unsafe void Prepare(IReadService readService,
out OperationStartupData data)
{
// We must make sure we can terminate if too many streams.
Block block = readService.Read(BlockType.NodeHeaderBlock, versionNode);
fixed(byte *p = block.Data)
{
NodeVersionHeader *header = (NodeVersionHeader *)p;
if (header->StreamCount + 1 > BlockHelper.MaxTypedStreamsInNode(readService.BlockSize))
{
throw new InvalidOperationException("Number of typed stream in node is more that "
+ BlockHelper.MaxTypedStreamsInNode(readService.BlockSize) + " which is the limit"
+ " at block size " + readService.BlockSize.ToString());
}
}
// We need one allocation if typed stream is single object, otherwise two.
if ((options & StreamOptions.SingleObject) != 0)
{
data = new OperationStartupData(versionNode, 1);
}
else
{
data = new OperationStartupData(versionNode, 2);
}
}
/// <summary>
/// Internal prepare
/// </summary>
/// <param name="readService"></param>
/// <param name="data"></param>
/// <param name="subOps"></param>
unsafe void PrepareInternal(IReadService readService, List <DeleteChild> subOps)
{
// We inspect children.
ulong childrenTS;
Block block = readService.Read(BlockType.NodeHeaderBlock, commonAddress);
fixed(byte *p = block.Data)
{
NodeCommonHeader *header = (NodeCommonHeader *)p;
childrenTS = header->ChildrenBTree;
}
// We check children count.
BPlusTree tree = new BPlusTree(childrenTS);
List <ObjectInfo> objects = tree.ListAll(readService);
// We update stage index/count.
for (int j = 0; j < objects.Count; j++)
{
BlockStream childTagStream = BlockStream.FromBase(objects[j].Address, readService);
ChildTag childTag = Common.DeserializeFromArray(childTagStream.Read(objects[j].Size)) as ChildTag;
foreach (KeyValuePair <string, ulong> child in childTag.Children)
{
DeleteChild subOp = new DeleteChild(child.Value, childrenTS, child.Key);
subOps.Add(subOp);
}
}
subOps.Add(this);
}
/// <summary>
/// Gets the index of the typed stream.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="block">The block.</param>
/// <param name="service">The service.</param>
/// <param name="typedStreamBlock">The typed stream block.</param>
/// <returns></returns>
public static unsafe uint GetTypedStreamIndex(string name, Block block,
IReadService service, out Block typedStreamBlock, out ulong address)
{
int nameHash = name.GetHashCode();
fixed(byte *p = block.Data)
{
NodeVersionHeader *header = (NodeVersionHeader *)p;
TSData * data = (TSData *)&header->TypedStreamData[0];
for (uint i = 0; i < header->StreamCount; i++)
{
if (nameHash == data[i].Hash)
{
// We check it if it is the correct one.
typedStreamBlock = service.Read(BlockType.TypedStreamHeader, data[i].Address);
if (IsTypedStreamWithType(typedStreamBlock, name))
{
address = data[i].Address;
return(i);
}
}
}
}
// Noone found.
typedStreamBlock = null;
address = 0;
return(uint.MaxValue);
}
/// <summary>
/// Reads this instance.
/// </summary>
/// <returns></returns>
public unsafe byte[] Read(ulong size)
{
// We prepare variables.
byte[] data = new byte[size];
ulong i = 0;
// Begin loop.
for (ulong addr = blocks[0]; addr != 0;)
{
uint seq;
ulong next;
// Read header first.
Block headerBlock = service.Read(BlockType.BigObjectData, addr);
fixed(byte *p = headerBlock.Data)
{
BlockLinkHeader *header = (BlockLinkHeader *)p;
next = header->NextBlock;
seq = header->Sequential;
}
// First block special.
for (uint j = (uint)sizeof(BlockLinkHeader); j < headerBlock.Data.Length && i < size; i++, j++)
{
data[i] = headerBlock.Data[j];
}
// All sequential blocks.
for (uint k = 1; k < seq; k++)
{
Block dataBlock = service.Read(BlockType.BigObjectData, addr + k);
for (uint z = 0; z < dataBlock.Data.Length && i < size; i++, z++)
{
data[i] = dataBlock.Data[z];
}
}
// Next iteration.
addr = next;
}
return(data);
}
public void Prepare(IReadService readService, out OperationStartupData data)
{
// We must extract new default.
if (newDefaultIndex == uint.MaxValue)
{
Block block = readService.Read(BlockType.NodeHeaderBlock, rootAddress);
Block unused;
newDefaultIndex = NodeVersionHelper.GetTypedStreamIndex(newDefault, block, readService, out unused);
}
data = new OperationStartupData(0, 0);
}
public void Prepare(IReadService readService, out OperationStartupData data)
{
// We must resolve which TS to delete.
if (tsToDeleteIndex == uint.MaxValue)
{
Block block = readService.Read(BlockType.NodeHeaderBlock, nodeVersionAddress);
Block unused;
tsToDeleteIndex = NodeVersionHelper.GetTypedStreamIndex(tsToDelete, block, readService, out unused);
}
data = new OperationStartupData(0, 0);
}
public unsafe void Prepare(IReadService readService, out OperationStartupData data)
{
Block block = readService.Read(BlockType.NodeHeaderBlock, commonAddress);
fixed(byte *p = block.Data)
{
NodeCommonHeader *header = (NodeCommonHeader *)p;
version = header->CurrentVersionNumber;
versionTree = new BPlusTree(header->VersionsBTree);
}
// We estimate how must we need.
uint allocations = 15; //< Approximate estimate.
data = new OperationStartupData(commonAddress, allocations, true);
}
/// <summary>
/// 更新库存交易单单身
/// </summary>
/// <param name="employeeNo">扫描人员</param>
/// <param name="scanType">扫描类型1.有箱条码 2.无箱条码</param>
/// <param name="reportDatetime">上传时间</param>
/// <param name="pickingDepartmentNo">领料部门</param>
/// <param name="recommendedOperations">建议执行作业</param>
/// <param name="recommendedFunction">A.新增 S.过帐</param>
/// <param name="scanDocNo">扫描单号</param>
/// <param name="collScan">参数集合</param>
/// <returns>新生成的单号DocNo</returns>
public DependencyObjectCollection DoUpdateTransactionDoc(string employeeNo, string scanType, DateTime reportDatetime,
string pickingDepartmentNo, string recommendedOperations, string recommendedFunction,
string scanDocNo, DependencyObjectCollection collScan)
{
#region 参数检查
if (Maths.IsEmpty(recommendedOperations))
{
throw new BusinessRuleException(InfoEncodeSrv.GetMessage("A111201", "recommended_operations"));//‘入参【recommended_operations】未传值’
}
if (Maths.IsEmpty(recommendedFunction))
{
throw new BusinessRuleException(InfoEncodeSrv.GetMessage("A111201", "recommended_function"));//‘入参【recommended_function】未传值’
}
#endregion
#region 准备临时表的列映射与数据
_collDocNos = CreateReturnCollection();
List <string> lstDocNos = new List <string>();
_lstQueryProperties = new List <QueryProperty>();
//DataTable dtTempScan = null;//临时表Scan的DataTable结构
DataTable dtTempScanDetail = null; //临时表ScanDetail的DataTable结构
List <BulkCopyColumnMapping> lstColumnMappingsScanDetail = null; //临时表ScanDetail的映射列
CreateTempTableMapping(ref dtTempScanDetail, ref lstColumnMappingsScanDetail); //创建临时表#Table_scan的列映射
InsertTempTableData(dtTempScanDetail, collScan, lstDocNos); //插入DataTable数据
#endregion
using (var transService = GetService <ITransactionService>()) {
using (var myConnectionSr = GetService <IConnectionService>()) {
InitParameters();//初始化全局变量
#region 7.1更新出入库单实体
//创建临时表Scan与ScanDetail
CreateTempTableScanDetail();
_querySrv.BulkCopy(dtTempScanDetail, _TEMP_SCAN_DETAIL.Name, lstColumnMappingsScanDetail.ToArray()); //批量插入数据到临时表ScanDetail
int decimalPlace = 8; //金额小数位数
int carryMode = 1; //金额取位模式
object companyId = Maths.GuidDefaultValue();
DependencyObjectCollection collPalnt = QueryPlant();
if (collPalnt.Count > 0)
{
companyId = collPalnt[0]["COMPANY_ID"];
//调用系统参数服务 获取 记账本位币
object currencyId = _sysParameterSrv.GetValue("FUNCTION_CURRENCY_ID", companyId);
//Call 货币单价金额取位服务
ICurrencyPrecisionService currencyPrecisionSrv = GetServiceForThisTypeKey <ICurrencyPrecisionService>();
object[] arrPrecision = currencyPrecisionSrv.GetPrecision(companyId, currencyId);
decimalPlace = arrPrecision[0].ToInt32();
carryMode = arrPrecision[1].ToInt32();
}
UpdateTransactionDocD(decimalPlace, carryMode); //更新库存交易单单身
UpdateTransactionDoc(); //更新库存交易单单头
DependencyObjectCollection collParaFil = QueryParaFil();
if (collParaFil.Count > 0 && collParaFil[0]["BC_LINE_MANAGEMENT"].ToBoolean())
{
DeleteBcLine(); //删除条码交易明细 BC_LINE
InsertBcLine(); //插入条码交易明细 BC_LINE
}
#endregion
//7.2审核
//保存单据
DependencyObjectCollection collTransactionDoc = QueryDoc(lstDocNos);
IReadService readSrv = GetService <IReadService>("TRANSACTION_DOC");
object[] entities = readSrv.Read(collTransactionDoc.Select(c => c["TRANSACTION_DOC_ID"]).ToArray());
if (entities != null && entities.Length > 0)
{
ISaveService saveSrv = GetService <ISaveService>("TRANSACTION_DOC");
saveSrv.Save(entities);
}
//保存时没有自动审核的，需要重新审核
entities = readSrv.Read(collTransactionDoc.Where(c => c["AUTO_APPROVE"].ToBoolean() == false).Select(c => c["TRANSACTION_DOC_ID"]).ToArray());
IConfirmService confirmService = GetService <IConfirmService>("TRANSACTION_DOC");
ILogOnService logOnSrv = GetService <ILogOnService>();
foreach (DependencyObject obj in entities)
{
ConfirmContext context = new ConfirmContext(obj.Oid, logOnSrv.CurrentUserId, reportDatetime.ToDate());
confirmService.Execute(context);
}
}
transService.Complete(); //事务提交
}
return(_collDocNos);
}
public void Execute(string pathToFolder, string sourceFileName, string resultFileName)
{
_lines = _readService.Read(pathToFolder + sourceFileName);
_words = _splitService.Split(_lines);
_writeService.Write(_words, pathToFolder, resultFileName);
}
/// <summary>
/// 更新领退料单
/// </summary>
/// <param name="employeeNo">扫描人员</param>
/// <param name="scanType">扫描类型 1.有箱条码 2.无箱条码</param>
/// <param name="reportDatetime">上传时间</param>
/// <param name="pickingDepartmentNo">领料部门</param>
/// <param name="recommendedOperations">建议执行作业</param>
/// <param name="recommendedFunction">A.新增 S.过帐</param>
/// <param name="scanDocNo">扫描单号</param>
/// <param name="collection">接口传入的领料单单身数据集合</param>
public DependencyObjectCollection UpdateIssueReceipt(string employeeNo, string scanType, DateTime reportDatetime, string pickingDepartmentNo
, string recommendedOperations, string recommendedFunction, string scanDocNo, DependencyObjectCollection collection)
{
DependencyObjectCollection rtnColl = CreateReturnCollection();
#region 参数检查
if (Maths.IsEmpty(recommendedOperations))
{
throw new BusinessRuleException(EncodeSrv.GetMessage("A111201", new object[] { "recommended_operations" }));
}
if (Maths.IsEmpty(recommendedFunction))
{
throw new BusinessRuleException(EncodeSrv.GetMessage("A111201", new object[] { "recommended_function" }));
}
#endregion
//创建临时表需要的DataTable和Mapping信息
DataTable issueReceiptD = null;
List <BulkCopyColumnMapping> issueReceiptDMap = null;
this.CreateRelateTable(ref issueReceiptD,
ref issueReceiptDMap);
List <string> docNos = new List <string>(); //记录单身的单号，保存时需要，可以避免后续再查
//组织数据BulkCopy需要的DataTable数据
InsertDataTable(issueReceiptD, collection, docNos);
#region 更新逻辑
using (ITransactionService trans = this.GetService <ITransactionService>()) {
IQueryService querySrv = this.GetService <IQueryService>();
//新增临时表
IDataEntityType issueReceiptDTmp = CreateIssueReceiptDTmpTable(querySrv);
//批量新增到临时表
querySrv.BulkCopy(issueReceiptD, issueReceiptDTmp.Name, issueReceiptDMap.ToArray());
if (issueReceiptD.Rows.Count <= 00 || issueReceiptD.Rows.Count <= 0) //没有数据值不再往下执行
{
return(rtnColl);
}
DataRow[] drs = issueReceiptD.Select("BARCODE_NO<>\'\'");
//利用临时表批量更新相关数据
//20170905 add by wangyq for P001-170717001 =================begin===================
if (recommendedOperations == "7-5")
{
UpdateBcCheckStatus(querySrv, issueReceiptDTmp);
}
else
{
//20170905 add by wangyq for P001-170717001 =================end===================
UpdateIssueReceiptD(querySrv, issueReceiptDTmp);
}//20170905 add by wangyq for P001-170717001
if (drs.Length > 0) //条码不为""的记录大于0时，才执行如下更新，避免多余的性能损失
{
bool bcLintFlag = UtilsClass.IsBCLineManagement(querySrv);
if (bcLintFlag)
{
DeleteBCLine(querySrv, issueReceiptDTmp); //先删除
InsertBCLine(querySrv, issueReceiptDTmp); //再重新生成
}
}
//保存
DependencyObjectCollection ids = GetIssueReceipt(docNos);
IReadService readSrv = this.GetService <IReadService>("ISSUE_RECEIPT");
object[] entities = readSrv.Read(ids.Select(c => c["ISSUE_RECEIPT_ID"]).ToArray());
if (entities != null && entities.Length > 0)
{
ISaveService saveSrv = this.GetService <ISaveService>("ISSUE_RECEIPT");
saveSrv.Save(entities);
}
//保存时没有自动审核的，需要重新审核
entities = readSrv.Read(ids.Where(c => !c["AUTO_APPROVE"].ToBoolean()).Select(c => c["ISSUE_RECEIPT_ID"]).ToArray());
IConfirmService confirmService = this.GetService <IConfirmService>("ISSUE_RECEIPT");
ILogOnService logOnSrv = this.GetService <ILogOnService>();
foreach (DependencyObject obj in entities)
{
ConfirmContext context = new ConfirmContext(obj.Oid, logOnSrv.CurrentUserId, reportDatetime.ToDate());
confirmService.Execute(context);
}
trans.Complete();
}
#endregion
#region 组织返回结果
foreach (string item in docNos)
{
DependencyObject obj = rtnColl.AddNew();
obj["doc_no"] = item;
}
#endregion
return(rtnColl);
}
public DependencyObjectCollection UpdateSalesIssue(string employeeNo, string scanType, DateTime reportDatetime, string pickingDepartmentNo
, string recommendedOperations, string recommendedFunction, string scanDocNo, DependencyObjectCollection collection)
{
DependencyObjectCollection rtnColl = CreateReturnCollection();
#region 参数检查
IInfoEncodeContainer encodeSrv = this.GetService <IInfoEncodeContainer>();
if (Maths.IsEmpty(recommendedOperations))
{
throw new BusinessRuleException(encodeSrv.GetMessage("A111201", new object[] { "recommended_operations" }));
}
if (Maths.IsEmpty(recommendedFunction))
{
throw new BusinessRuleException(encodeSrv.GetMessage("A111201", new object[] { "recommended_function" }));
}
#endregion
//创建临时表需要的DataTable和Mapping信息
DataTable dtEntityD = new DataTable();
List <BulkCopyColumnMapping> entityDMap = new List <BulkCopyColumnMapping>();
CreateRelateTable(dtEntityD, entityDMap);
List <string> docNos = new List <string>(); //记录单身的单号，保存时需要，可以避免后续再查
//组织数据BulkCopy需要的DataTable数据
InsertDataTable(dtEntityD, collection, docNos);
if (dtEntityD.Rows.Count <= 0)
{
return(rtnColl);
}
#region 更新逻辑
using (ITransactionService trans = this.GetService <ITransactionService>()) {
using (IConnectionService connService = this.GetService <IConnectionService>()) {
IQueryService querySrv = this.GetService <IQueryService>();
//新增临时表
IDataEntityType dtTemp = CreateDTmpTable(querySrv);
//批量新增到临时表
querySrv.BulkCopy(dtEntityD, dtTemp.Name, entityDMap.ToArray());
//利用临时表批量更新相关数据
UpdateSalesIssueD(querySrv, dtTemp);
DataRow[] drs = dtEntityD.Select("BARCODE_NO<>\'\'");
if (drs.Length > 0) //条码不为""的记录大于0时，才执行如下更新，避免多余的性能损失
{
ICreateService createService = this.GetService <ICreateService>("PARA_FIL");
if (createService != null) //PARA_FIL实体存在,服务端可以这么判断
{
bool bcLintFlag = UtilsClass.IsBCLineManagement(querySrv);
if (bcLintFlag)
{
DeleteBCLine(querySrv, dtTemp); //先删除
InsertBCLine(querySrv, dtTemp); //再重新生成
}
}
}
}
//保存
DependencyObjectCollection ids = GetSalesIssue(docNos);
IReadService readSrv = this.GetService <IReadService>("SALES_ISSUE");
object[] entities = readSrv.Read(ids.Select(c => c["SALES_ISSUE_ID"]).ToArray());
if (entities != null && entities.Length > 0)
{
ISaveService saveSrv = this.GetService <ISaveService>("SALES_ISSUE");
saveSrv.Save(entities);
}
//保存时没有自动审核的，需要重新审核
entities = readSrv.Read(ids.Where(c => !c["AUTO_APPROVE"].ToBoolean()).Select(c => c["SALES_ISSUE_ID"]).ToArray());
IConfirmService confirmService = this.GetService <IConfirmService>("SALES_ISSUE");
ILogOnService logOnSrv = this.GetService <ILogOnService>();
foreach (DependencyObject obj in entities)
{
ConfirmContext context = new ConfirmContext(obj.Oid, logOnSrv.CurrentUserId, reportDatetime.ToDate());
confirmService.Execute(context);
}
trans.Complete();
}
#endregion
#region 组织返回结果
foreach (string item in docNos)
{
DependencyObject obj = rtnColl.AddNew();
obj["doc_no"] = item;
}
#endregion
return(rtnColl);
}
private string InsertPoArrivalInspection(string receiptNo, DependencyObjectCollection receiptList, List <int> paiSequenceNumber, Dictionary <int, object> docIdDt)
{
//获取生成到货检验单基础数据
DataTable poArrivalInspection = GetInsertPoArrivalInspection(receiptNo, paiSequenceNumber);
//把查询数据以序号为Key，存入字典中。方便后期直接根据序号拿数据
Dictionary <int, DataRow> poArrivalDictionary = new Dictionary <int, DataRow>();
foreach (DataRow item in poArrivalInspection.Rows)
{
if (!poArrivalDictionary.ContainsKey(item["SequenceNumber"].ToInt32()))
{
poArrivalDictionary.Add(item["SequenceNumber"].ToInt32(), item);
}
}
//创建生成采购到货检验单缓存临时表
DataTable poArrivalInspectionInfo = poArrivalInspection.Clone(); //复制表结构
poArrivalInspectionInfo.TableName = "PO_ARRIVAL_INSPECTION";
//创建生成采购到货检验单计数单身缓存临时表
DataTable poArrivalInspectionDInfo = CreatePoArrivalInspectionDInfo();
//创建生成采购到货检验单计量单身缓存临时表
DataTable poArrivalInspectionD1Info = CreatePoArrivalInspectionD1Info();
//创建计数品质检验不良原因缓存临时表
DataTable defectiveReasonsAiId = CreateDefectiveReasonsAiIdInfo();
IPrimaryKeyService keyService = GetService <IPrimaryKeyService>(TypeKey); //生成主键服务
IDocumentNumberGenerateService docNumService = GetService <IDocumentNumberGenerateService>("PO_ARRIVAL_INSPECTION"); //自动编号服务
ICreateInspectionService createInspectionService = GetService <ICreateInspectionService>("PO_ARRIVAL_INSPECTION"); //顺序检查服务
IGenerateOrDeletePurchaseArivalQCResultService generatePurchaseArivalQc = GetService <IGenerateOrDeletePurchaseArivalQCResultService>("PO_QC_RESULT"); //生成/删除采购质检业务信息服务
IItemQtyConversionService itemQtyConversionService = GetService <IItemQtyConversionService>(TypeKey);
ILogOnService loginService = GetService <ILogOnService>();
List <DocmentInfo> listDocuments = new List <DocmentInfo>();
Dictionary <string, string> salesReturnDocNo = new Dictionary <string, string>(); //记录产生的单号用于批量生成的时候防止重复单号
const decimal defaultDecimal = 0m;
string resutQcNo = string.Empty; //返回结果单号
//循环入参数据，分别给到货检验单、货检验单计数单身、货检验单计量单身身临时表插入数据
foreach (DependencyObject receiptListItem in receiptList)
{
object poArrivalInspectionId = keyService.CreateId(); //主键
if (poArrivalDictionary.ContainsKey(receiptListItem["seq"].ToInt32()))
{
#region 到货检验单临时表插入数据
//获取生单基础数据
DataRow dr = poArrivalDictionary[receiptListItem["seq"].ToInt32()];
//获取单据性质
object docId = Maths.GuidDefaultValue();
if (docIdDt.ContainsKey(dr["SequenceNumber"].ToInt32()))
{
docId = docIdDt[dr["SequenceNumber"].ToInt32()];
}
if (dr["PURCHASE_TYPE"].ToStringExtension() == "1" || dr["PURCHASE_TYPE"].ToStringExtension() == "5")
{
dr["CATEGORY"] = "Q1";
}
else if (dr["PURCHASE_TYPE"].ToStringExtension() == "2" || dr["PURCHASE_TYPE"].ToStringExtension() == "3")
{
dr["CATEGORY"] = "Q2";
}
//计算列赋值
dr["PO_ARRIVAL_INSPECTION_ID"] = poArrivalInspectionId; //主键
dr["DOC_ID"] = docId; //单据类型
dr["DOC_DATE"] = DateTime.Now.Date; //单据日期
dr["DOC_NO"] = docNumService.NextNumber(dr["DOC_ID"], dr["DOC_DATE"].ToDate()); //单号
if (!salesReturnDocNo.ContainsKey(dr["DOC_NO"].ToString()))
{
salesReturnDocNo.Add(dr["DOC_NO"].ToString(), dr["DOC_NO"].ToString());
}
else
{
string oldDocNo = salesReturnDocNo[dr["DOC_NO"].ToString()]; //取得字典中存储的最大单号
string docNo = NewDocNo(oldDocNo); //产生新单号
salesReturnDocNo[dr["DOC_NO"].ToString()] = docNo; //更新字段中单号
dr["DOC_NO"] = docNo; //当前笔单号重新赋值
}
object[] createInspection = createInspectionService.GetInspectionId(dr["ITEM_ID"],
dr["Owner_Org_ROid"],
dr["ITEM_FEATURE_ID"], dr["OPERATION_ID"]);
if (!Maths.IsEmpty(createInspection))
{
dr["INSPECTION_PLAN_ID"] = createInspection[0]; //质检方案ID
dr["INSPECTION_TIMES"] = createInspection[1]; //最大抽样次数
}
dr["INSPECTION_QTY"] = receiptListItem["receipt_qty"]; //送检数量
dr["INSPECTION_DUE_DATE"] = Maths.AddTimeValue(dr["ARRIVAL_DATE"].ToDate(), 1,
dr["INSPECT_DAYS"].ToInt32()); //检验期限
dr["INVENTORY_QTY"] = itemQtyConversionService.GetConvertedQty(dr["ITEM_ID"],
dr["INSPECTION_UNIT_ID"], dr["INSPECTION_QTY"].ToDecimal(), dr["STOCK_UNIT_ID"]); //库存单位数量
dr["SECOND_QTY"] = itemQtyConversionService.GetConvertedQty(dr["ITEM_ID"], dr["INSPECTION_UNIT_ID"],
dr["INSPECTION_QTY"].ToDecimal(), dr["SECOND_UNIT_ID"]); //库存单位数量
dr["ACCEPTABLE_QTY"] = receiptListItem["ok_qty"]; //送检数量
dr["UNQUALIFIED_QTY"] = receiptListItem["unqualified_qty"]; //不合格数量
dr["DESTROYED_QTY"] = receiptListItem["checkdestroy_qty"]; //破坏数量
//判定结果
if (receiptListItem["result_type"].ToStringExtension() == "Y")
{
dr["DECISION"] = "1";
}
else
{
dr["DECISION"] = "2";
}
//后道工序
if (!Maths.IsEmpty(dr["MO_ROUTING_D_ID"]))
{
DependencyObject moRouting = GetMoRouting(dr["MO_ROUTING_D_ID"]);
dr["TO_MO_ROUTING_D_ID"] = moRouting["MO_ROUTING_D_ID"];
dr["TO_OPERATION_ID"] = moRouting["OPERATION_ID"];
}
dr["Owner_Emp"] = GetEmployeeInfo(loginService.CurrentUserId);
dr["Owner_Dept"] = GetAdminUnitInfo(dr["Owner_Emp"]);
//系统管理字段
AddManagementData(dr, loginService);
poArrivalInspectionInfo.Rows.Add(dr.ItemArray);
#endregion
#region 到货检验单计数单身临时表插入数据
DependencyObjectCollection qcList = receiptListItem["qc_list"] as DependencyObjectCollection;
if (qcList == null)
{
continue; //不存在qc_list集合数据跳出循环
}
foreach (var qcListItem in qcList)
{
if (qcListItem["qc_seq"].ToInt32() == 0)
{
continue; //序号为0的数据是默认数据只是为了json结构完整插入的，虚无插入E10系统
}
DataRow qcListDr = poArrivalInspectionDInfo.NewRow();
qcListDr["PO_ARRIVAL_INSPECTION_D_ID"] = keyService.CreateId(); //主键
qcListDr["ParentId"] = poArrivalInspectionId; //父主键
qcListDr["SEQUENCE"] = qcListItem["qc_seq"];
qcListDr["DEFECT_CLASS"] = qcListItem["defect_level"];
qcListDr["INSPECTION_QTY"] = qcListItem["test_qty"];
qcListDr["INSPECTION_QQ"] = qcListItem["return_qty"];
qcListDr["INSPECTION_ITEM_ID"] = GetInspectionItem(qcListItem["test_no"], dr["Owner_Org_ROid"]);
qcListDr["INSPECTION_AC"] = qcListItem["acceptable_qty"];
qcListDr["INSPECTION_RE"] = qcListItem["rejected_qty"];
if (receiptListItem["result_type"].ToStringExtension() == "Y")
{
qcListDr["DECISION"] = true;
}
else
{
qcListDr["DECISION"] = false;
}
qcListDr["IMPACT_RESULT"] = true;
qcListDr["REMARK"] = string.Empty;
qcListDr["DEFECTIVE_REASONS_ID"] = Maths.GuidDefaultValue();
//系统管理字段
AddManagementData(qcListDr, loginService);
DependencyObjectCollection reasonlist = qcListItem["reason_list"] as DependencyObjectCollection;
if (reasonlist == null)
{
continue;
}
//defect_qty为0且reason_no为空的数据是默认数据只是为了json结构完整插入的，不需要插入E10系统
if (reasonlist.Count == 1 && (!Maths.IsEmpty(reasonlist[0]["reason_no"]) || reasonlist[0]["defect_qty"].ToInt32() != 0))
{
qcListDr["DEFECTIVE_REASONS_ID"] = GetDefectiveReasonsId(reasonlist[0]["reason_no"].ToStringExtension());
}
else
{
//defect_qty为0且reason_no为空的数据是默认数据只是为了json结构完整插入的，不需要插入E10系统
if (!Maths.IsEmpty(reasonlist[0]["reason_no"]) || reasonlist[0]["defect_qty"].ToInt32() != 0)
{
foreach (DependencyObject reasonlistItem in reasonlist)
{
DataRow reasonlistDr = defectiveReasonsAiId.NewRow();
reasonlistDr["DEFECTIVE_REASONS_AI_ID"] = keyService.CreateId(); //主键
reasonlistDr["ParentId"] = qcListDr["PO_ARRIVAL_INSPECTION_D_ID"]; //父主键
reasonlistDr["DEFECTS"] = reasonlistItem["defect_qty"];
reasonlistDr["REMARK"] = string.Empty;
reasonlistDr["DEFECTIVE_REASONS_ID"] =
GetDefectiveReasonsId(reasonlistItem["reason_no"].ToStringExtension());
//系统管理字段
AddManagementData(reasonlistDr, loginService);
defectiveReasonsAiId.Rows.Add(reasonlistDr.ItemArray);
//子单身第一笔时把不良原因主键赋值给单身不良原因
if (reasonlist.IndexOf(reasonlistItem) == 0)
{
qcListDr["DEFECTIVE_REASONS_ID"] = reasonlistDr["DEFECTIVE_REASONS_ID"];
}
}
}
}
//把对应数据添加至预生单缓存中
poArrivalInspectionDInfo.Rows.Add(qcListDr.ItemArray);
}
#endregion
#region 到货检验单计量单身临时表插入数据
DependencyObjectCollection collection =
createInspectionService.CreateInspection(dr["INSPECTION_PLAN_ID"], dr["OPERATION_ID"]);
foreach (DependencyObject item in collection)
{
if (item["INSPECTION_TYPE"].Equals("VI")) //collection.检验类型=‘VI’
{
DataRow itemDr = poArrivalInspectionD1Info.NewRow();
itemDr["PO_ARRIVAL_INSPECTION_D1_ID"] = keyService.CreateId();
itemDr["ParentId"] = poArrivalInspectionId;
itemDr["SEQUENCE"] = item["SEQUENCE"]; //检验顺序
DependencyObject inspectionPlantD = GetInspectionPlantD(dr["INSPECTION_PLAN_ID"],
item["INSPECTION_ITEM_ID"]);
itemDr["DEFECT_CLASS"] = inspectionPlantD["DEFECT_CLASS"];
itemDr["INSPECTION_QTY"] = defaultDecimal;
itemDr["INSPECTION_QQ"] = defaultDecimal;
itemDr["DECISION"] = false;
itemDr["IMPACT_RESULT"] = inspectionPlantD["IMPACT_RESULT"];
itemDr["REMARK"] = string.Empty;
itemDr["INSPECTION_ITEM_ID"] = item["INSPECTION_ITEM_ID"]; //检验项目
itemDr["DEFECTIVE_REASONS_ID"] = Maths.GuidDefaultValue();
itemDr["ACCEPTANCE_CONSTANT"] = defaultDecimal;
itemDr["SS"] = defaultDecimal;
itemDr["XX"] = defaultDecimal;
//系统管理字段
AddManagementData(itemDr, loginService);
poArrivalInspectionD1Info.Rows.Add(itemDr.ItemArray);
}
}
#endregion
//记录单据信息
DocmentInfo docmentInfo = new DocmentInfo();
docmentInfo.Id = dr["PO_ARRIVAL_INSPECTION_ID"];
docmentInfo.OwnerOrgId = dr["Owner_Org_ROid"];
docmentInfo.DocId = dr["DOC_ID"];
docmentInfo.DocNo = dr["DOC_NO"].ToStringExtension();
listDocuments.Add(docmentInfo);
if (Maths.IsEmpty(resutQcNo))
{
resutQcNo = dr["DOC_NO"].ToStringExtension();
}
else
{
resutQcNo += "，" + dr["DOC_NO"].ToStringExtension();
}
}
}
#region 将数据统一插入数据库中
using (ITransactionService trans = GetService <ITransactionService>()) {
IQueryService querySrv = GetService <IQueryService>();
//生成采购到货检验单
if (poArrivalInspectionInfo.Rows.Count > 0)
{
poArrivalInspectionInfo.Columns.Remove("SequenceNumber");
poArrivalInspectionInfo.Columns.Remove("ARRIVAL_DATE");
poArrivalInspectionInfo.Columns.Remove("INSPECT_DAYS");
poArrivalInspectionInfo.Columns.Remove("STOCK_UNIT_ID");
poArrivalInspectionInfo.Columns.Remove("SECOND_UNIT_ID");
poArrivalInspectionInfo.Columns.Remove("PURCHASE_TYPE");
BulkCopyAll(poArrivalInspectionInfo, querySrv);
}
//生成采购到货检验单计数单身
if (poArrivalInspectionDInfo.Rows.Count > 0)
{
BulkCopyAll(poArrivalInspectionDInfo, querySrv);
}
//生成采购到货检验单计量单身
if (poArrivalInspectionD1Info.Rows.Count > 0)
{
BulkCopyAll(poArrivalInspectionD1Info, querySrv);
}
//生成计数品质检验不良原因
if (defectiveReasonsAiId.Rows.Count > 0)
{
BulkCopyAll(defectiveReasonsAiId, querySrv);
}
//EFNET签核
var infos = listDocuments.GroupBy(c => new { DOC_ID = c.DocId, OwnerOrgID = c.OwnerOrgId });
foreach (var item in infos)
{
IEFNETStatusStatusService efnetSrv = GetService <IEFNETStatusStatusService>();
efnetSrv.GetFormFlow("PO_ARRIVAL_INSPECTION.I01", item.Key.DOC_ID, item.Key.OwnerOrgID,
item.Select(c => c.Id).ToArray());
}
//保存单据
IReadService readSrv = GetService <IReadService>("PO_ARRIVAL_INSPECTION");
object[] entities = readSrv.Read(listDocuments.Select(c => c.Id).Distinct().ToArray());
if (entities != null && entities.Length > 0)
{
ISaveService saveSrv = GetService <ISaveService>("PO_ARRIVAL_INSPECTION");
saveSrv.Save(entities);
}
trans.Complete();
}
#endregion
return(resutQcNo);
}
