diff --git a/mmpac/src/client/nccloud/web/mmpac/pickm/query/PickmItemsQuery.java b/mmpac/src/client/nccloud/web/mmpac/pickm/query/PickmItemsQuery.java new file mode 100644 index 0000000..6d6c040 --- /dev/null +++ b/mmpac/src/client/nccloud/web/mmpac/pickm/query/PickmItemsQuery.java @@ -0,0 +1,63 @@ +package nccloud.web.mmpac.pickm.query; + +import nc.itf.mmpac.pickm.IPickmQueryService; +import nc.util.mmf.framework.base.MMValueCheck; +import nc.vo.mmpac.pickm.consts.PickmLangConsts; +import nc.vo.mmpac.pickm.entity.PickmItemVO; +import nccloud.dto.mmpac.pickm.pub.entity.PickmQueryInfoDTO; +import nccloud.framework.core.exception.ExceptionUtils; +import nccloud.framework.core.json.IJson; +import nccloud.framework.service.ServiceLocator; +import nccloud.framework.web.container.IRequest; +import nccloud.framework.web.convert.translate.Translator; +import nccloud.framework.web.json.JsonFactory; +import nccloud.framework.web.ui.pattern.grid.Grid; +import nccloud.framework.web.ui.pattern.grid.GridOperator; +import nccloud.web.mmpac.pickm.util.PickmScaleUtil; +import nccloud.web.mmpub.pub.action.NCCTempletQueryAction; + +/** + * 备料计划-借料入库弹窗查询 + * + * @author mzr + * @date 2025/7/8 + */ +public class PickmItemsQuery { + public Object doAction(IRequest request) { + String read = request.read(); + IJson json = JsonFactory.create(); + PickmQueryInfoDTO queryInfo = json.fromJson(read, PickmQueryInfoDTO.class); + try { + String[] cpickmbids = queryInfo.getCpickmbids(); + if (null != cpickmbids && cpickmbids.length != 0) { + IPickmQueryService service = ServiceLocator.find(IPickmQueryService.class); + PickmItemVO[] itemVOS = service.queryItemsByIds(cpickmbids); + if (MMValueCheck.isEmpty(itemVOS)) { + ExceptionUtils.wrapBusinessException(PickmLangConsts.getHIT_BODYNOTNULL()); + } + + GridOperator operator = new GridOperator(queryInfo.getPageid()); + if (MMValueCheck.isNotEmpty(queryInfo.getAppcode())) { + String templetid = NCCTempletQueryAction.getTempletIdByAppCode(queryInfo.getAppcode(), queryInfo.getPageid()); + operator = new GridOperator(templetid, queryInfo.getPageid()); + } + + Grid grid = operator.toGrid(itemVOS); + Translator translator = new Translator(); + translator.translate(grid); + this.afterProcess(grid); + return grid; + } else { + return null; + } + } catch (Exception ex) { + ExceptionUtils.wrapBusinessException(ex.getMessage()); + return null; + } + } + + public void afterProcess(Grid grid) { + PickmScaleUtil scaleUtil = new PickmScaleUtil(); + scaleUtil.processHeadBodyGrid(grid); + } +} diff --git a/mmpac/src/client/yyconfig/modules/mmpac/pickm/config/action/pickm_query.xml b/mmpac/src/client/yyconfig/modules/mmpac/pickm/config/action/pickm_query.xml new file mode 100644 index 0000000..5be371f --- /dev/null +++ b/mmpac/src/client/yyconfig/modules/mmpac/pickm/config/action/pickm_query.xml @@ -0,0 +1,74 @@ + + + + mmpac.pickm.transtypeQuery + + nccloud.web.mmpac.pickm.query.PickmTranstypeQuery + + + mmpac.pickm.clquery + + nccloud.web.mmpac.pickm.query.PickmCLQuery + + + mmpac.pickm.setdeliverquery + + nccloud.web.mmpac.pickm.query.PickmSetDeliverQuery + + + mmpac.pickm.setdelivercheck + + nccloud.web.mmpac.pickm.query.PickmSetDeliverCheck + + + mmpac.pickm.backdeliverquery + + nccloud.web.mmpac.pickm.query.PickmBackDeliverQuery + + + + mmpac.pickm.PickmMatchCodeRef + + nccloud.web.mmpac.pickm.ref.PickmMatchCodeRef + + + mmpac.pickm.takeoverquery + + nccloud.web.mmpac.pickm.query.PickmTakeOverQuery + + + mmpac.pickm.setbackdeliverquery + + nccloud.web.mmpac.pickm.query.PickmSetBackDeliverQuery + + + mmpac.pickm.PickmSerialNoRef + + nccloud.web.mmpac.pickm.ref.PickmSerialNoRef + + + mmpac.pickm.noitemdeliverquery + + nccloud.web.mmpac.pickm.query.PickmNoItemDeliverQuery + + + mmpac.pickm.replaceQuery + + nccloud.web.mmpac.pickm.query.PickmReplaceQuery + + + mmpac.pickm.replaceBodyQuery + + nccloud.web.mmpac.pickm.query.PickmReplaceBodyQuery + + + mmpac.pickm.transtypeExtQuery + + nccloud.web.mmpac.pickm.transtype.action.PickmTransTypeExtQuery + + + mmpac.pickm.pickmItemsQuery + + nnccloud.web.mmpac.pickm.query.PickmItemsQuery + + \ No newline at end of file diff --git a/mmpac/src/private/nc/impl/mmpac/pickm/PickmQueryServiceImpl.java b/mmpac/src/private/nc/impl/mmpac/pickm/PickmQueryServiceImpl.java new file mode 100644 index 0000000..a312cd8 --- /dev/null +++ b/mmpac/src/private/nc/impl/mmpac/pickm/PickmQueryServiceImpl.java @@ -0,0 +1,315 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package nc.impl.mmpac.pickm; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import nc.bs.mmpac.pickm.adapter.OnHandServiceAdapter; +import nc.bs.mmpac.pickm.adapter.OrgServiceAdapter; +import nc.bs.mmpac.pickm.adapter.TransTypeServiceAdapter; +import nc.bs.mmpac.pickm.bp.query.PickmQueryBillsByPKsBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryByBidsBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryByPermBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryBySchemeBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryByWhereSqlBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryItemsByPKsBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryMOInfoBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryMatSumPlanOutNumBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryMaterialVersionVOBP; +import nc.bs.mmpac.pickm.bp.query.PickmQueryRelationItemForHeadBP; +import nc.bs.mmpac.pickm.bp.query.PickmQuerySCOrderStockBP; +import nc.itf.mmpac.pickm.IPickmQueryService; +import nc.ui.querytemplate.querytree.IQueryScheme; +import nc.util.mmf.busi.service.DeptPubService; +import nc.util.mmf.busi.service.OrgUnitPubService; +import nc.util.mmf.framework.base.MMStringUtil; +import nc.util.mmf.framework.base.MMValueCheck; +import nc.vo.bd.material.MaterialVersionVO; +import nc.vo.mmpac.pickm.entity.AggPickmVO; +import nc.vo.mmpac.pickm.entity.MaterialQueryCondition; +import nc.vo.mmpac.pickm.entity.MaterialRelationItem; +import nc.vo.mmpac.pickm.entity.PickmHeadVO; +import nc.vo.mmpac.pickm.entity.PickmItemVO; +import nc.vo.mmpac.pickm.entity.PickmTransTypeVO; +import nc.vo.mmpac.pickm.param.PickmParamForAdd; +import nc.vo.mmpac.pickm.param.PickmQueryMOParamForSetDelivery; +import nc.vo.mmpac.pickm.param.PickmTransParamForPlanReplace; +import nc.vo.pub.BusinessException; +import nc.vo.pub.lang.UFBoolean; +import nc.vo.pubapp.pattern.exception.ExceptionUtils; +import nc.vo.pubapp.pattern.pub.MapList; + +public class PickmQueryServiceImpl implements IPickmQueryService { + public PickmQueryServiceImpl() { + } + + public Object[] queryByWhereSql(String whereSql, Class clazz, boolean lazyLoad, String[] orderPaths) throws BusinessException { + try { + PickmQueryByWhereSqlBP bp = new PickmQueryByWhereSqlBP(); + return bp.queryByWhereSql(whereSql, clazz, lazyLoad, orderPaths); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public Object[] queryByWhereSql(String whereSql) throws BusinessException { + try { + PickmQueryByWhereSqlBP bp = new PickmQueryByWhereSqlBP(); + return bp.queryByWhereSql(whereSql); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public AggPickmVO querySingleBillByPk(String primaryKey) throws BusinessException { + try { + AggPickmVO[] aggvos = this.queryBillsByPks(new String[]{primaryKey}); + return MMValueCheck.isEmpty(aggvos) ? null : aggvos[0]; + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public AggPickmVO[] queryBillsByPks(String[] primaryKeys) throws BusinessException { + try { + PickmQueryBillsByPKsBP pickmQueryBillsByPKsBP = new PickmQueryBillsByPKsBP(); + return pickmQueryBillsByPKsBP.queryBillsByPks(primaryKeys); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public MaterialRelationItem queryRelationItemForHead(MaterialQueryCondition condition) throws BusinessException { + try { + PickmQueryRelationItemForHeadBP bp = new PickmQueryRelationItemForHeadBP(); + return bp.queryRelationItemForHead(condition); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public Map queryMaterialVersionVOByPks(String[] pks) throws BusinessException { + try { + PickmQueryMaterialVersionVOBP bp = new PickmQueryMaterialVersionVOBP(); + return bp.getMaterialVersionVOByPks(pks); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public AggPickmVO[] queryByQueryScheme(IQueryScheme queryScheme, Integer prodmode) throws BusinessException { + try { + PickmQueryBySchemeBP bp = new PickmQueryBySchemeBP(); + return bp.queryByQueryScheme(queryScheme, prodmode); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public PickmItemVO queryPickmItemByPK(String pk) throws BusinessException { + if (MMStringUtil.isEmpty(pk)) { + return null; + } else { + PickmQueryItemsByPKsBP bp = new PickmQueryItemsByPKsBP(); + PickmItemVO[] itemVOs = null; + + try { + itemVOs = bp.queryItemsByPks(new String[]{pk}); + } catch (Exception e) { + ExceptionUtils.marsh(e); + } + + return MMValueCheck.isEmpty(itemVOs) ? null : itemVOs[0]; + } + } + + public Map queryHasDownFlowBill(String[] pks) throws BusinessException { + return null; + } + + public Map> queryNeededData(AggPickmVO[] aggVOs) throws BusinessException { + return null; + } + + public AggPickmVO[] queryPermData(AggPickmVO[] aggVOs) throws BusinessException { + return (new PickmQueryByPermBP()).queryByPerm(aggVOs); + } + + public Map queryAcceptLowerData(PickmHeadVO headvo, PickmItemVO bodyvo) throws BusinessException { + return null; + } + + public Map queryUnAcceptLowerData(String cpickm_bid) throws BusinessException { + return null; + } + + public String querySCOrderStock(String sourceBillbid, String pk_group) throws BusinessException { + try { + PickmQuerySCOrderStockBP bp = new PickmQuerySCOrderStockBP(); + return bp.querySCOrderStock(sourceBillbid, pk_group); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public Map queryMOInfo(String[] ids, boolean isFromPMO) throws BusinessException { + try { + PickmQueryMOInfoBP bp = new PickmQueryMOInfoBP(); + return bp.queryMOInfo(ids, isFromPMO); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public PickmTransParamForPlanReplace[] queryMatSumPlanOutNumFromSameFirstBill(PickmTransParamForPlanReplace[] queryParams) throws BusinessException { + try { + PickmQueryMatSumPlanOutNumBP bp = new PickmQueryMatSumPlanOutNumBP(); + return bp.queryMatSumPlanOutNumWithSameSource(queryParams); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public Object[] queryPSCPickmByQueryScheme(IQueryScheme queryScheme) throws BusinessException { + try { + PickmQueryBySchemeBP bp = new PickmQueryBySchemeBP(); + return bp.queryPSCPickmByQueryScheme(queryScheme); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public Map queryIsHavePSCitemsByRowIDs(String[] rowIDs) throws BusinessException { + if (MMValueCheck.isEmpty(rowIDs)) { + return null; + } else { + PickmQueryByBidsBP bp = new PickmQueryByBidsBP(); + return bp.getIsHavePSCitemByRowIDs(rowIDs); + } + } + + public Map queryVidByOidForOrgAndDept(List orgids, List deptids) throws BusinessException { + Map result = new HashMap(); + if (MMValueCheck.isNotEmpty(orgids)) { + Map omap = OrgServiceAdapter.getOrgVIDsByOrgIDs((String[]) orgids.toArray(new String[0])); + if (MMValueCheck.isNotEmpty(omap)) { + for (String key : omap.keySet()) { + result.put("O" + key, (String) omap.get(key)); + } + } + } + + if (MMValueCheck.isNotEmpty(deptids)) { + Map dmap = DeptPubService.getIDeptPubService().getLastVIDSByDeptIDS((String[]) deptids.toArray(new String[0])); + if (MMValueCheck.isNotEmpty(dmap)) { + for (String key : dmap.keySet()) { + result.put("D" + key, (String) dmap.get(key)); + } + } + } + + return result; + } + + public PickmParamForAdd queryOrgvidAndTransinfForAdd(String pk_org, String pk_group) throws BusinessException { + PickmParamForAdd param = new PickmParamForAdd(); + if (MMValueCheck.isNotEmpty(pk_org)) { + String pk_org_v = OrgUnitPubService.getNewVIDByOrgID(pk_org); + param.setPk_org_v(pk_org_v); + } + + if (MMValueCheck.isNotEmpty(pk_group)) { + StringBuffer wherePart = new StringBuffer(); + wherePart.append(" and fpickmtype=1"); + wherePart.append(" and pk_group='"); + wherePart.append(pk_group); + wherePart.append("'"); + wherePart.append(" and ctrantypeid in (select pk_billtypeid from bd_billtype where parentbilltype = '55A3' and islock='N')"); + + try { + PickmTransTypeVO[] transVOs = TransTypeServiceAdapter.queryTranstypeExtProp(wherePart.toString()); + if (MMValueCheck.isNotEmpty(transVOs) && MMValueCheck.isNotEmpty(transVOs[0])) { + param.setTransID(transVOs[0].getCtrantypeid()); + param.setTransCode(transVOs[0].getVtrantypecode()); + } + } catch (Exception e) { + ExceptionUtils.wrappException(e); + } + + return param; + } else { + return null; + } + } + + public PickmHeadVO[] queryHeadByIds(String[] cpickmids) throws BusinessException { + if (MMValueCheck.isEmpty(cpickmids)) { + return null; + } else { + try { + PickmQueryByBidsBP bp = new PickmQueryByBidsBP(); + return bp.queryByHeadIDs(cpickmids); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + } + + public PickmItemVO[] queryCLItemsForNcc(String cpickmid, String[] cpickmbids) throws BusinessException { + PickmItemVO[] items = null; + PickmQueryItemsByPKsBP queryBP = new PickmQueryItemsByPKsBP(); + if (MMValueCheck.isEmpty(cpickmid)) { + items = queryBP.queryItemsByPks(cpickmbids); + } else { + items = queryBP.queryItemsByHeadPks(new String[]{cpickmid}); + } + + return MMValueCheck.isEmpty(items) ? null : this.fillCLItemsForNcc(items); + } + + public AggPickmVO[] queryAggPickmVObyBid(String[] cpickmbids) throws BusinessException { + PickmQueryByBidsBP bp = new PickmQueryByBidsBP(); + return bp.queryAggPickmVObyBids(cpickmbids); + } + + public PickmItemVO[] fillCLItemsForNcc(PickmItemVO[] items) throws BusinessException { + return OnHandServiceAdapter.fillCLItemsForNcc(items); + } + + public MapList getReplaceGroupItemByKeyID(String[] bids, String hid) throws BusinessException { + PickmQueryByBidsBP bp = new PickmQueryByBidsBP(); + return bp.getReplaceGroupItemByKeyID(bids, hid); + } + + public PickmItemVO[] queryItemsByIds(String[] itemIds) throws BusinessException { + if (MMValueCheck.isEmpty(itemIds)) { + return null; + } else { + try { + PickmQueryItemsByPKsBP queryBP = new PickmQueryItemsByPKsBP(); + return queryBP.queryItemsByPks(itemIds); + } catch (Exception e) { + ExceptionUtils.marsh(e); + return null; + } + } + + } +} diff --git a/mmpac/src/public/nc/itf/mmpac/pickm/IPickmQueryService.java b/mmpac/src/public/nc/itf/mmpac/pickm/IPickmQueryService.java new file mode 100644 index 0000000..9488bb4 --- /dev/null +++ b/mmpac/src/public/nc/itf/mmpac/pickm/IPickmQueryService.java @@ -0,0 +1,77 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package nc.itf.mmpac.pickm; + +import java.util.List; +import java.util.Map; + +import nc.ui.querytemplate.querytree.IQueryScheme; +import nc.vo.bd.material.MaterialVersionVO; +import nc.vo.mmpac.pickm.entity.AggPickmVO; +import nc.vo.mmpac.pickm.entity.MaterialQueryCondition; +import nc.vo.mmpac.pickm.entity.MaterialRelationItem; +import nc.vo.mmpac.pickm.entity.PickmHeadVO; +import nc.vo.mmpac.pickm.entity.PickmItemVO; +import nc.vo.mmpac.pickm.param.PickmParamForAdd; +import nc.vo.mmpac.pickm.param.PickmQueryMOParamForSetDelivery; +import nc.vo.mmpac.pickm.param.PickmTransParamForPlanReplace; +import nc.vo.pub.BusinessException; +import nc.vo.pub.lang.UFBoolean; +import nc.vo.pubapp.pattern.pub.MapList; + +public interface IPickmQueryService { + Object[] queryByWhereSql(String paramString, Class paramClass, boolean paramBoolean, String[] paramArrayOfString) throws BusinessException; + + Object[] queryByWhereSql(String paramString) throws BusinessException; + + AggPickmVO[] queryByQueryScheme(IQueryScheme paramIQueryScheme, Integer paramInteger) throws BusinessException; + + AggPickmVO querySingleBillByPk(String paramString) throws BusinessException; + + AggPickmVO[] queryBillsByPks(String[] paramArrayOfString) throws BusinessException; + + MaterialRelationItem queryRelationItemForHead(MaterialQueryCondition paramMaterialQueryCondition) throws BusinessException; + + Map queryMaterialVersionVOByPks(String[] paramArrayOfString) throws BusinessException; + + PickmItemVO queryPickmItemByPK(String paramString) throws BusinessException; + + Map queryHasDownFlowBill(String[] paramArrayOfString) throws BusinessException; + + Map> queryNeededData(AggPickmVO[] paramArrayOfAggPickmVO) throws BusinessException; + + AggPickmVO[] queryPermData(AggPickmVO[] paramArrayOfAggPickmVO) throws BusinessException; + + Map queryAcceptLowerData(PickmHeadVO paramPickmHeadVO, PickmItemVO paramPickmItemVO) throws BusinessException; + + Map queryUnAcceptLowerData(String paramString) throws BusinessException; + + String querySCOrderStock(String paramString1, String paramString2) throws BusinessException; + + Map queryMOInfo(String[] paramArrayOfString, boolean paramBoolean) throws BusinessException; + + PickmTransParamForPlanReplace[] queryMatSumPlanOutNumFromSameFirstBill(PickmTransParamForPlanReplace[] paramArrayOfPickmTransParamForPlanReplace) throws BusinessException; + + Object[] queryPSCPickmByQueryScheme(IQueryScheme paramIQueryScheme) throws BusinessException; + + Map queryIsHavePSCitemsByRowIDs(String[] paramArrayOfString) throws BusinessException; + + Map queryVidByOidForOrgAndDept(List paramList1, List paramList2) throws BusinessException; + + PickmParamForAdd queryOrgvidAndTransinfForAdd(String paramString1, String paramString2) throws BusinessException; + + PickmHeadVO[] queryHeadByIds(String[] paramArrayOfString) throws BusinessException; + + PickmItemVO[] queryCLItemsForNcc(String paramString, String[] paramArrayOfString) throws BusinessException; + + PickmItemVO[] fillCLItemsForNcc(PickmItemVO[] paramArrayOfPickmItemVO) throws BusinessException; + + AggPickmVO[] queryAggPickmVObyBid(String[] paramArrayOfString) throws BusinessException; + + MapList getReplaceGroupItemByKeyID(String[] paramArrayOfString, String paramString) throws BusinessException; + + PickmItemVO[] queryItemsByIds(String[] itemIds) throws BusinessException; +}