public void restrictSuppliers(final SearchCriteriaBuilder scb, final FilterValueHolder filterValue) { Long productId = filterValue.getLong(CoverageProductGeneratedFields.PRODUCT_ID); List<Long> ids = deliveriesService.getSuppliersWithIntegration(productId).stream().map(Entity::getId) .collect(Collectors.toList()); if (ids.isEmpty()) { scb.add(SearchRestrictions.idEq(0L)); } else { scb.add(SearchRestrictions.in("id", ids)); } } }
public void showEntryData(final SearchCriteriaBuilder scb, final FilterValueHolder filterValue) { if (!filterValue.has(ORDERS_PARAMETER)) { scb.add(SearchRestrictions.idEq(0L)); } else if (filterValue.has(ORDERS_PARAMETER)) { String ids = filterValue.getString(ORDERS_PARAMETER); Iterable<Long> longIds = Longs.stringConverter() .convertAll(Splitter.on(',').trimResults().omitEmptyStrings().splitToList(ids)); List<Long> id = Lists.newArrayList(longIds); scb.add(SearchRestrictions.in("id", id)); } } }
@Override public Optional<Entity> find(final Long orderId, final Long productId) { return find(OrderMaterialCostsCriteria.forOrder(orderId).setProductCriteria(idEq(productId))); }
private Set<LocalDate> findNextStartDatesMatching(final DataDefinition assignmentToShiftDD, final LocalDate laterThan, final Shift shift, final Entity factory, Entity crew) { AssignmentToShiftCriteria criteria = AssignmentToShiftCriteria.empty(); criteria.withCriteria(gt(AssignmentToShiftFields.START_DATE, laterThan.toDate())); criteria.withShiftCriteria(idEq(shift.getId())); criteria.withFactoryCriteria(idEq(factory.getId())); if(Objects.nonNull(crew)){ criteria.withCrewCriteria(idEq(crew.getId())); } List<Entity> matchingStartDatesProjection = assignmentToShiftDataProvider.findAll(criteria, Optional.of(alias(field(AssignmentToShiftFields.START_DATE), AssignmentToShiftFields.START_DATE)), Optional.of(asc(AssignmentToShiftFields.START_DATE))); return FluentIterable.from(matchingStartDatesProjection) .transform(EntityUtils.<Date> getFieldExtractor(AssignmentToShiftFields.START_DATE)).transform(TO_LOCAL_DATE) .toSet(); }
public void restrictBatchForProduct(final SearchCriteriaBuilder searchCriteriaBuilder, final FilterValueHolder filterValueHolder) { if (filterValueHolder.has(L_PRODUCT_FOR_BATCH)) { Long productId = filterValueHolder.getLong(L_PRODUCT_FOR_BATCH); searchCriteriaBuilder.createCriteria(BatchFields.PRODUCT, L_PRODUCT_FOR_BATCH, JoinType.INNER).add( SearchRestrictions.idEq(productId)); } }
public void restrictAdditionalCodesForProduct(final SearchCriteriaBuilder searchCriteriaBuilder, final FilterValueHolder filterValueHolder) { if (filterValueHolder.has(AdditionalCodeFields.PRODUCT)) { Long productId = filterValueHolder.getLong(AdditionalCodeFields.PRODUCT); searchCriteriaBuilder.createCriteria(AdditionalCodeFields.PRODUCT, AdditionalCodeFields.PRODUCT, JoinType.INNER).add( SearchRestrictions.idEq(productId)); } }
public Optional<Entity> findRoot(final long technologyId) { SearchCriteriaBuilder scb = getTocDataDefinition().find(); scb.createCriteria(TechnologyOperationComponentFields.TECHNOLOGY, "tech_alias", JoinType.INNER).add(idEq(technologyId)); scb.add(isNull(TechnologyOperationComponentFields.PARENT)); return Optional.fromNullable(scb.setMaxResults(1).uniqueResult()); }
public void showEntriesForTechnology(final SearchCriteriaBuilder scb, final FilterValueHolder filterValue) { if (filterValue.has(TECHNOLOGY_PARAMETER)) { Entity technology = dataDefinitionService.get(TechnologiesConstants.PLUGIN_IDENTIFIER, TechnologiesConstants.MODEL_TECHNOLOGY).get(filterValue.getLong(TECHNOLOGY_PARAMETER)); scb.createAlias(OperCompTimeCalculationsFields.TECHNOLOGY_OPERATION_COMPONENT, "opr", JoinType.LEFT); scb.add(SearchRestrictions.in("opr.id", technology.getHasManyField( TechnologyFields.OPERATION_COMPONENTS).stream().map(e -> e.getId()).collect(Collectors.toList()))); scb.add(SearchRestrictions.isNull(OperCompTimeCalculationsFields.ORDER_TIME_CALCULATION)); } else { scb.add(SearchRestrictions.idEq(0l)); } } }
public void showEntriesForOrder(final SearchCriteriaBuilder scb, final FilterValueHolder filterValue) { if (filterValue.has(ORDER_PARAMETER)) { Entity orderTimeCalculation = dataDefinitionService .get(TimeNormsConstants.PLUGIN_PRODUCTION_SCHEDULING_IDENTIFIER, TimeNormsConstants.MODEL_ORDER_TIME_CALCULATION) .find() .add(SearchRestrictions.belongsTo("order", OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER, filterValue.getLong(ORDER_PARAMETER))).setMaxResults(1).uniqueResult(); if (Objects.isNull(orderTimeCalculation)) { scb.add(SearchRestrictions.idEq(0l)); } else { scb.add(SearchRestrictions.belongsTo(OperCompTimeCalculationsFields.ORDER_TIME_CALCULATION, orderTimeCalculation)); } } else { scb.add(SearchRestrictions.idEq(0l)); } }
private Entity findGenealogyOperationProductInByOperationProductIn(Entity operationProduct) { Long id = operationProduct.getId(); return advancedGenealogyForOrdersDD() .find() .createCriteria("productInComponent", "productInComponent_alias", JoinType.INNER).add(idEq(id)) .uniqueResult(); }
public void showDivisionsUsedInTechnology(final SearchCriteriaBuilder scb, final FilterValueHolder filterValueHolder) { if (filterValueHolder.has(L_TECHNOLOGY)) { scb.add(SearchRestrictions.in("id", getDivisionsForOrder(filterValueHolder.getLong(L_TECHNOLOGY)))); } else { scb.add(SearchRestrictions.idEq(-1)); } }
private void applyDefaultCriteria(final TechnologyRawInputProductComponentsCriteria criteria, final SearchCriteriaBuilder scb) { scb.add(or( neField(OPOC_ALIAS + "." + OperationProductOutComponentFields.PRODUCT, OPIC_ALIAS + "." + OperationProductInComponentFields.PRODUCT), isEmpty(TOC_ALIAS + "." + TechnologyOperationComponentFields.CHILDREN))); scb.createCriteria(TOC_ALIAS + "." + TechnologyOperationComponentFields.TECHNOLOGY, "tech_alias", JoinType.INNER).add( idEq(criteria.getTechnologyId())); }
private SearchCriteriaBuilder prepareCriteria(final OrderMaterialCostsCriteria criteria) { SearchCriteriaBuilder scb = createCriteriaBuilder(); scb.createCriteria(TechnologyInstOperProductInCompFields.ORDER, ORDER_ALIAS, JoinType.INNER).add( idEq(criteria.getOrderId())); applyProjection(criteria, scb); applyProductCriteria(criteria, scb); applySearchOrder(criteria, scb); return scb; }
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; }
private SearchCriteriaBuilder createGenerationModeBaseCriteria(final String modelName, final String tocFieldName, final String productFieldName, final TechnologyId technologyId) { DataDefinition dd = dataDefinitionService.get(TechnologiesConstants.PLUGIN_IDENTIFIER, modelName); SearchCriteriaBuilder opicCriteria = dd.find(); opicCriteria.createCriteria(tocFieldName, "toc_alias", JoinType.INNER) .createCriteria(TechnologyOperationComponentFields.TECHNOLOGY, "tech_alias", JoinType.INNER) .add(idEq(technologyId.get())); opicCriteria.createCriteria(productFieldName, "prod_alias", JoinType.INNER).add( eq(ProductFieldsTG.FROM_GENERATOR, true)); return opicCriteria; }
@Override public List<Entity> getProductionTrackingsForOrder(final Entity order) { SearchCriteriaBuilder scb = getProductionTrackingDD().find(); scb.createCriteria(ProductionTrackingFields.ORDER, "ord_alias", JoinType.INNER).add(idEq(order.getId())); scb.add(SearchRestrictions.eq(ProductionTrackingFields.STATE, ProductionTrackingStateStringValues.ACCEPTED)); return scb.list().getEntities(); }
private SearchCriteriaBuilder createBaseCriteria(final String modelName, final String tocFieldName, final String productFieldName, final TechnologyId technologyId) { DataDefinition dd = dataDefinitionService.get(TechnologiesConstants.PLUGIN_IDENTIFIER, modelName); SearchCriteriaBuilder opicCriteria = dd.find(); opicCriteria.createCriteria(tocFieldName, "toc_alias", JoinType.INNER) .createCriteria(TechnologyOperationComponentFields.TECHNOLOGY, "tech_alias", JoinType.INNER) .add(idEq(technologyId.get())); opicCriteria.createCriteria(productFieldName, "prod_alias", JoinType.INNER).add( eq(ProductFields.ENTITY_TYPE, ProductFamilyElementType.PRODUCTS_FAMILY.getStringValue())); return opicCriteria; }
private SearchCriteriaBuilder prepareExistingNodeSearchCriteria(final ContextId contextId) { SearchCriteriaBuilder scb = getGeneratorTreeNodeDD().find(); scb.add(isNotNull(GeneratorTreeNodeFields.PRODUCT_TECHNOLOGY)); scb.add(isNotNull(GeneratorTreeNodeFields.ORIGINAL_TECHNOLOGY)); scb.createCriteria(GeneratorTreeNodeFields.GENERATOR_CONTEXT, "generatorContext_alias", JoinType.INNER).add( idEq(contextId.get())); scb.add(neField(GeneratorTreeNodeFields.PRODUCT_TECHNOLOGY, GeneratorTreeNodeFields.ORIGINAL_TECHNOLOGY)); return scb; }
private boolean reasonHasChanged(final Entity reasonTypeEntity, final DeviationModelDescriber deviationModelDescriber) { String reasonFieldName = deviationModelDescriber.getReasonTypeFieldName(); String reason = reasonTypeEntity.getStringField(reasonFieldName); DataDefinition reasonDD = dataDefinitionService.get(deviationModelDescriber.getModelPlugin(), deviationModelDescriber.getModelName()); SearchCriteriaBuilder scb = reasonDD.find(); scb.add(idEq(reasonTypeEntity.getId())); scb.add(eq(reasonFieldName, reason)); scb.setProjection(id()); return scb.setMaxResults(1).list().getTotalNumberOfEntities() == 0; }
private Entity getWorkstationTypesSumProjection(final Long productionLineId, final String workstationTypeNumber) { SearchCriteriaBuilder scb = getWorkstationTypeComponentDD().find(); scb.createCriteria(WorkstationTypeComponentFields.PRODUCTIONLINE, "pl").add(idEq(productionLineId)); scb.createCriteria(WorkstationTypeComponentFields.WORKSTATIONTYPE, "wt").add( eq(WorkstationTypeFields.NUMBER, workstationTypeNumber)); scb.setProjection(list().add(alias(sum(WorkstationTypeComponentFields.QUANTITY), "sum")).add(rowCount())); scb.addOrder(asc("sum")); return scb.setMaxResults(1).uniqueResult(); }