/// <summary>
        /// 创建送货单临时表
        /// </summary>
        /// <returns></returns>
        private DataTable FilArrivalNewDt(object filArrivalId, string siteNo, string deliveryNo, string createDate, string supplierNo,
                                          string purchaseType, string receiptAddress, string receiptNo, string printQty, string remark, string status)
        {
            //创建临时表
            DataTable     dataTable = CreateFilArrivalInfo();
            ILogOnService loginSrv  = GetService <ILogOnService>();
            //新增行
            DataRow dr = dataTable.NewRow();

            dr["FIL_ARRIVAL_ID"] = filArrivalId;        //主键
            dr["BOOK_CODE"]      = "99";                //企业编号
            dr["PLANT_CODE"]     = siteNo;              //门店
            dr["DOC_NO"]         = deliveryNo;          //发货单号
            dr["DOC_DATE"]       = createDate.ToDate(); //单据日期
            dr["COMPANY_CODE"]   = supplierNo;          //公司代号
            dr["CATEGORY"]       = purchaseType;        //采购性质
            dr["ADDR_NAME"]      = receiptAddress;      //收货地址
            dr["ARRIVAL_NO"]     = receiptNo;           //收货单号
            dr["PRINT"]          = printQty.ToInt32();  //打印次数
            dr["REMARK"]         = remark;              //备注
            dr["STATUS"]         = status;              //状态
            //系统管理字段
            dr["CreateBy"]         = loginSrv.CurrentUserId;
            dr["CreateDate"]       = DateTime.Now;
            dr["ModifiedBy"]       = loginSrv.CurrentUserId;
            dr["ModifiedDate"]     = DateTime.Now;
            dr["LastModifiedBy"]   = loginSrv.CurrentUserId;
            dr["LastModifiedDate"] = DateTime.Now;
            //添加至dataTable中
            dataTable.Rows.Add(dr);
            return(dataTable);
        }
 public ContriveAccountController(IUserServiceExtended userService,
                                  ILogOnService logOnService,
                                  IEmailService emailService)
 {
     _userService = userService;
     _logOnService = logOnService;
     _emailService = emailService;
 }
 /// <summary>
 /// 增加管理字段数据
 /// </summary>
 /// <param name="dr"></param>
 /// <param name="loginService"></param>
 private void AddManagementData(DataRow dr, ILogOnService loginService)
 {
     dr["CreateBy"]         = loginService.CurrentUserId;
     dr["CreateDate"]       = DateTime.Now;
     dr["ModifiedBy"]       = loginService.CurrentUserId;
     dr["ModifiedDate"]     = DateTime.Now;
     dr["LastModifiedBy"]   = loginService.CurrentUserId;
     dr["LastModifiedDate"] = DateTime.Now;
 }
        /// <summary>
        /// 创建送货单单身临时表
        /// </summary>
        /// <returns></returns>
        private DataTable FilArrivalDNewDt(DependencyObjectCollection deliveryDetail, string siteNo, string deliveryNo, string supplierNo, object parentId, IPrimaryKeyService keyService)
        {
            //创建临时表
            DataTable     dataTable = CreateFilArrivalDInfo();
            ILogOnService loginSrv  = GetService <ILogOnService>();

            foreach (DependencyObject item in deliveryDetail)
            {
                //新增行
                DataRow dr = dataTable.NewRow();
                dr["FIL_ARRIVAL_D_ID"] = keyService.CreateId();            //主键
                dr["ParentId"]         = parentId;                         //父主键
                dr["BOOK_CODE"]        = "99";                             //企业编号
                dr["PLANT_CODE"]       = siteNo;                           //门店
                dr["DOC_NO"]           = deliveryNo;                       //发货单号
                dr["SequenceNumber"]   = item["seq"];                      //项次
                dr["COMPANY_CODE"]     = supplierNo;                       //公司代号
                dr["ORDER_NO"]         = item["purchase_no"];              //采购单号
                dr["ORDER_SE"]         = item["purchase_seq"].ToInt32();   //采购单序号
                dr["ORDER_SE_SE"]      = item["line_seq"].ToInt32();       //采购单子序号
                dr["ORDER_SE_SE_SE"]   = item["batch_seq"].ToInt32();      //采购订单子子单身
                dr["ITEM_CODE"]        = item["item_no"];                  //品号
                dr["ITEM_NAME"]        = item["item_name"];                //品名
                dr["ITEM_DESCRIPTION"] = item["item_spec"];                //规格
                dr["WAREHOUSE_CODE"]   = item["warehouse_no"];             //仓库
                dr["UNIT_CODE"]        = item["unit_no"];                  //单位
                dr["PU_QTY"]           = item["purchase_qty"].ToDecimal(); //采购量
                dr["UNARR_QTY"]        = item["unpaid_qty"].ToDecimal();   //未交量
                dr["ACTUAL_QTY"]       = item["qty"].ToDecimal();          //实发量
                dr["RECEIPT_QTY"]      = item["receipt_qty"].ToDecimal();  //收货量
                dr["TAX_INVOICE_NO"]   = string.Empty;                     //发票号
                dr["PACKING_QTY"]      = item["box_qty"].ToDecimal();      //箱装量
                dr["BC_TYPE"]          = item["barcode_type"];             //条码类型

                dr["CHECK_NO"]          = item["qc_type"];
                dr["PRICE_UNIT_CODE"]   = item["valuation_unit_no"];
                dr["PRICE_QTY"]         = item["valuation_qty"];
                dr["RECEIPT_OVER_RATE"] = item["over_deliver_rate"];
                dr["ITEM_FEATURE_CODE"] = item["item_feature_no"];
                dr["STATUS"]            = item["receipt_status"];
                //系统管理字段
                dr["CreateBy"]         = loginSrv.CurrentUserId;
                dr["CreateDate"]       = DateTime.Now;
                dr["ModifiedBy"]       = loginSrv.CurrentUserId;
                dr["ModifiedDate"]     = DateTime.Now;
                dr["LastModifiedBy"]   = loginSrv.CurrentUserId;
                dr["LastModifiedDate"] = DateTime.Now;

                //添加至dataTable中
                dataTable.Rows.Add(dr);
            }
            return(dataTable);
        }
Exemplo n.º 5
0
 public AccountController(IUserService userService, ILogOnService logOnService)
 {
     _userService = userService;
     _logOnService = logOnService;
 }
        /// <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);
        }
Exemplo n.º 7
0
        /// <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);
        }
Exemplo n.º 10
0
 public LogController(ILogOnService logOn)
 {
     _logOn = logOn;
 }