private void ArchiveIfNeeded()
{
var archivableUsages = usageToday.GetArchivableUsages();
usageArchive.Archive(archivableUsages);
SavePreference savePreference = saveService.GetSavePreference();
if (!noArchiveList.Contains(savePreference) && archivableUsages.Count > 0)
{
usageArchive.DeleteUsagesOlderThen((int)savePreference);
saveService.Save(usageArchive, SaveType.Archive);
}
}
private void Save_Clicked(object sender, EventArgs e)
{
var info = new SKImageInfo((int)canvasView.CanvasSize.Width, (int)canvasView.CanvasSize.Height);
var surface = SKSurface.Create(info);
var canvas = surface.Canvas;
canvas.Clear();
foreach (FingerPaintPolyline polyline in completedPolylines)
{
canvas.DrawPath(polyline.Path, paint);
}
foreach (FingerPaintPolyline polyline in inProgressPolylines.Values)
{
canvas.DrawPath(polyline.Path, paint);
}
canvas.Flush();
var snap = surface.Snapshot();
using (var data = snap.Encode(SKEncodedImageFormat.Png, 80))
{
_saveService.Save(data.AsStream());
}
}
void Save()
{
if (!CanSave)
{
return;
}
saveService.Save(SelectedItems[0].Tab);
}
//20170209 add by liwei1 for P001-170203001 ===end===
private void InsertMR(DateTime report_datetime, string category, string recommendedOperations, DependencyObjectCollection resultColl, object docId) //20170209 modi by liwei1 for P001-170124001 增加参数：docId
{
DataTable dt = QueryForMoReceiptReq(report_datetime, category, recommendedOperations, docId); //20170209 modi by liwei1 for P001-170124001 增加参数：docId
ValidateParaFilDoc(dt); //20161213 add by shenbao for B001-161213006
DataTable dt_d = QueryForMoReceipt_D(category, report_datetime, recommendedOperations);
if (dt.Rows.Count > 0)
{
IQueryService qrySrv = GetService <IQueryService>();//20170405 add by wangrm for P001-170328001
ICreateService createSrv = GetService <ICreateService>("MO_RECEIPT_REQUISTION");
DependencyObject entity = createSrv.Create() as DependencyObject;
ISaveService saveService = this.GetService <ISaveService>("MO_RECEIPT_REQUISTION");
List <IGrouping <object, DataRow> > groupDt = dt_d.AsEnumerable().GroupBy(a => (a.Field <object>("MO_RECEIPT_REQUISTION_ID"))).ToList();
IEFNETStatusStatusService efnetSrv = this.GetService <IEFNETStatusStatusService>();
IDocumentNumberGenerateService docNumberService = this.GetService <IDocumentNumberGenerateService>("MO_RECEIPT_REQUISTION");
foreach (DataRow dr in dt.Rows)
{
DependencyObject newEntity = new DependencyObject(entity.DependencyObjectType);
DependencyObjectCollection newEntityDColl = newEntity["MO_RECEIPT_REQUISTION_D"] as DependencyObjectCollection;
AddToEntity(newEntity, dr, dt.Columns, false);
newEntity["DOC_NO"] = docNumberService.NextNumber(dr["DOC_ID"], dr["DOC_DATE"].ToDate().Date);
List <IGrouping <object, DataRow> > entityDColl = groupDt.Where(c => c.Key.Equals(dr["MO_RECEIPT_REQUISTION_ID"])).ToList();
foreach (IGrouping <object, DataRow> groupDColl in entityDColl)
{
foreach (DataRow dr_d in groupDColl)
{
DependencyObject newEntityD = new DependencyObject(newEntityDColl.ItemDependencyObjectType);
AddToEntity(newEntityD, dr_d, dt_d.Columns, true);
newEntityDColl.Add(newEntityD);
}
}
//20170428 add by wangyq for P001-170427001 ============begin==========
DependencyObject resultObj = resultColl.AddNew();
resultObj["doc_no"] = newEntity["DOC_NO"];
//20170428 add by wangyq for P001-170427001 ============end==========
//20170628 modi by zhangcn for P001-170327001 ===begin===
try {
SetIgnoreWarningTag(); //忽略警告
saveService.Save(newEntity); //希望触发保存校验
}
finally {
ResetIgnoreWarningTag();// 重置警告
}
//20170628 modi by zhangcn for P001-170327001 ===end===
//7.3自动签核
efnetSrv.GetFormFlow("MO_RECEIPT_REQUISTION.I01", dr["DOC_ID"], dr["Owner_Org_ROid"],
new List <object>()
{
dr["MO_RECEIPT_REQUISTION_ID"]
});
}
}
}
/// <summary>
///
/// </summary>
/// <param name="counting_type">盘点类型</param>
/// <param name="site_no">营运据点</param>
/// <param name="counting_no">盘点计划编号</param>
/// <param name="scan"></param>
public void UpdateCountingPlan(string counting_type, string site_no, string counting_no, DependencyObjectCollection scan)
{
if (string.IsNullOrEmpty(counting_no))
{
IInfoEncodeContainer infoContainer = this.GetService <IInfoEncodeContainer>();
throw new BusinessRuleException(string.Format(infoContainer.GetMessage("A111201"), "counting_no"));
}
using (IConnectionService connectionService = this.GetService <IConnectionService>()) {
_qurService = this.GetService <IQueryService>();
CreateTempTable(); //创建临时表
InsertToScan(site_no, scan); //临时表储存scan入参
QueryNode queryScan = QueryScan(counting_no);
QueryNode querySumNode = QuerySumForInsert(counting_no, queryScan);
DependencyObjectCollection sumColl = _qurService.ExecuteDependencyObject(querySumNode);
List <DependencyObject> newList = new List <DependencyObject>();
ISaveService saveService = this.GetService <ISaveService>("COUNTING");
if (sumColl.Count > 0) //查询存在记录新增实体COUNTING
{
ICreateService createSrv = GetService <ICreateService>("COUNTING");
DependencyObject entity = createSrv.Create() as DependencyObject;
newList = InsertCOUNTING(counting_type, counting_no, sumColl, entity.DependencyObjectType);
}
ICreateService createSrvParaFil = this.GetService <ICreateService>("PARA_FIL");
QueryNode updateNode = null;
QueryNode insertNode = null;
if (createSrvParaFil != null) //表示该typekey存在
{
bool bcManagement = GetBcInventoryManagement();
if (bcManagement)
{
QueryNode querySumBarcodeNode = QuerySumBarcode(counting_no, queryScan);
updateNode = GetUpdateNode(counting_type, counting_no, querySumBarcodeNode);
insertNode = QueryNodeForInsert(counting_no, counting_type, querySumBarcodeNode);
}
}
using (ITransactionService transActionService = this.GetService <ITransactionService>()) {
if (newList.Count > 0)
{
SetIgnoreWarningTag(true);
saveService.Save(newList.ToArray());
SetIgnoreWarningTag(false);
}
//更新条码盘点计划
if (updateNode != null) //启用条码库存管理更新
{
_qurService.ExecuteNoQueryWithManageProperties(updateNode);
}
//新增条码盘点计划
if (insertNode != null) //启用条码库存管理更新
{
_qurService.ExecuteNoQueryWithManageProperties(insertNode);
}
transActionService.Complete();
}
}
}
/// <summary>
/// 不起作用
/// </summary>
private void saveBtn()
{
/*
* // 构建保存操作参数：设置操作选项值，忽略交互提示
* OperateOption saveOption = OperateOption.Create();
* // 忽略交互提示
* saveOption.SetIgnoreWarning(true);
* saveOption.SetIgnoreInteractionFlag(true);
*/
ISaveService saveService = ServiceHelper.GetService <ISaveService>();
var dataObjects = new DynamicObject[] { this.View.BillModel.DataObject };
saveService.Save(this.Context, dataObjects);
}
public FileSetupPageViewModel(
DirectoryListViewModel dirList,
NotificationCenterViewModel notificationCenter,
OpenFileDialogCommand openFile,
SaveFileDialogCommand saveFile,
ISaveService saveService
) : base("File Setup", PackIconKind.File)
{
this.DirList = dirList;
this.NotificationCenter = notificationCenter;
OpenFile = openFile;
SaveFile = saveFile;
this.saveService = saveService;
this.SaveFileAction = (path) => saveService.Save(path);
}
public override void AfterBarItemClick(AfterBarItemClickEventArgs e)
{
if (e.BarItemKey.Equals("tbsave"))
{
long entryid = 0;
getTableName();
Entity entity = this.View.BusinessInfo.GetEntity("FEntity");
DynamicObjectCollection objs = this.View.Model.GetEntityDataObject(entity);
DynamicObject[] lotMasters = null;
if (!lotIds.IsEmpty() && !lotIds.Equals("0"))
{
string filter = string.Format("FLOTID IN ('{0}')", lotIds);
OQLFilter of = OQLFilter.CreateHeadEntityFilter(filter);
lotMasters = BusinessDataServiceHelper.Load(this.Context, "BD_BatchMainFile", null, of);
}
foreach (DynamicObject obj in objs)
{
value = obj["F_QANo"];
entryid = Convert.ToInt64(obj["F_BEM_billentryid"]);
if (entryid == 0)
{
continue;
}
foreach (DynamicObject lotobj in lotMasters)
{
if (lotobj["id"].Equals(obj["FLOT_Id"]))
{
lotobj["F_QANo"] = obj["F_QANo"];
}
}
updateSqls.Add(string.Format(@"UPDATE {0} set F_QANo ='{1}' WHERE fentryid = {2} ", tableName, value, entryid));
}
ISaveService service = Kingdee.BOS.App.ServiceHelper.GetService <ISaveService>();
service.Save(this.Context, lotMasters);
DBUtils.ExecuteBatch(this.Context, updateSqls, updateSqls.Count);
//返回值到父窗口
this.View.ReturnToParentWindow("true");
this.View.Close();
}
base.AfterBarItemClick(e);
}
/// <summary>
/// 保存
/// </summary>
/// <param name="ctx"></param>
/// <param name="FormID">业务对象标识</param>
/// <param name="dyObject">保存业务对象集合</param>
/// <returns></returns>
public IOperationResult SaveBill(Context ctx, string FormID, DynamicObject[] dyObject)
{
IMetaDataService metaService = ServiceHelper.GetService <IMetaDataService>();
FormMetadata targetBillMeta = metaService.Load(ctx, FormID) as FormMetadata;
// 构建保存操作参数：设置操作选项值，忽略交互提示
OperateOption saveOption = OperateOption.Create();
// 忽略全部需要交互性质的提示，直接保存；
//saveOption.SetIgnoreWarning(true); // 忽略交互提示
//saveOption.SetInteractionFlag(this.Option.GetInteractionFlag()); // 如果有交互，传入用户选择的交互结果
// using Kingdee.BOS.Core.Interaction;
//saveOption.SetIgnoreInteractionFlag(this.Option.GetIgnoreInteractionFlag());
//// 如下代码，强制要求忽略交互提示(演示案例不需要，注释掉)
saveOption.SetIgnoreWarning(true);
//// using Kingdee.BOS.Core.Interaction;
saveOption.SetIgnoreInteractionFlag(true);
// 调用保存服务，自动保存
ISaveService saveService = ServiceHelper.GetService <ISaveService>();
IOperationResult saveResult = saveService.Save(ctx, targetBillMeta.BusinessInfo, dyObject, saveOption, "Save");
ISubmitService save1Service = ServiceHelper.GetService <ISubmitService>();
return(saveResult);
}
/// <summary>
///
/// </summary>
/// <param name="employee_no">扫描人员</param>
/// <param name="scan_type">扫描类型1.有箱条码 2.无箱条码</param>
/// <param name="report_datetime">上传时间</param>
/// <param name="picking_department_no">部门</param>
/// <param name="recommended_operations">建议执行作业</param>
/// <param name="recommended_function">A.新增 S.过帐</param>
/// <param name="scan_doc_no">扫描单号</param>
/// <param name="collScan"></param>
public DependencyObjectCollection InertTransactionDoc(string employee_no, string scan_type, DateTime report_datetime,
string picking_department_no, string recommended_operations, string recommended_function,
string scan_doc_no, DependencyObjectCollection scanColl)
{
IInfoEncodeContainer InfoEncodeSrv = this.GetService <IInfoEncodeContainer>();
if (Maths.IsEmpty(recommended_operations))
{
throw new BusinessRuleException(InfoEncodeSrv.GetMessage("A111201", "recommended_operations"));//‘入参【recommended_operations】未传值’
}
if (Maths.IsEmpty(recommended_function))
{
throw new BusinessRuleException(InfoEncodeSrv.GetMessage("A111201", "recommended_function"));//‘入参【recommended_function】未传值’
}
DependencyObjectType type = new DependencyObjectType("ReturnCollection");
type.RegisterSimpleProperty("doc_no", typeof(string));
DependencyObjectCollection Rtn = new DependencyObjectCollection(type);
if (scanColl.Count > 0)
{
string stockAction = string.Empty;
string view = string.Empty;
if (recommended_operations.StartsWith("11"))
{
stockAction = "-1";
view = "TRANSACTION_DOC.I02";
}
else if (recommended_operations.StartsWith("12"))
{
stockAction = "1";
view = "TRANSACTION_DOC.I01";
}
DependencyObjectCollection docColl = ValidateDocSet(stockAction, scanColl[0]["site_no"].ToStringExtension());
if (docColl.Count <= 0)
{
throw new BusinessRuleException(InfoEncodeSrv.GetMessage("A111275"));
}
DataTable dtScan = CreateDtScan();
DataTable dtScanDetail = CreateDtScanDetail();
PrepareDtForInsertScan(employee_no, picking_department_no, scanColl, dtScan, dtScanDetail);
using (IConnectionService connService = this.GetService <IConnectionService>()) {
_qurService = this.GetService <IQueryService>();
CreateTemp();
InsertTemp(dtScan, dtScanDetail);
List <DependencyObject> saveEntities = AddEntity(docColl[0]["DOC_ID"], docColl[0]["SEQUENCE_DIGIT"].ToInt32(), report_datetime, stockAction);
if (saveEntities.Count > 0)
{
using (ITransactionService transService = this.GetService <ITransactionService>()) {
InsertBCLine(report_datetime);//20170413 add by wangyq for P001-170412001 需要在保存服务之前,保存自动审核会需要回写
//保存单据
ISaveService saveSrv = this.GetService <ISaveService>("TRANSACTION_DOC");
saveSrv.Save(saveEntities.ToArray());
UpdateTD();//更新
//InsertBCLine(report_datetime);//20170413 mark by wangyq for P001-170412001
//EFNET签核
foreach (DependencyObject item in saveEntities)
{
IEFNETStatusStatusService efnetSrv = this.GetService <IEFNETStatusStatusService>();
efnetSrv.GetFormFlow(view, item["DOC_ID"], ((DependencyObject)item["Owner_Org"])["ROid"], new object[] { item["TRANSACTION_DOC_ID"] });
}
transService.Complete();
}
foreach (DependencyObject item in saveEntities)
{
DependencyObject obj = Rtn.AddNew();
obj["doc_no"] = item["DOC_NO"];
}
}
}
}
return(Rtn);
}
/// <summary>
/// 自动下推并保存
/// </summary>
/// <param name="sourceFormId">源单FormId</param>
/// <param name="targetFormId">目标单FormId</param>
/// <param name="sourceBillIds">源单内码</param>
private IOperationResult DoPush(string sourceFormId, string targetFormId, long targetOrgId, List <long> sourceBillIds)
{
IOperationResult result = new OperationResult();
result.IsSuccess = false;
// 获取源单与目标单的转换规则
IConvertService convertService = Kingdee.BOS.App.ServiceHelper.GetService <IConvertService>();
var rules = convertService.GetConvertRules(this.Context, sourceFormId, targetFormId);
if (rules == null || rules.Count == 0)
{
throw new KDBusinessException("", string.Format("未找到{0}到{1}之间，启用的转换规则，无法自动下推！", sourceFormId, targetFormId));
}
// 取勾选了默认选项的规则
var rule = rules.FirstOrDefault(t => t.IsDefault);
//var rule = rules.
// 如果无默认规则，则取第一个
if (rule == null)
{
rule = rules[0];
}
// 开始构建下推参数：
// 待下推的源单数据行
List <ListSelectedRow> srcSelectedRows = new List <ListSelectedRow>();
foreach (var billId in sourceBillIds)
{// 把待下推的源单内码，逐个创建ListSelectedRow对象，添加到集合中
srcSelectedRows.Add(new ListSelectedRow(billId.ToString(), string.Empty, 0, sourceFormId));
// 特别说明：上述代码，是整单下推；
// 如果需要指定待下推的单据体行，请参照下句代码，在ListSelectedRow中，指定EntryEntityKey以及EntryId
//srcSelectedRows.Add(new ListSelectedRow(billId.ToString(), entityId, 0, sourceFormId) { EntryEntityKey = "FEntity" });
}
// 指定目标单单据类型:情况比较复杂，没有合适的案例做参照，示例代码暂略，直接留空，会下推到默认的单据类型
string targetBillTypeId = string.Empty;
// 指定目标单据主业务组织：情况更加复杂，需要涉及到业务委托关系，缺少合适案例，示例代码暂略
// 建议在转换规则中，配置好主业务组织字段的映射关系：运行时，由系统根据映射关系，自动从上游单据取主业务组织，避免由插件指定
//long targetOrgId = 0;
// 自定义参数字典：把一些自定义参数，传递到转换插件中；转换插件再根据这些参数，进行特定处理
Dictionary <string, object> custParams = new Dictionary <string, object>();
// 组装下推参数对象
PushArgs pushArgs = new PushArgs(rule, srcSelectedRows.ToArray())
{
TargetBillTypeId = targetBillTypeId,
TargetOrgId = targetOrgId,
CustomParams = custParams
};
// 调用下推服务，生成下游单据数据包
ConvertOperationResult operationResult = convertService.Push(this.Context, pushArgs, OperateOption.Create());
// 开始处理下推结果:
// 获取下推生成的下游单据数据包
DynamicObject[] targetBillObjs = (from p in operationResult.TargetDataEntities select p.DataEntity).ToArray();
if (targetBillObjs.Length == 0)
{
// 未下推成功目标单，抛出错误，中断审核
throw new KDBusinessException("", string.Format("由{0}自动下推{1}，没有成功生成数据包，自动下推失败！", sourceFormId, targetFormId));
}
// 对下游单据数据包，进行适当的修订，以避免关键字段为空，自动保存失败
// 示例代码略
// 读取目标单据元数据
IMetaDataService metaService = Kingdee.BOS.App.ServiceHelper.GetService <IMetaDataService>();
var targetBillMeta = metaService.Load(this.Context, targetFormId) as FormMetadata;
// 构建保存操作参数：设置操作选项值，忽略交互提示
OperateOption saveOption = OperateOption.Create();
// 忽略全部需要交互性质的提示，直接保存；
saveOption.SetIgnoreWarning(true); // 忽略交互提示
saveOption.SetInteractionFlag(this.Option.GetInteractionFlag()); // 如果有交互，传入用户选择的交互结果
// using Kingdee.BOS.Core.Interaction;
saveOption.SetIgnoreInteractionFlag(this.Option.GetIgnoreInteractionFlag());
// 调用保存服务，自动保存
ISaveService saveService = Kingdee.BOS.App.ServiceHelper.GetService <ISaveService>();
var saveResult = saveService.Save(this.Context, targetBillMeta.BusinessInfo, targetBillObjs, saveOption, "Save");
// 判断自动保存结果：只有操作成功，才会继续
if (saveResult.SuccessDataEnity != null)
{
var submitRet = AppServiceContext.SubmitService.Submit(this.Context, targetBillMeta.BusinessInfo, saveResult.SuccessDataEnity.Select(o => o["Id"]).ToArray(), "Submit", saveOption);
result.MergeResult(submitRet);
if (submitRet.SuccessDataEnity != null)
{
var auditResult = AppServiceContext.SetStatusService.SetBillStatus(this.Context, targetBillMeta.BusinessInfo,
submitRet.SuccessDataEnity.Select(o => new KeyValuePair <object, object>(o["Id"], 0)).ToList(),
new List <object> {
"1", ""
},
"Audit", saveOption);
result.MergeResult(auditResult);
}
}
if (this.CheckOpResult(saveResult, saveOption))
{
return(result);
}
return(result);
}
/// <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);
}
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);
}
public void SaveValue(DebuggableValueModel debuggableValue)
{
SaveService.Save(debuggableValue);
}
SaveCommandInit(ISaveService saveService, IAppWindow appWindow, IDocumentTabService documentTabService) {
appWindow.MainWindowCommands.Add(ApplicationCommands.Save, (s, e) => saveService.Save(documentTabService.ActiveTab), (s, e) => e.CanExecute = saveService.CanSave(documentTabService.ActiveTab));
}
SaveCommandInit(ISaveService saveService, IAppWindow appWindow, IDocumentTabService documentTabService)
{
appWindow.MainWindowCommands.Add(ApplicationCommands.Save, (s, e) => saveService.Save(documentTabService.ActiveTab), (s, e) => e.CanExecute = saveService.CanSave(documentTabService.ActiveTab));
}
/// <summary>
/// 审核结束自动下推（应付单下推付款申请单）
/// </summary>
/// <param name="e"></param>
public override void AfterExecuteOperationTransaction(AfterExecuteOperationTransaction e)
{
base.AfterExecuteOperationTransaction(e);
try
{
string sql = string.Empty;
if (e.DataEntitys != null && e.DataEntitys.Count <DynamicObject>() > 0)
{
foreach (DynamicObject item in e.DataEntitys)
{
//收款单id
string Fid = item["Id"].ToString();
string sql2 = "";
//收款单源单明细
DynamicObjectCollection RECEIVEBILLSRCENTRYList = item["RECEIVEBILLSRCENTRY"] as DynamicObjectCollection;
foreach (var entry in RECEIVEBILLSRCENTRYList)
{
//销售订单明细内码
string FORDERENTRYID = entry["FSRCORDERENTRYID"].ToString();
//本次收款金额
decimal FREALRECAMOUNT = Convert.ToDecimal(entry["REALRECAMOUNT"].ToString());
if (!string.IsNullOrEmpty(FORDERENTRYID))
{
//查询采购订单
sql = string.Format(@"select a.FBILLNO,b.FENTRYID as 采购订单明细内码 ,f.F_YBG_BUSINESSMODEL as 业务模式 from t_PUR_POOrder a
inner join t_PUR_POOrderEntry b on a.fID=b.FID
inner join T_PUR_POORDERENTRY_LK c on c.FENTRYID=b.FENTRYID
left join T_SAL_ORDERENTRY d on d.FENTRYID=c.FSID
left join T_SAL_ORDER f on f.FID=d.FID
where FSID='{0}'", FORDERENTRYID);
DataSet ds = DBServiceHelper.ExecuteDataSet(this.Context, sql);
DataTable dt = ds.Tables[0];
if (dt.Rows.Count > 0)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
string F_YBG_BUSINESSMODEL = dt.Rows[i]["采购订单明细内码"].ToString();
if (F_YBG_BUSINESSMODEL == "01" || F_YBG_BUSINESSMODEL == "04") //挂靠的采用自动生成付款申请单
{
string POFENTRYID = dt.Rows[i]["采购订单明细内码"].ToString();
if (string.IsNullOrEmpty(sql2))
{
sql2 += " FPAYABLEENTRYID='" + POFENTRYID + "' ";
}
else
{
sql2 += " or FPAYABLEENTRYID='" + POFENTRYID + "' ";
}
}
}
}
}
}
if (!string.IsNullOrEmpty(sql2))
{
#region 应付单下推付款申请单
string srcFormId = "AP_Payable"; //应付单
string destFormId = "CN_PAYAPPLY"; //付款申请单
IMetaDataService mService = Kingdee.BOS.App.ServiceHelper.GetService <IMetaDataService>();
IViewService vService = Kingdee.BOS.App.ServiceHelper.GetService <IViewService>();
FormMetadata destmeta = mService.Load(this.Context, destFormId) as FormMetadata;
//转换规则的唯一标识
string ruleKey = "AP_PayableToPayApply";
//var rules = ConvertServiceHelper.GetConvertRules(Context, srcFormId, destFormId);
//var rule = rules.FirstOrDefault(t => t.IsDefault);
ConvertRuleElement rule = GetDefaultConvertRule(Context, srcFormId, destFormId, ruleKey);
List <ListSelectedRow> lstRows = new List <ListSelectedRow>();
string strsql = "select a.FID , a.FENTRYID from T_AP_PAYABLEPLAN a left join T_AP_PAYABLE b on a.FID=b.FID where b.FDOCUMENTSTATUS='C' and (" + sql2 + ") ";
DataSet ds2 = DBServiceHelper.ExecuteDataSet(Context, strsql);
if (ds2.Tables[0].Rows.Count > 0)
{
HashSet <string> hasset = new HashSet <string>();
for (int j = 0; j < ds2.Tables[0].Rows.Count; j++)
{
hasset.Add(ds2.Tables[0].Rows[j]["FID"].ToString());
long entryId = Convert.ToInt64(ds2.Tables[0].Rows[j]["FENTRYID"]);
//源单单据标识
ListSelectedRow row = new ListSelectedRow(ds2.Tables[0].Rows[j]["FID"].ToString(), entryId.ToString(), 0, "AP_Payable");
//源单单据体标识
row.EntryEntityKey = "FEntityPlan";
lstRows.Add(row);
}
PushArgs pargs = new PushArgs(rule, lstRows.ToArray());
IConvertService cvtService = Kingdee.BOS.App.ServiceHelper.GetService <IConvertService>();
OperateOption option = OperateOption.Create();
option.SetIgnoreWarning(true);
option.SetVariableValue("ignoreTransaction", false);
option.SetIgnoreInteractionFlag(true);
#region 提交审核
//OperateOption option2 = OperateOption.Create();
//option2.SetIgnoreWarning(true);
//option2.SetVariableValue("ignoreTransaction", true);
//foreach (var hid in hasset)
//{
// //如果应付单没有提交先提交审核
// IMetaDataService BomService = Kingdee.BOS.App.ServiceHelper.GetService<IMetaDataService>();
// //应付单元素包
// FormMetadata APMeta = BomService.Load(Context, "AP_Payable") as FormMetadata;
// IViewService APVService = Kingdee.BOS.App.ServiceHelper.GetService<IViewService>();
// //应付单数据包
// DynamicObject APmd = APVService.LoadSingle(Context, hid, APMeta.BusinessInfo.GetDynamicObjectType());
// DynamicObject[] dy = new DynamicObject[] { APmd };
// object[] items = dy.Select(p => p["Id"]).ToArray();
// ISubmitService submitService = Kingdee.BOS.App.ServiceHelper.GetService<ISubmitService>();
// IOperationResult submitresult = submitService.Submit(Context, APMeta.BusinessInfo, items, "Submit", option2);
// IAuditService auditService = Kingdee.BOS.App.ServiceHelper.GetService<IAuditService>();
// IOperationResult auditresult = auditService.Audit(Context, APMeta.BusinessInfo, items, option2);
//}
#endregion
ConvertOperationResult cvtResult = cvtService.Push(Context, pargs, option, false);
if (cvtResult.IsSuccess)
{
DynamicObject[] dylist = (from p in cvtResult.TargetDataEntities select p.DataEntity).ToArray();
//修改应收单里面数据
for (int K = 0; K < dylist.Length; K++)
{
//付款原因
dylist[K]["F_YBG_Remarks"] = "供应商付款";
//明细信息
DynamicObjectCollection RECEIVEBILLENTRYList = dylist[K]["FPAYAPPLYENTRY"] as DynamicObjectCollection;
foreach (var Entry in RECEIVEBILLENTRYList)
{
//结算方式
BaseDataField FSETTLETYPEID = destmeta.BusinessInfo.GetField("FSETTLETYPEID") as BaseDataField;
Entry["FSETTLETYPEID_Id"] = 4;
Entry["FSETTLETYPEID"] = vService.LoadSingle(Context, 4, FSETTLETYPEID.RefFormDynamicObjectType);
}
}
//保存
ISaveService saveService = Kingdee.BOS.App.ServiceHelper.GetService <ISaveService>();
IOperationResult saveresult = saveService.Save(Context, destmeta.BusinessInfo, dylist, option);
bool reult = CheckResult(saveresult, out string mssg);
if (!reult)
{
throw new Exception("收款款单审核成功，生成付款申请单失败：");
}
else
{
//纪录核销的纪录
OperateResultCollection operateResults = saveresult.OperateResult;
string fnmber = operateResults[0].Number;
string fid = operateResults[0].PKValue.ToString();
}
}
}
else
{
throw new KDException("", "应付单不存在或者未审核，下推付款申请单失败");
}
#endregion
}
}
}
}
catch (Exception ex)
{
throw new KDException("", "应付单下推付款申请单失败：" + ex.ToString());
}
}
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);
}
/// <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 override void ButtonClick(BOS.Core.DynamicForm.PlugIn.Args.ButtonClickEventArgs e)
{
base.ButtonClick(e);
string PformId = this.View.BillBusinessInfo.GetForm().Id;
switch (PformId)
{
case "STK_InStock": //采购入库
tableName = "T_STK_INSTOCKENTRY";
break;
case "STK_MISCELLANEOUS": //其他入库
tableName = "T_STK_MISCELLANEOUSENTRY";
break;
case "SP_InStock": //简单生产入库
tableName = "T_SP_INSTOCKENTRY";
break;
case "STK_InitInStock": //期初采购入库
tableName = "T_STK_INITINSTOCKENTRY";
break;
case "STK_OEMInStock": //受托加工材料入库
tableName = "T_STK_OEMINSTOCKENTRY";
break;
case "STK_InvInit":
tableName = "T_STK_INVINITDETAIL";
break;
default: break;
}
//string a;
//if ((a = e.Key.ToUpper()) != null)
//{
// if (!(a == "FBTNCONFIRM"))
// {
// if (a == "FBTNCANCEL")
// {
// this.View.Close();
// }
// }
// else
// {
//value = this.View.Model.GetValue("F_BEM_QANO");
//if (value == null)
//{
// this.View.ShowMessage("请输入质保书号");
// return;
//}
if (!lotIds.IsEmpty() && !lotIds.Equals("0"))
{
string filter = string.Format("FLOTID IN ('{0}')", lotIds);
OQLFilter of = OQLFilter.CreateHeadEntityFilter(filter);
var lotMasters = BusinessDataServiceHelper.Load(this.Context, "BD_BatchMainFile", null, of);
foreach (var lot in lotMasters)
{
lot["F_QANo"] = value;
}
ISaveService service = Kingdee.BOS.App.ServiceHelper.GetService <ISaveService>();
service.Save(this.Context, lotMasters);
updateSqls.Add(string.Format(@"UPDATE {0} set F_QANo ='{1}' WHERE flot in ('{2}') ", tableName, value, lotIds));
}
if (!ids.IsEmpty())
{
updateSqls.Add(string.Format(@"UPDATE {0} set F_QANo ='{1}' WHERE fid in ('{2}') ", tableName, value, ids));
}
else if (!entryIds.IsEmpty())
{
updateSqls.Add(string.Format(@"UPDATE {0} set F_QANo ='{1}' WHERE fentryid in ('{2}') ", tableName, value, entryIds));
}
DBUtils.ExecuteBatch(this.Context, updateSqls, updateSqls.Count);
//}
//返回值到父窗口
// this.View.ReturnToParentWindow("true");
this.View.Close();
}
public override void EndOperationTransaction(BOS.Core.DynamicForm.PlugIn.Args.EndOperationTransactionArgs e)
{
lotIds.Clear();
List <SqlObject> sqlList = new List <SqlObject>();
foreach (var item in e.DataEntitys)
{
string formId = "";
if (item.DynamicObjectType.Name.Equals("InvInit"))
{
formId = "STK_InvInit";
}
else
{
formId = item["FFormId"].ToString();
}
DynamicObjectCollection details = null;
switch (formId)
{
case "STK_MISCELLANEOUS":
details = item["STK_MISCELLANEOUSENTRY"] as DynamicObjectCollection;
break;
case "STK_InStock":
details = item["InStockEntry"] as DynamicObjectCollection;
break;
case "SP_InStock":
details = item["Entity"] as DynamicObjectCollection;
break;
case "STK_OEMInStock":
details = item["OEMInStockEntry"] as DynamicObjectCollection;
break;
case "STK_InitInStock":
details = item["InitInStockEntry"] as DynamicObjectCollection;
break;
case "STK_InvInit":
details = item["InvInitDetail"] as DynamicObjectCollection;
break;
default: break;
}
if (details == null)
{
return;
}
foreach (var entryItem in details)
{
Object lotObj = entryItem["LOT"];
if (null != lotObj && Convert.ToInt16((lotObj as DynamicObject)["BizType"]) == 1)
{
sqlList.Add(this.getSqlParams(formId, entryItem, item));
}
}
}
if (sqlList.Count > 0 && lotIds.Count > 0)
{
DBUtils.ExecuteBatch(this.Context, sqlList);
string filter = string.Format("FLOTID IN ({0})", string.Join(",", lotIds));
OQLFilter of = OQLFilter.CreateHeadEntityFilter(filter);
DynamicObject[] lotMasters = BusinessDataServiceHelper.Load(this.Context, "BD_BatchMainFile", null, of);
ISaveService service = Kingdee.BOS.App.ServiceHelper.GetService <ISaveService>();
service.Save(this.Context, lotMasters);
}
}
private void Store_TimerElasped()
{
saveService.Save(store.GetUsageKeeper());
}
