public BigDecimal sumBelongingOrdersDoneQuantities(final Entity masterOrder, final Entity product) { SearchProjection quantitiesSumProjection = list().add(alias(sum(OrderFields.DONE_QUANTITY), QUANTITIES_SUM_ALIAS)) .add(rowCount()); SearchCriterion productCriterion = belongsTo(OrderFields.PRODUCT, product); List<Entity> quantitiesSumProjectionResults = findBelongingOrders(masterOrder, quantitiesSumProjection, productCriterion, SearchOrders.desc(QUANTITIES_SUM_ALIAS)); for (Entity entity : quantitiesSumProjectionResults) { return entity.getDecimalField(QUANTITIES_SUM_ALIAS); } return BigDecimal.ZERO; } }
private Collection<Long> getContextIds() { DataDefinition dataDef = getDataDefinition(); SearchCriteriaBuilder scb = dataDef.find(); scb.setProjection(SearchProjections.alias(SearchProjections.id(), "id")); List<Long> ids = Lists.newLinkedList(); for (Entity idProjection : scb.list().getEntities()) { ids.add((Long) idProjection.getField("id")); } return ids; }
private SearchProjection buildProjection() { SearchProjection lineIdProjection = alias(field(OrderFields.PRODUCTION_LINE + ".id"), PRODUCTION_LINE_ID_ALIAS); SearchProjection dateFromProjection = alias(field(OrderFields.START_DATE), DATE_FROM_ALIAS); SearchProjection dateToProjection = alias(field(OrderFields.FINISH_DATE), DATE_TO_ALIAS); SearchProjection technologyId = alias(field(OrderFields.TECHNOLOGY + ".id"), TECHNOLOGY_ID_ALIAS); SearchProjection technologyGroupId = alias( field(OrderFields.TECHNOLOGY + "." + TechnologyFields.TECHNOLOGY_GROUP + ".id"), TECHNOLOGY_GROUP_ID_ALIAS); SearchProjection ownChangeoverDurationProjection = alias(field(OrderFieldsLCNFO.OWN_LINE_CHANGEOVER_DURATION), OrderFieldsLCNFO.OWN_LINE_CHANGEOVER_DURATION); return SearchProjections.list().add(dateFromProjection).add(dateToProjection).add(lineIdProjection).add(technologyId) .add(technologyGroupId).add(ownChangeoverDurationProjection); }
private List<Entity> findCorruptedTechnologyNumbers(final Long productID) { MasterOutputProductCriteria criteria = MasterOutputProductCriteria .empty() .withProdCriteria(idEq(productID)) .withTechCriteria( in(TechnologyFields.STATE, Lists.newArrayList(TechnologyStateStringValues.ACCEPTED, TechnologyStateStringValues.CHECKED))); SearchCriteriaBuilder scb = mainTocOutputProductCriteriaBuilder.create(criteria); scb.add(neField(Aliases.OPERATION_OUTPUT_PRODUCT + "." + ProductFields.UNIT, Aliases.TOC + "." + TechnologyOperationComponentFieldsTNFO.PRODUCTION_IN_ONE_CYCLE_UNIT)); scb.addOrder(desc("id")); SearchProjection techNumProjection = alias(field(Aliases.TECHNOLOGY + "." + TechnologyFields.NUMBER), "techNumber"); SearchProjection projection = SearchProjections.list().add(techNumProjection).add(alias(id(), "id")); scb.setProjection(SearchProjections.distinct(projection)); return scb.list().getEntities(); } }
public long countBelongingOrders(final Entity masterOrder, final SearchCriterion additionalCriteria) { List<Entity> ordersCountProjection = findBelongingOrders(masterOrder, alias(rowCount(), "count"), additionalCriteria, SearchOrders.desc("count")); for (Entity entity : ordersCountProjection) { return (Long) entity.getField("count"); } return 0L; }
@Override public Map<Long, BigDecimal> getComponentsStock(Entity technology, boolean externalNumberShouldBeNull) { Preconditions.checkArgument(technology != null, "Technology is required."); DataDefinition operationProductInComponentDD = dataDefinitionService.get(TechnologiesConstants.PLUGIN_IDENTIFIER, TechnologiesConstants.MODEL_OPERATION_PRODUCT_IN_COMPONENT); SearchCriteriaBuilder scb = operationProductInComponentDD.find() .createAlias(OperationProductInComponentFields.OPERATION_COMPONENT, "c", JoinType.INNER) .createAlias(OperationProductInComponentFieldsPFTD.COMPONENTS_LOCATION, "w", JoinType.LEFT) .createAlias("w." + LocationFieldsMFR.RESOURCES, "r", JoinType.LEFT) .add(eqField("r." + ResourceFields.PRODUCT, OperationProductInComponentFields.PRODUCT)) .add(belongsTo("c." + TechnologyOperationComponentFields.TECHNOLOGY, technology)); if (externalNumberShouldBeNull) { scb.add(isNull("w." + LocationFields.EXTERNAL_NUMBER)); } scb.setProjection( list().add( alias(groupField(OperationProductInComponentFields.PRODUCT), OperationProductInComponentFields.PRODUCT)) .add(alias(sum("r." + ResourceFields.QUANTITY), ResourceFields.QUANTITY))).addOrder( SearchOrders.asc(ResourceFields.QUANTITY)); List<Entity> componentsStock = scb.list().getEntities(); Map<Long, BigDecimal> stockMap = Maps.newHashMap(); for (Entity componentStock : componentsStock) { stockMap.put(componentStock.getBelongsToField(OperationProductInComponentFields.PRODUCT).getId(), componentStock.getDecimalField(ResourceFields.QUANTITY)); } return stockMap; }
private boolean productWithEanAlreadyExists(final DataDefinition productDD, final String notEmptyEan) { SearchCriteriaBuilder scb = productDD.find(); scb.setProjection(SearchProjections.id()); scb.add(SearchRestrictions.eq(ProductFields.EAN, notEmptyEan)); return scb.setMaxResults(1).uniqueResult() != null; }
public boolean hasSubOrders(List<Long> orderIds) { if (orderIds.isEmpty()) { return false; } SearchCriteriaBuilder scb = dataDefinitionService.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER) .find(); scb.createAlias(OrderFieldsOFSPG.PARENT, OrderFieldsOFSPG.PARENT, JoinType.LEFT); scb.add(SearchRestrictions.in(OrderFieldsOFSPG.PARENT + ".id", orderIds)); scb.setProjection(SearchProjections.alias(SearchProjections.countDistinct("id"), COUNT_ALIAS)); scb.addOrder(SearchOrders.desc(COUNT_ALIAS)); Entity projectionResult = scb.setMaxResults(1).uniqueResult(); Long countValue = (Long) projectionResult.getField(COUNT_ALIAS); return countValue > 0; }
public static SearchProjection buildProjectionForProduct(final String prefix) { return list().add(fieldProj(prefix, "id", PRODUCT_ID)) .add(fieldProj(prefix, ProductFieldsCNFP.COST_FOR_NUMBER, COST_FOR_NUMBER)) .add(fieldProj(prefix, ProductFieldsCNFP.NOMINAL_COST, NOMINAL_COST)) .add(fieldProj(prefix, ProductFieldsCNFP.LAST_PURCHASE_COST, LAST_PURCHASE_COST)) .add(fieldProj(prefix, ProductFieldsCNFP.AVERAGE_COST, AVERAGE_COST)); }
public List<Entity> getProductsSeenInLocation(final String locationNumber) { DataDefinition dataDefLocation = dataDefinitionService.get(MaterialFlowConstants.PLUGIN_IDENTIFIER, MaterialFlowConstants.MODEL_LOCATION); Long id = dataDefLocation.find().add(SearchRestrictions.eq(NUMBER, locationNumber)).uniqueResult().getId(); DataDefinition dataDefProduct = dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT); List<Entity> productsFromTransfers = dataDefProduct.find().createAlias(MaterialFlowConstants.MODEL_TRANSFER, L_TRANS) .addOrder(SearchOrders.asc(L_TRANS_PRODUCT_ID)) .setProjection(SearchProjections.distinct(SearchProjections.field(L_TRANS_PRODUCT))) .add(SearchRestrictions.eqField(L_TRANS_PRODUCT_ID, L_ID)).add(SearchRestrictions.eq(L_TRANS_LOCATION_TO_ID, id)) .list().getEntities(); List<Entity> productsFromStockCorrections = dataDefProduct.find() .createAlias(MaterialFlowConstants.MODEL_STOCK_CORRECTION, L_LOC).addOrder(SearchOrders.asc(L_LOC_PRODUCT_ID)) .setProjection(SearchProjections.distinct(SearchProjections.field(L_LOC_PRODUCT))) .add(SearchRestrictions.eqField(L_LOC_PRODUCT_ID, L_ID)).add(SearchRestrictions.eq(L_LOC_LOCATION_ID, id)).list() .getEntities(); for (Entity product : productsFromStockCorrections) { if (!productsFromTransfers.contains(product)) { productsFromTransfers.add(product); } } return productsFromTransfers; }
@Override public List<Long> findMergedToOperationComponentIds() { List<Entity> entities = mergesProductInDD().find() .add(SearchRestrictions.lt(TechnologyOperationComponentMergeProductFields.QUANTITY_CHANGE, BigDecimal.ZERO)) .setProjection(SearchProjections.field(TechnologyOperationComponentMergeProductFields.MERGED_OPERATION_COMPONENT)) .list().getEntities(); return Lists.newArrayList(Collections2.transform(entities, new Function<Entity, Long>() { @Override public Long apply(final Entity from) { return from.getId(); } })); }
private boolean checkIfBasicProductionCountingIsEmpty(final Entity order) { SearchCriteriaBuilder searchBuilder = order.getHasManyField(OrderFieldsBPC.BASIC_PRODUCTION_COUNTINGS).find() .setProjection(SearchProjections.alias(SearchProjections.rowCount(), "count")).addOrder(asc("count")); return (Long) searchBuilder.setMaxResults(1).uniqueResult().getField("count") == 0; }
private void updateOutProducts(final Entity productionTracking, final OperationProductsExtractor.TrackingOperationProducts operationProducts) { List<Entity> outputs = operationProducts.getOutputComponents(); List<Entity> productionTrackingOutputs = productionTracking .getHasManyField(ProductionTrackingFields.TRACKING_OPERATION_PRODUCT_OUT_COMPONENTS).find() .setProjection(alias(field(TrackingOperationProductOutComponentFields.PRODUCT + ".id"), PRODUCT_ID_FIELD_NAME)) .list().getEntities(); Map<Long, Entity> outputsMap = outputs.stream().collect( Collectors.toMap(x -> x.getBelongsToField(TrackingOperationProductOutComponentFields.PRODUCT).getId(), x -> x)); Map<Long, Entity> productionTrackingOutputsMap = productionTrackingOutputs.stream() .collect(Collectors.toMap(x -> x.getLongField(PRODUCT_ID_FIELD_NAME), x -> x)); Set<Long> newEntries = Sets.difference(outputsMap.keySet(), productionTrackingOutputsMap.keySet()); Set<Long> removedEntries = Sets.difference(productionTrackingOutputsMap.keySet(), outputsMap.keySet()); for (Long newEntry : newEntries) { Entity trackingOperationProductOutComponent = outputsMap.get(newEntry); trackingOperationProductOutComponent.setField(TrackingOperationProductOutComponentFields.PRODUCTION_TRACKING, productionTracking); trackingOperationProductOutComponent.getDataDefinition().save(trackingOperationProductOutComponent); } for (Long removedEntry : removedEntries) { dataDefinitionService.get(ProductionCountingConstants.PLUGIN_IDENTIFIER, ProductionCountingConstants.MODEL_TRACKING_OPERATION_PRODUCT_OUT_COMPONENT).delete(removedEntry); } }
private boolean startDatesHasBeenChanged(final Entity order) { SearchCriteriaBuilder scb = order.getDataDefinition().find(); scb.setProjection(id()); scb.add(idEq(order.getId())); for (String dateFieldName : Sets.newHashSet(OrderFields.DATE_FROM, OrderFields.CORRECTED_DATE_FROM, OrderFields.EFFECTIVE_DATE_FROM)) { scb.add(eq(dateFieldName, order.getDateField(dateFieldName))); } return scb.setMaxResults(1).uniqueResult() == null; }
public boolean hasSubOrders(final Entity order) { if (order == null) { return false; } SearchCriteriaBuilder scb = dataDefinitionService.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER) .find(); scb.add(SearchRestrictions.belongsTo(OrderFieldsOFSPG.PARENT, order)); scb.setProjection(SearchProjections.alias(SearchProjections.countDistinct("id"), COUNT_ALIAS)); scb.addOrder(SearchOrders.desc(COUNT_ALIAS)); Entity projectionResult = scb.setMaxResults(1).uniqueResult(); Long countValue = (Long) projectionResult.getField(COUNT_ALIAS); return countValue > 0; }
public BigDecimal sumBelongingOrdersPlannedQuantities(final Entity masterOrder, final Entity product) { SearchProjection quantitiesSumProjection = list().add(alias(sum(OrderFields.PLANNED_QUANTITY), QUANTITIES_SUM_ALIAS)) .add(rowCount()); SearchCriterion productCriterion = belongsTo(OrderFields.PRODUCT, product); List<Entity> quantitiesSumProjectionResults = findBelongingOrders(masterOrder, quantitiesSumProjection, productCriterion, SearchOrders.desc(QUANTITIES_SUM_ALIAS)); for (Entity entity : quantitiesSumProjectionResults) { return entity.getDecimalField(QUANTITIES_SUM_ALIAS); } return BigDecimal.ZERO; }
private boolean existsAnyBatchMatchingCriterion(final DataDefinition batchDD, final SearchCriterion criterion) { SearchCriteriaBuilder scb = batchDD.find(); scb.add(criterion); // to decrease mapping overhead scb.setProjection(alias(id(), "id")); return scb.setMaxResults(1).uniqueResult() != null; }
private static SearchProjection buildProjection() { SearchProjectionList projection = SearchProjections.list(); projection.add(alias(field(ORDER_ALIAS + DOT_ID), ORDER_ID_ALIAS)); projection.add(alias(field(ORDER_ALIAS + DOT + OrderFields.NUMBER), ORDER_NUMBER_ALIAS)); projection.add(alias(field(OPERATION_ALIAS + DOT_ID), OPERATION_ID_ALIAS)); projection.add(alias(field(OPERATION_ALIAS + DOT + OperationFields.NUMBER), OPERATION_NUMBER_ALIAS)); projection.add(alias(field(PRODUCT_ALIAS + DOT_ID), PRODUCT_ID_ALIAS)); projection.add(alias(field(PRODUCT_ALIAS + DOT + ProductFields.NUMBER), PRODUCT_NUMBER_ALIAS)); projection.add(alias(field(PRODUCT_ALIAS + DOT + ProductFields.UNIT), PRODUCT_UNIT_ALIAS)); projection .add(alias(field(TOC_ALIAS + DOT + TechnologyOperationComponentFields.NODE_NUMBER), OPERATION_NODE_NUMBER_ALIAS)); projection.add(alias(field(SHIFT_ALIAS + DOT_ID), SHIFT_ID_ALIAS)); projection.add(alias(field(SHIFT_ALIAS + DOT + ShiftFields.NAME), SHIFT_NAME_ALIAS)); projection.add(alias(field(RECORD_ALIAS + DOT + ProductionTrackingFields.SHIFT_START_DAY), SHIFT_START_DAY_ALIAS)); projection.add(alias(field(TrackingOperationProductOutComponentFields.USED_QUANTITY), QUANTITY_ALIAS)); return projection; }
public boolean noReservationExists(Entity entity) { if (entity.getId() == null) { return true; } SearchCriteriaBuilder scb = dataDefinitionService .get(MaterialFlowResourcesConstants.PLUGIN_IDENTIFIER, MaterialFlowResourcesConstants.MODEL_RESERVATION).find(); scb.add(SearchRestrictions.isNotNull(ReservationFields.POSITION)); scb.add(SearchRestrictions.belongsTo(ReservationFields.LOCATION, entity)); scb.setProjection(alias(rowCount(), "cnt")); scb.addOrder(asc("cnt")); Entity countProjection = scb.setMaxResults(1).uniqueResult(); return ((Long) countProjection.getField("cnt")).compareTo(0L) == 0; }