package nc.ui.bd.material.check.config;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import oracle.sql.ARRAY;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.framework.common.NCLocator;
import nc.bs.logging.Logger;
import nc.itf.bd.material.fi.IMaterialFiQueryService;
import nc.itf.bd.material.plan.IMaterialPlanQueryService;
import nc.itf.bd.material.prod.IMaterialProdQueryService;
import nc.itf.bd.material.stock.IMaterialStockQueryService;
import nc.itf.uap.IUAPQueryBS;
import nc.jdbc.framework.processor.ArrayListProcessor;
import nc.ui.pub.beans.MessageDialog;
import nc.vo.bd.material.MaterialVO;
import nc.vo.bd.material.check.MaterialCheckVO;
import nc.vo.bd.material.check.MaterialRulerVO;
import nc.vo.bd.material.fi.MaterialFiVO;
import nc.vo.pub.BusinessException;
import nc.vo.pub.lang.UFDateTime;
import nc.vo.bd.material.plan.MaterialPlanVO;
import nc.vo.bd.material.prod.MaterialProdVO;
import nc.vo.bd.material.stock.MaterialStockVO;
import nc.ws.log.materiallog.MaterialLog;
import nc.ws.log.materiallog.MaterialLogAdd;
/**
* mhh 2020年5月6日11:36:06 物料校验规则处理类
*
* */
public class MaterialCheck {
private MaterialCheckService mc = new MaterialCheckService();
private String orgsql = "select distinct bd_marorg.pk_org from bd_marorg bd_marorg where bd_marorg.pk_material = '";
private List<Map<String,Object>> rulers = new ArrayList<Map<String,Object>>();;
private MaterialLog log = new MaterialLog();
private MaterialLogAdd logadd = new MaterialLogAdd();
@SuppressWarnings("static-access")
public void checkMaterialList(List<MaterialVO> materialList) throws BusinessException{
String sql = "select map(pk_psndoc,code) from bd_psndoc";
getPKs(sql);
/*if(materialList.size() <= 0 || materialList == null)
return;
Document doc = mc.getDoc();
this.rulers = getRulers(doc);
List<MaterialCheckVO> mchecklist = new ArrayList<MaterialCheckVO>();//建立回执信息VO链表，用来保存当前物料的校验信息
for(MaterialVO material : materialList){
MaterialCheckVO mcvo = new MaterialCheckVO();//保存物料校验结果
String pk_material = material.getPk_material();//当前物料PK
mcvo.setTs(new UFDateTime(System.currentTimeMillis()).toString());
mcvo.setMaterial_pk(pk_material);
mcvo.setMaterial_name(material.getName());
mcvo.setMaterial_code(material.getCode());
mcvo.setUsercode(InvocationInfoProxy.getInstance().getUserCode());
checkMaterialForRuler(material,mcvo);
mchecklist.add(mcvo);
}
for(int i = 0; i < mchecklist.size() ; i++){
//log.debug(mchecklist.get(i).toString());
logadd.addlog(mchecklist.get(i).toString());
nc.bs.logging.Logger.init("materialrule");
Logger.debug(mchecklist.get(i).toString());
Logger.init("materialrule");
Logger.debug(mchecklist.get(i).toString());
Logger.info(mchecklist.get(i).toString());
Logger S = new nc.bs.logging.Logger();
Logger.debug(mchecklist.get(i).toString());
}*/
}
/**
* mhh 2020年5月8日09:54:08 匹配当前物料属于哪种规则设置
* @param material
* @param doc
* @param mcvo
* @throws BusinessException
*/
@SuppressWarnings({ "unchecked", "static-access" })
private void checkMaterialForRuler(MaterialVO material, MaterialCheckVO mcvo) throws BusinessException {
String pk_marbasclass = material.getPk_marbasclass();
String marbascodesql = "select innercode from bd_marbasclass where pk_marbasclass = '"+pk_marbasclass+"'";
String marbascode = this.getSql(marbascodesql);//物料类型code
for(Map map : rulers){
if(map.get("pk_marbasclass") != null && marbascode.startsWith(map.get("pk_marbasclass").toString())){
//校验组织信息
checkOrg(material.getPk_material(),(Map<String, Object>) map.get("org"),mcvo);
//校验库存信息
checkStock(material,(Map<String, Object>) map.get("stock"),mcvo);
//校验计划信息
checkPlan(material,(Map<String, Object>) map.get("plan"),mcvo);
//校验生产信息
checkMaterialprod(material,(Map<String, Object>) map.get("prod"),mcvo);
//校验财务信息
checkMaterialFi(material ,(Map<String, Object>) map.get("fi"),mcvo);
break;
}
}
}
/**
* 校验物料的组织分配信息
* @throws BusinessException
*/
public void checkOrg(String pk_material,Map<String,Object> rule,MaterialCheckVO mcvo) throws BusinessException{
List<String> errmsg = mcvo.getErrmsg();
if(errmsg == null)
errmsg = new ArrayList<String>();
//获取当前物料已经分配的业务单元
String[] materialbusiness_org = this.getPKs("select distinct bd_marorg.pk_org from bd_marorg bd_marorg left join org_orgs on bd_marorg.pk_org = org_orgs.pk_org where org_orgs.pk_org <> org_orgs.pk_group and org_orgs.isbusinessunit = 'Y' and bd_marorg.pk_material ='"+pk_material+"'");
//获取当前物料已分配的成本域
String[] materialcost_org = this.getPKs("select distinct bd_marorg.pk_org from bd_marorg bd_marorg left join org_orgs on bd_marorg.pk_org = org_orgs.pk_org where org_orgs.pk_org <> org_orgs.pk_group and org_orgs.orgtype19 = 'Y' and bd_marorg.pk_material ='"+pk_material+"'");
//业务单元
String business_org = rule.get("business_org").toString();
//成本域
String cost_org = rule.get("cost_org").toString();
String[] business_orgs = null;//需要分配的业务单元
String[] cost_orgs = null;//需要分配的成本域
String businesssql = "SELECT pk_org FROM org_orgs WHERE (pk_group = '0001A1100000000008HW') and pk_group <> pk_org and (isbusinessunit = 'Y') and (enablestate = 2) and pk_group = '0001A1100000000008HW'";
String businesssql2 = "SELECT pk_org FROM org_orgs WHERE (pk_group = '0001A1100000000008HW') and pk_group <> pk_org and (orgtype19 = 'Y') and (enablestate = 2) and pk_group = '0001A1100000000008HW'";
if(business_org.equals("all")){
business_orgs = this.getPKs(businesssql);
}else{
String[] business = business_org.split(",");
businesssql += " and code in (";
for(int i = 0; i < business.length; i++){
if(i == 0)
businesssql += "'"+business[i]+"'";
else
businesssql += ",'"+business[i]+"'";
}
businesssql += ")";
business_orgs = this.getPKs(businesssql);
}
if(cost_org.equals("all")){
cost_orgs = this.getPKs(businesssql2);
}else{
String[] cost = cost_org.split(",");
businesssql2 += " and code in (";
for(int i = 0; i < cost.length; i++){
if(i == 0)
businesssql2 += "'"+cost[i]+"'";
else
businesssql2 += ",'"+cost[i]+"'";
}
businesssql2 += ")";
cost_orgs = this.getPKs(businesssql2);
}
//对四列数组进行排序
Arrays.sort(materialbusiness_org);
Arrays.sort(materialcost_org);
Arrays.sort(business_orgs);
Arrays.sort(cost_orgs);
String getOrgNameSql = "select name from org_orgs where pk_org = '";
if(!Arrays.equals(materialbusiness_org, business_orgs)){//处理业务单元错误信息
mcvo.setIsnormal(false);
String businessOrgErr = getErrMsg(business_orgs,materialbusiness_org,getOrgNameSql,"分配组织业务单元");
errmsg.add(businessOrgErr);
}
if(!Arrays.equals(materialcost_org, cost_orgs)){//处理成本域错误信息
mcvo.setIsnormal(false);
String costOrgErr = getErrMsg(cost_orgs,materialcost_org,getOrgNameSql,"分配组织成本域");
errmsg.add(costOrgErr);
}
mcvo.setErrmsg(errmsg);
}
/**
* mhh 2020年5月8日08:47:15 对物料库存信息的校验。
* @param pk_material
* @param doc
* @param mcvo
* @throws BusinessException
*/
@SuppressWarnings("unchecked")
private void checkStock(MaterialVO material,Map<String,Object> map,MaterialCheckVO mcvo) throws BusinessException{
String getOrgIDs = "select pk_org from bd_materialstock where pk_material = '"+material.getPk_material()+"'";
//获取当前物料的所有库存信息相关的库存组织
String[] orgIDs = this.getPKs(getOrgIDs);
IMaterialStockQueryService service = ((IMaterialStockQueryService)NCLocator.getInstance().lookup(IMaterialStockQueryService.class));
MaterialStockVO[] stockVOs = service.queryMaterialStockVOs(orgIDs, material.getPk_material());
//获取物料类型规则
Map<String,Object> martypes = (Map<String, Object>) map.get("martypes");
//校验物料类型
checkMaterialMartype(martypes,stockVOs,mcvo);
//获取批次管理类型规则
Map<String,Object> wholemanaflags = (Map<String, Object>) map.get("wholemanaflags");
//校验批次管理
checkWholemanaflag(wholemanaflags,stockVOs,mcvo);
//获取供货库存组织类型规则
Map<String,Object> pk_suplystockorgs = (Map<String, Object>) map.get("pk_suplystockorgs");
//校验供货库存组织规则
checkPk_suplystockorgs(pk_suplystockorgs,stockVOs,mcvo);
//获取根据检验结果入库规则
Map<String,Object> stockbychecks = (Map<String, Object>) map.get("stockbychecks");
//校验根据检验结果入库规则
checkStockbychecks(stockbychecks,stockVOs,mcvo);
//获取根据检验结果入库规则
Map<String,Object> chkfreeflags = (Map<String, Object>) map.get("chkfreeflags");
//校验根据检验结果入库规则
checkChkfreeflags(chkfreeflags,stockVOs,mcvo);
}
/**
* mhh 2020年5月9日17:35:35 校验物料计划信息
* @param material
* @param map
* @param mcvo
* @throws BusinessException
*/
@SuppressWarnings("unchecked")
private void checkPlan(MaterialVO material, Map<String, Object> map,
MaterialCheckVO mcvo) throws BusinessException {
String getOrgIDs = "select pk_org from bd_materialplan where pk_material = '"+material.getPk_material()+"'";
//获取当前物料的所有库存信息相关的库存组织
String[] orgIDs = this.getPKs(getOrgIDs);
IMaterialPlanQueryService service = ((IMaterialPlanQueryService)NCLocator.getInstance().lookup(IMaterialPlanQueryService.class));
MaterialPlanVO[] planvos = service.queryMaterialPlanVOs(orgIDs, material.getPk_material());
//获取计划属性规则
Map<String,Object> planprops = (Map<String, Object>) map.get("planprops");
//校验物料类型
checkMaterialPlanprops(planprops,planvos,mcvo);
}
/**
* mhh 2020年5月11日09:25:07 校验物料生产信息规则
* @param material
* @param map
* @param mcvo
* @throws BusinessException
*/
private void checkMaterialprod(MaterialVO material,
Map<String, Object> map, MaterialCheckVO mcvo) throws BusinessException {
String getOrgIDs = "select pk_org from bd_materialprod where pk_material = '" + material.getPk_material() + "'";
String[] orgIDs = this.getPKs(getOrgIDs);
IMaterialProdQueryService service = ((IMaterialProdQueryService)NCLocator.getInstance().lookup(IMaterialProdQueryService.class));
MaterialProdVO[] prodvos = service.queryMaterialProdVOs(orgIDs, material.getPk_material());
//获取生产模式规则
Map<String, Object> prodmodes = (Map<String, Object>) map.get("prodmodes");
//生产信息生产模式规则校验
checkMaterialProdmodes(prodmodes, prodvos, mcvo);
//获取物料形态规则
Map<String, Object> materstates = (Map<String, Object>) map.get("materstates");
//成产信息物料形态规则校验
checkMaterialMaterstates(materstates, prodvos, mcvo);
}
/**
* mhh 2020年5月11日11:20:39 校验物料财务信息规则
* @param material
* @param map
* @param mcvo
* @throws BusinessException
*/
private void checkMaterialFi(MaterialVO material, Map<String, Object> map,
MaterialCheckVO mcvo) throws BusinessException {
String getOrgIDs = "select pk_org from bd_materialfi where pk_material = '" + material.getPk_material() + "'";
String[] orgIDs = this.getPKs(getOrgIDs);
IMaterialFiQueryService service = ((IMaterialFiQueryService)NCLocator.getInstance().lookup(IMaterialFiQueryService.class));
MaterialFiVO[] fivos = service.queryMaterialFiVOs(orgIDs, material.getPk_material());
//获取实物物料价值管理模式规则
Map<String, Object> materialvaluemgts = (Map<String, Object>) map.get("materialvaluemgts");
//实物物料价值管理模式规则校验
checkMaterialMvaluemgts(materialvaluemgts,fivos,mcvo);
}
/**
* mhh 2020年5月11日11:25:51 财务信息实物物料价值管理模式校验规则
* @param materialvaluemgts
* @param fivos
* @param mcvo
* @throws BusinessException
*/
private void checkMaterialMvaluemgts(Map<String, Object> materialvaluemgts,
MaterialFiVO[] fivos, MaterialCheckVO mcvo) throws BusinessException {
if(materialvaluemgts == null || materialvaluemgts.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialFiVO vo : fivos){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getMaterialvaluemgt().toString();
list.add(map);
}
checkCurrency(materialvaluemgts,list,mcvo,"materialvaluemgt0","fiorg","materialvaluemgtcode","财务信息实物物料价值管理模式出错的库存组织:","fi");
}
/**
* mhh 2020年5月11日11:03:07 生产信息物料形态校验
* @param materstates
* @param prodvos
* @param mcvo
* @throws BusinessException
*/
private void checkMaterialMaterstates(Map<String, Object> materstates,
MaterialProdVO[] prodvos, MaterialCheckVO mcvo) throws BusinessException {
if(materstates == null || materstates.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialProdVO vo : prodvos){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getMaterstate().toString();
list.add(map);
}
checkCurrency(materstates,list,mcvo,"materstate0","prodorg","prodmaterstatecode","生产信息物料形态出错的库存组织:","prod");
}
/**
* mhh 2020年5月11日09:33:04 生产信息中生产模式的规则校验
* @param prodmodes
* @param prodvos
* @param mcvo
* @throws BusinessException
*/
private void checkMaterialProdmodes(Map<String, Object> prodmodes,
MaterialProdVO[] prodvos, MaterialCheckVO mcvo) throws BusinessException {
if(prodmodes == null || prodmodes.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialProdVO vo : prodvos){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getProdmode().toString();
list.add(map);
}
checkCurrency(prodmodes,list,mcvo,"prodmode0","prodorg","prodmodecode","生产信息生产模式出错的库存组织:","prod");
}
/**
* mhh 2020年5月9日17:50:22 校验计划信息中计划书型规则
* @param planprops
* @param planvos
* @param mcvo
* @throws BusinessException
*/
private void checkMaterialPlanprops(Map<String, Object> planprops,
MaterialPlanVO[] planvos, MaterialCheckVO mcvo) throws BusinessException {
if(planprops == null || planprops.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialPlanVO vo : planvos){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getPlanprop();
list.add(map);
}
checkCurrency(planprops,list,mcvo,"planprop0","planorg","planpropcode","计划信息计划属性出错的库存组织:","plan");
}
/**
* mhh 2020年5月9日17:42:18 免检规则校验
* @param chkfreeflags
* @param stockVOs
* @param mcvo
* @throws BusinessException
*/
private void checkChkfreeflags(Map<String, Object> chkfreeflags,
MaterialStockVO[] stockVOs, MaterialCheckVO mcvo) throws BusinessException {
if(chkfreeflags == null || chkfreeflags.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialStockVO vo : stockVOs){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getChkfreeflag().toString();
list.add(map);
}
checkCurrency(chkfreeflags,list,mcvo,"chkfreeflag0","stockorg","chkfreeflagcode","库存信息免检出错的库存组织:","stock");
}
/**
* mhh 2020年5月9日17:22:20 库存信息根据检验结果入库规则
* @param stockbychecks
* @param stockVOs
* @param mcvo
* @throws BusinessException
*/
private void checkStockbychecks(Map<String, Object> stockbychecks,
MaterialStockVO[] stockVOs, MaterialCheckVO mcvo) throws BusinessException {
if(stockbychecks == null || stockbychecks.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialStockVO vo : stockVOs){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getStockbycheck().toString();
list.add(map);
}
checkCurrency(stockbychecks,list,mcvo,"stockbycheck0","stockorg","stockbycheckcode","库存信息根据检验结果入库出错的库存组织:","stock");
}
/**
* mhh 2020年5月9日16:28:48 校验供货库存组织规则
* @param pk_suplystockorgs
* @param stockVOs
* @param mcvo
* @throws BusinessException
*/
private void checkPk_suplystockorgs(Map<String, Object> pk_suplystockorgs,
MaterialStockVO[] stockVOs, MaterialCheckVO mcvo) throws BusinessException {
if(pk_suplystockorgs == null || pk_suplystockorgs.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialStockVO vo : stockVOs){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getPk_suplystockorg();
list.add(map);
}
checkCurrency(pk_suplystockorgs,list,mcvo,"pk_suplystockorg0","stockorg","pk_suplystockorgcode","库存信息供货库存组织出错的库存组织:","stock");
}
/**
* mhh 2020年5月9日15:23:48 校验库存信息-批次管理规则
* @param martypes
* @param stockVOs
* @param mcvo
* @throws BusinessException
*/
private void checkWholemanaflag(Map<String, Object> wholemanaflags,MaterialStockVO[] stockVOs, MaterialCheckVO mcvo) throws BusinessException {
if(wholemanaflags == null || wholemanaflags.size() == 0)
return;
List<String[]> list = new ArrayList<String[]>();
for(MaterialStockVO vo : stockVOs){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getWholemanaflag().toString();
list.add(map);
}
checkCurrency(wholemanaflags,list,mcvo,"wholemanaflag0","stockorg","wholemanaflagcode","库存信息批次管理出错的库存组织:","stock");
}
/**
* mhh 2020年5月9日10:51:40 校验库存信息中的物料类型,如果规则map只有all规则，则统一校验；或者分步校验，先单独设置，剩下的以others为规则设置
* @throws BusinessException
*/
@SuppressWarnings({ "unchecked", "static-access" })
private void checkMaterialMartype(Map<String,Object> martypes,MaterialStockVO[] stockVOs,MaterialCheckVO mcvo) throws BusinessException {
if(martypes == null || martypes.size() == 0)
return;
/*List<MaterialStockVO> errvo = new ArrayList<MaterialStockVO>();
//将库存信息类数组转化为list链表，装载除去已经匹配的剩下的类
List<MaterialStockVO> others =new ArrayList<MaterialStockVO>(Arrays.asList(stockVOs));
for(int i = 0; i < martypes.size(); i++){
Map<String,String> rule = (Map<String, String>) martypes.get("martype0"+(i+1));
String stockorg = rule.get("stockorg");
String martypecode = rule.get("martypecode");
if(stockorg!=null&&stockorg.equals("all")&&martypes.size()<=1&&martypecode!=null){//全规则,只设置一种规则的情况,如果规则长度大于1，且包含all规则，则报错
for(MaterialStockVO vo : stockVOs){
if(vo.getMartype()==null)
errvo.add(vo);
else if(!vo.getMartype().equals(martypecode))
errvo.add(vo);
}
}else if(stockorg!=null&&martypecode!=null&&!stockorg.equals("others")&&martypes.size() > 1){//分步规则，将库存组织分开匹配规则
List<String> orgs = Arrays.asList(stockorg.split(","));
for(MaterialStockVO vo : stockVOs){
if(orgs.contains(vo.getPk_org())&&(!vo.getMartype().equals(martypecode)||vo.getMartype() == null))
errvo.add(vo);
if(orgs.contains(vo.getPk_org()))
others.remove(vo);
}
}else if(stockorg!=null&&martypecode!=null&&stockorg.equals("others")){//others 分步剩下的组织统一设置
for(MaterialStockVO vo : others){
if(!vo.getMartype().equals(martypecode)||vo.getMartype() == null)
errvo.add(vo);
}
}else{
MessageDialog.showErrorDlg(null, "错误！", "规则文件库存信息物料类型规则配置错误，请修改后执行！");
return;
}
}
if(errvo.size() > 0){
String errmsg = "库存信息物料类型出错的库存组织:";
for(MaterialStockVO vo : errvo){
errmsg += this.getSql("select name from org_stockorg where pk_stockorg = '"+vo.getPk_org()+"'") +" ";
}
List<String> errlist = mcvo.getErrmsg();
errlist.add(errmsg);
mcvo.setErrmsg(errlist);
}*/
List<String[]> list = new ArrayList<String[]>();
for(MaterialStockVO vo : stockVOs){
String[] map = new String[2];
map[0] = vo.getPk_org();
map[1] = vo.getMartype();
list.add(map);
}
checkCurrency(martypes,list,mcvo,"martype0","stockorg","martypecode","库存信息物料类型出错的库存组织:","stock");
}
/**
* mhh 2020年5月9日15:54:08 带all\others的通用校验方法
* @throws BusinessException
*/
@SuppressWarnings({ "unused", "static-access" })
private void checkCurrency(Map<String, Object> ruleMaps,List<String[]> stocklist, MaterialCheckVO mcvo,String parentRule,String firstRule,String secondRule,String errmsg,String page) throws BusinessException{
List<String[]> errvo = new ArrayList<String[]>();
//将库存信息类数组转化为list链表，装载除去已经匹配的剩下的类
List<String[]> others = new ArrayList<String[]>(stocklist);
for(int i = 0; i < ruleMaps.size(); i++){
Map<String,String> rule = (Map<String, String>) ruleMaps.get(parentRule+(i+1));
String stockorg = rule.get(firstRule);
String martypecode = rule.get(secondRule);
if(stockorg!=null&&stockorg.equals("all")&&ruleMaps.size()<=1&&martypecode!=null){//全规则,只设置一种规则的情况,如果规则长度大于1，且包含all规则，则报错
for(String[] vo : stocklist){
if(vo[1]==null)
errvo.add(vo);
else if(!vo[1].equals(martypecode))
errvo.add(vo);
}
}else if(stockorg!=null&&martypecode!=null&&!stockorg.equals("others")&&ruleMaps.size() > 1){//分步规则，将库存组织分开匹配规则
List<String> orgs = Arrays.asList(stockorg.split(","));
for(String[] vo : stocklist){
if(orgs.contains(vo[0])&&(!vo[1].equals(martypecode)||vo[1] == null))
errvo.add(vo);
if(orgs.contains(vo[0]))
others.remove(vo);
}
}else if(stockorg!=null&&martypecode!=null&&stockorg.equals("others")){//others 分步剩下的组织统一设置
for(String[] vo : others){
if(!vo[1].equals(martypecode)||vo[1] == null)
errvo.add(vo);
}
}else{
MessageDialog.showErrorDlg(null, "错误！", "规则文件规则配置错误，请修改后执行！");
return;
}
}
if(errvo.size() > 0){
mcvo.setIsnormal(false);
if(page.equals("stock")){
for(String[] vo : errvo){
errmsg += this.getSql("select name from org_stockorg where pk_stockorg = '"+vo[0]+"'") +" ";
}
}else if(page.equals("plan")){
for(String[] vo : errvo){
errmsg += this.getSql("select name from org_orgs where pk_org = '"+vo[0]+"'") +" ";
}
}else if(page.equals("prod")){
for(String[] vo : errvo){
errmsg += this.getSql("select name from org_factory where pk_factory = '"+vo[0]+"'") +" ";
}
}else if(page.equals("fi")){
for(String[] vo : errvo){
errmsg += this.getSql("select name from org_financeorg where pk_financeorg = '"+vo[0]+"'") +" ";
}
}
List<String> errlist = mcvo.getErrmsg();
errlist.add(errmsg);
mcvo.setErrmsg(errlist);
}
}
/**
* mhh 2020年5月7日15:16:42 处理两个组织数组的差集
*
* */
@SuppressWarnings("static-access")
private String getErrMsg(String[] aa,String[] bb,String getOrgNameSql,String costOrgErr) throws BusinessException{
//用来装多余的差集
List<String> resultMore = new ArrayList<String>();
//用来装载缺少的差集
List<String> resultLess = new ArrayList<String>();
List<String> listLess = Arrays.asList(bb);
for(String a : aa){
//判断是否包含
if(!listLess.contains(a)){
resultLess.add(a);
}
}
List<String> listMore = Arrays.asList(aa);
for(String a : bb){
//判断是否包含
if(!listMore.contains(a)){
resultMore.add(a);
}
}
if(resultMore.size()>0){
for(int i = 0;i < resultMore.size(); i++){
if(i == 0){
costOrgErr +="多余:";
costOrgErr += this.getSql(getOrgNameSql+resultMore.get(i)+"'");
}else{
costOrgErr += ","+this.getSql(getOrgNameSql+resultMore.get(i)+"'");
}
}
}
if(resultLess.size()>0){
for(int i = 0;i < resultLess.size(); i++){
if(i == 0){
costOrgErr +="\t缺少:";
costOrgErr += this.getSql(getOrgNameSql+resultLess.get(i)+"'");
}else{
costOrgErr += ","+this.getSql(getOrgNameSql+resultLess.get(i)+"'");
}
}
}
return costOrgErr;
}
/**
* mhh 2020年5月8日11:59:24 获取所有的规则放进链表
* @param doc
* @return
*/
public List<Map<String,Object>> getRulers(Document doc){
NodeList nodes = doc.getElementsByTagName("rule");
for(int i = 0; i < nodes.getLength(); i++){
Map<String,Object> ruleMap = new HashMap<String,Object>();
//遍历获取每一个规则项
Node ruler = nodes.item(i);
//通过Node对象的getAttributes()方法获取全的属性值 此方法是获取文件中标签属性
/*NamedNodeMap ruleMap = ruler.getAttributes();
for(int j = 0; j < ruleMap.getLength(); j++){
Node node = ruleMap.item(j);
System.out.print(node.getNodeName());
System.out.println(node.getNodeValue());
}*/
NodeList childrenList = ruler.getChildNodes();
ruleMap = getRulerMap(childrenList, ruleMap);
rulers.add(ruleMap);
}
return rulers;
}
/**
* mhh 2020年5月8日14:49:50 递归获取xml文件中的标签名和其对用的值
* @param sql
* @return
* @throws BusinessException
*/
public Map<String,Object> getRulerMap(NodeList nodes,Map<String,Object> map){
for(int i = 0; i < nodes.getLength(); i++){
if(nodes.item(i).getNodeType() == Node.ELEMENT_NODE){
if(nodes.item(i).hasChildNodes() && nodes.item(i).getChildNodes().getLength() > 1){
//map = getRulerMap(nodes.item(i).getChildNodes(), map);
map.put(nodes.item(i).getNodeName(),getRulerMap(nodes.item(i).getChildNodes(),new HashMap<String,Object>()));
}else{
map.put(nodes.item(i).getNodeName(), nodes.item(i).getTextContent());
}
}
}
return map;
}
private String[] getPKs(String sql) throws BusinessException {
IUAPQueryBS uapQuery = (IUAPQueryBS) NCLocator.getInstance().lookup(nc.itf.uap.IUAPQueryBS.class);
List<?> list = (List<?>) uapQuery.executeQuery(sql, new ArrayListProcessor());
if (list == null || list.size() == 0) {
return null;
}
String[] pks = new String[list.size()];
for(int i = 0; i < list.size();i++){
pks[i] = ((Object[])list.get(i))[0].toString();
}
return pks;
}
// 通过sql语句 获取结果集
private static String getSql(String sql) throws BusinessException {
IUAPQueryBS uapQuery = (IUAPQueryBS) NCLocator.getInstance().lookup(nc.itf.uap.IUAPQueryBS.class);
List<?> userList = (List<?>) uapQuery.executeQuery(sql, new ArrayListProcessor());
if (userList == null || userList.size() == 0) {
return null;
}
Object[] obj = (Object[]) userList.get(0);
if (obj[0] == null) {
return null;
}
String result = obj[0].toString();
return result;
}
}
nc物料检验规则
最新推荐文章于 2023-03-28 18:44:10 发布
扫一扫
1440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
