private SearchCriterion getProductionLineRestrictions(final Long productionLineId) { SearchCriterion matchProductionLine = eq(LineChangeoverNormsFields.PRODUCTION_LINE + DOT_ID, productionLineId); SearchCriterion productionLineIsNull = isNull(LineChangeoverNormsFields.PRODUCTION_LINE); return or(matchProductionLine, productionLineIsNull); }
public void showWorkstationTypesWithoutSubassembly(final SearchCriteriaBuilder scb) { scb.add(SearchRestrictions.or(SearchRestrictions.eq(WorkstationTypeFields.SUBASSEMBLY, false), SearchRestrictions.isNull(WorkstationTypeFields.SUBASSEMBLY))); } }
public Optional<Entity> getDictionaryItemByOccupationTypeAttributes(final Map<String, String> occupationTypeAttributes) { List<Entity> dictionaryItems = getDictionaryItemDataDefinition() .find() .add(SearchRestrictions.belongsTo(L_DICTIONARY, getOcupationTypeDictionary())) .add(SearchRestrictions.or( SearchRestrictions.eq(L_TECHNICAL_CODE, occupationTypeAttributes.get(L_TECHNICAL_CODE.toLowerCase(Locale.ENGLISH))), SearchRestrictions.eq(L_NAME, occupationTypeAttributes.get(L_NAME.toLowerCase(Locale.ENGLISH))))).list() .getEntities(); return dictionaryItems.isEmpty() ? Optional.empty() : Optional.of(dictionaryItems.get(0)); }
private void restrictToUserLocations(SearchCriteriaBuilder scb) { Long currentUserId = securityService.getCurrentUserId(); if (Objects.nonNull(currentUserId)) { EntityList userLocations = userDataDefinition().get(currentUserId).getHasManyField(UserFieldsMF.USER_LOCATIONS); if (!userLocations.isEmpty()) { Set<Integer> locationIds = userLocations.stream().map(ul -> ul.getBelongsToField(UserLocationFields.LOCATION)) .mapToInt(e -> e.getId().intValue()).boxed().collect(Collectors.toSet()); scb.add(SearchRestrictions.or(SearchRestrictions.in(LOCATION_TO_ID, locationIds), SearchRestrictions.in(LOCATION_FROM_ID, locationIds))); } } }
public void restrictToUserLocations(final SearchCriteriaBuilder scb, final FilterValueHolder filterValue) { Long currentUserId = securityService.getCurrentUserId(); if (Objects.nonNull(currentUserId)) { EntityList userLocations = userDataDefinition().get(currentUserId).getHasManyField(UserFieldsMF.USER_LOCATIONS); if (!userLocations.isEmpty()) { Set<Integer> locationIds = userLocations.stream().map(ul -> ul.getBelongsToField(UserLocationFields.LOCATION)) .mapToInt(e -> e.getId().intValue()).boxed().collect(Collectors.toSet()); scb.add(SearchRestrictions.or(SearchRestrictions.in(LOCATION_TO_ID, locationIds), SearchRestrictions.in(LOCATION_FROM_ID, locationIds))); } } }
public void filterAllWithoutOtherAction(final SearchCriteriaBuilder searchCriteriaBuilder, final FilterValueHolder filterValueHolder) { filterActionsForObejct(searchCriteriaBuilder, filterValueHolder); searchCriteriaBuilder.add(SearchRestrictions.or(SearchRestrictions.eq(ActionFields.IS_DEFAULT, false), SearchRestrictions.isNull(ActionFields.IS_DEFAULT))); }
@Override public void addRestriction(final SearchCriteriaBuilder searchBuilder) { Entity ownerCompany = companyService.getCompany(); searchBuilder.add(SearchRestrictions.or(SearchRestrictions.belongsTo("workFor", ownerCompany), SearchRestrictions.isNotNull("laborHourlyCost"))); }
public void restrictDivisionsToLocation(final SearchCriteriaBuilder scb, final FilterValueHolder filterValue) { if (!filterValue.has(L_LOCATION)) { return; } Long locationId = filterValue.getLong(L_LOCATION); scb.add(SearchRestrictions.or(SearchRestrictions.eq(DivisionFieldsMFR.COMPONENTS_LOCATION + "." + L_ID, locationId), SearchRestrictions.eq(DivisionFieldsMFR.COMPONENTS_OUTPUT_LOCATION + "." + L_ID, locationId), SearchRestrictions.eq(DivisionFieldsMFR.PRODUCTS_INPUT_LOCATION + "." + L_ID, locationId))); } }
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 boolean draftOrInProgressWarehouseIssuesDoesntExist() { DataDefinition dd = dataDefinitionService.get(ProductFlowThruDivisionConstants.PLUGIN_IDENTIFIER, ProductFlowThruDivisionConstants.MODEL_WAREHOUSE_ISSUE); SearchResult result = dd.find().add(SearchRestrictions.or( SearchRestrictions.eq(WarehouseIssueFields.STATE, WarehouseIssueState.DRAFT.getStringValue()), SearchRestrictions.eq(WarehouseIssueFields.STATE, WarehouseIssueState.IN_PROGRESS.getStringValue()))).list(); return result.getTotalNumberOfEntities() == 0; }
private boolean databaseHasToBePrepared() { return dictionariesService .getDictionaryItemDD() .find() .add(belongsTo(DictionaryItemFields.DICTIONARY, getTypeOfPalletDictionary())) .add(SearchRestrictions.or(eq(DictionaryItemFields.TECHNICAL_CODE, "01epal"), eq(DictionaryItemFields.TECHNICAL_CODE, "02cheapEur"))).list().getTotalNumberOfEntities() == 0; }
private boolean databaseHasToBePrepared() { return getDictionaryItemDataDefinition() .find() .add(SearchRestrictions.belongsTo(L_DICTIONARY, getOcupationTypeDictionary())) .add(SearchRestrictions.eq(DictionaryItemFields.ACTIVE, true)) .add(SearchRestrictions.or(SearchRestrictions.eq(L_TECHNICAL_CODE, "01workForLine"), SearchRestrictions.eq(L_TECHNICAL_CODE, "02otherCase"))).list().getTotalNumberOfEntities() == 0; }
public Entity findFirstByNumberProductAndOptionallySupplier(final String number, final Entity product, final Entity supplier) { SearchCriteriaBuilder scb = getBatchDataDef().find(); scb.add(eq(BatchFields.NUMBER, number)); scb.add(belongsTo(BatchFields.PRODUCT, product)); scb.add(or(belongsTo(BatchFields.SUPPLIER, supplier), isNull(BatchFields.SUPPLIER))); scb.addOrder(asc(BatchFields.SUPPLIER)); scb.setMaxResults(1); return scb.uniqueResult(); }
private List<Entity> getCoverageProductLoggingDemands(final Entity coverageProduct, final Date farthestCoverageDate) { return coverageProduct .getHasManyField(CoverageProductFields.COVERAGE_PRODUCT_LOGGINGS) .find() .add(SearchRestrictions.or(SearchRestrictions.eq(CoverageProductLoggingFields.EVENT_TYPE, CoverageProductLoggingEventType.ORDER_INPUT.getStringValue()), SearchRestrictions.eq(CoverageProductLoggingFields.EVENT_TYPE, CoverageProductLoggingEventType.OPERATION_INPUT.getStringValue()))) .add(SearchRestrictions.gt(CoverageProductLoggingFields.DATE, farthestCoverageDate)) .addOrder(SearchOrders.asc(CoverageProductLoggingFields.DATE)).list().getEntities(); }
public Entity findTechnologyForProduct(final Entity product) { DataDefinition technologyDD = dataDefinitionService.get(TechnologiesConstants.PLUGIN_IDENTIFIER, TechnologiesConstants.MODEL_TECHNOLOGY); return technologyDD .find() .add(SearchRestrictions.isNull(TechnologyFields.TECHNOLOGY_TYPE)) .add(SearchRestrictions.belongsTo(ProductStructureTreeNodeFields.PRODUCT, product)) .add(SearchRestrictions.or(SearchRestrictions.eq(TechnologyFields.STATE, TechnologyStateStringValues.ACCEPTED), SearchRestrictions.eq(TechnologyFields.STATE, TechnologyStateStringValues.CHECKED))) .addOrder(SearchOrders.desc(TechnologyFields.MASTER)).addOrder(SearchOrders.asc(TechnologyFields.NUMBER)) .setMaxResults(1).uniqueResult(); }
public boolean checkIfUsedOrWastesQuantitiesWereNotFilled(final Entity productionTracking) { Entity order = productionTracking.getBelongsToField(ProductionTrackingFields.ORDER); final SearchCriteriaBuilder searchBuilder = productionTracking .getHasManyField(ProductionTrackingFields.TRACKING_OPERATION_PRODUCT_OUT_COMPONENTS).find() .add(SearchRestrictions.or(SearchRestrictions.isNotNull(TrackingOperationProductOutComponentFields.USED_QUANTITY), SearchRestrictions.isNotNull(TrackingOperationProductOutComponentFields.WASTES_QUANTITY))) .setProjection(SearchProjections.alias(SearchProjections.rowCount(), L_COUNT)).addOrder(asc(L_COUNT)); return (order.getBooleanField(OrderFieldsPC.REGISTER_QUANTITY_OUT_PRODUCT) && ((Long) searchBuilder.setMaxResults(1).uniqueResult().getField(L_COUNT) <= 0)); }
private List<Entity> getOrdersFromDB() { return dataDefinitionService .get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER) .find() .add(SearchRestrictions.isNotNull(OrderFieldsPC.TYPE_OF_PRODUCTION_RECORDING)) .add(SearchRestrictions.isNotNull(OrderFields.TECHNOLOGY)) .add(SearchRestrictions.or(SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.PENDING), SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.ACCEPTED), SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.IN_PROGRESS), SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.INTERRUPTED))) .add(SearchRestrictions.eq(OrderFields.ACTIVE, true)).list().getEntities(); }
private boolean databaseHasToBePrepared() { return dictionariesService .getDictionaryItemDD() .find() .add(belongsTo(DictionaryItemFields.DICTIONARY, getColorDictionary())) .add(SearchRestrictions.or(eq(DictionaryItemFields.TECHNICAL_CODE, "01white"), eq(DictionaryItemFields.TECHNICAL_CODE, "02grey"), eq(DictionaryItemFields.TECHNICAL_CODE, "03yellow"), eq(DictionaryItemFields.TECHNICAL_CODE, "04orange"), eq(DictionaryItemFields.TECHNICAL_CODE, "05red"), eq(DictionaryItemFields.TECHNICAL_CODE, "06green"), eq(DictionaryItemFields.TECHNICAL_CODE, "07blue"))) .list().getTotalNumberOfEntities() == 0; }
@Override public Entity getPreviousOrderFromDB(final Entity order) { return dataDefinitionService .get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER) .find() .add(SearchRestrictions.belongsTo(OrderFields.PRODUCTION_LINE, order.getBelongsToField(OrderFields.PRODUCTION_LINE))) .add(SearchRestrictions.or(SearchRestrictions.ne(OrderFields.STATE, OrderState.DECLINED.getStringValue()), SearchRestrictions.ne(OrderFields.STATE, OrderState.ABANDONED.getStringValue()))) .add(SearchRestrictions.lt(OrderFields.FINISH_DATE, order.getDateField(OrderFields.START_DATE))) .addOrder(SearchOrders.desc(OrderFields.FINISH_DATE)).setMaxResults(1).uniqueResult(); }
private List<Entity> getOrdersFromDB(final Date coverageToDate) { return dataDefinitionService .get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER) .find() .add(SearchRestrictions.le(OrderFields.START_DATE, coverageToDate)) .add(SearchRestrictions.isNotNull(OrderFieldsPC.TYPE_OF_PRODUCTION_RECORDING)) .add(SearchRestrictions.isNotNull(OrderFields.TECHNOLOGY)) .add(SearchRestrictions.or(SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.PENDING), SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.ACCEPTED), SearchRestrictions.eq(OrderFields.STATE, OrderStateStringValues.INTERRUPTED))) .add(SearchRestrictions.eq(OrderFields.ACTIVE, true)).list().getEntities(); }