private List<Entity> getResourcesForLocationAndProductLIFO(final Entity warehouse, final Entity product, final Entity additionalCode, final Entity position) { return getResourcesForLocationCommonCode(warehouse, product, additionalCode, position, SearchOrders.desc(ResourceFields.TIME)); }
private List<Entity> getResourcesForLocationAndProductLEFO(final Entity warehouse, final Entity product, final Entity additionalCode, final Entity position) { return getResourcesForLocationCommonCode(warehouse, product, additionalCode, position, SearchOrders.desc(ResourceFields.EXPIRATION_DATE), SearchOrders.asc(ResourceFields.AVAILABLE_QUANTITY)); }
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; }
private List<Entity> findNearestOrdersAfterInterval(final DataDefinition orderDD, final TimeGapsContext context) { Date firstDateAfter = findStartDateOfFirstOrderAfterInterval(orderDD, context); if (firstDateAfter == null) { return Collections.emptyList(); } SearchCriteriaBuilder scb = prepareCriteriaBuilder(orderDD, context); scb.add(eq(OrderFields.START_DATE, firstDateAfter)); scb.addOrder(SearchOrders.desc(OrderFields.START_DATE)); return scb.list().getEntities(); }
private Entity getLastBatch() { return dataDefinitionService .get(MaterialFlowResourcesConstants.PLUGIN_IDENTIFIER, MaterialFlowResourcesConstants.MODEL_RESOURCE).find() .addOrder(SearchOrders.desc(BATCH)).setMaxResults(1).uniqueResult(); }
private List<Entity> findNearestOrdersBeforeInterval(final DataDefinition orderDD, final TimeGapsContext context) { Date lastDateBefore = findFinishDateOfLastOrderBeforeInterval(orderDD, context); if (lastDateBefore == null) { return Collections.emptyList(); } SearchCriteriaBuilder scb = prepareCriteriaBuilder(orderDD, context); scb.add(eq(OrderFields.FINISH_DATE, lastDateBefore)); scb.addOrder(SearchOrders.desc(OrderFields.FINISH_DATE)); return scb.list().getEntities(); }
public Optional<Entity> tryFind(final Entity product, final String numberWithSuffix) { SearchCriteriaBuilder scb = product.getDataDefinition().find(); scb.add(belongsTo(ProductFields.PARENT, product)); scb.add(eq(ProductFields.NUMBER, numberWithSuffix)); scb.addOrder(desc("id")); return Optional.ofNullable(scb.setMaxResults(1).uniqueResult()); }
public Optional<Entity> findPreviousOrder(final Entity order) { Entity productionLine = order.getBelongsToField(OrderFields.PRODUCTION_LINE); Entity nextOrder = dataDefinitionService.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER).find() .add(SearchRestrictions.belongsTo(OrderFields.PRODUCTION_LINE, productionLine)) .add(SearchRestrictions.isNotNull(OrderFields.START_DATE)).addOrder(SearchOrders.desc(OrderFields.START_DATE)) .setMaxResults(1).uniqueResult(); return Optional.ofNullable(nextOrder); }
public Entity getLastTechnologyStateChange(Entity technology) { return technology.getHasManyField(TechnologyFields.STATE_CHANGES).find() .add(SearchRestrictions.eq(TechnologyStateChangeFields.STATUS, StateChangeStatus.SUCCESSFUL.getStringValue())) .addOrder(SearchOrders.desc(TechnologyStateChangeFields.DATE_AND_TIME)).setMaxResults(1).uniqueResult(); }
private Entity getCoverageProductLoggingFarthestCoverage(final Entity coverageProduct) { return coverageProduct .getHasManyField(CoverageProductFields.COVERAGE_PRODUCT_LOGGINGS) .find() .add(SearchRestrictions.eq(CoverageProductLoggingFields.STATE, CoverageProductLoggingState.COVERED.getStringValue())) .addOrder(SearchOrders.desc(CoverageProductLoggingFields.DATE)).setMaxResults(1).uniqueResult(); }
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; }
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 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; } }
public Optional<Entity> findLastOrder(final Entity order) { Entity productionLine = order.getBelongsToField(OrderFields.PRODUCTION_LINE); Entity lastOrder = dataDefinitionService.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER).find() .add(SearchRestrictions.isNotNull(OrderFields.FINISH_DATE)) .add(SearchRestrictions.belongsTo(OrderFields.PRODUCTION_LINE, productionLine)) .add(SearchRestrictions.ne(OrderFields.STATE, OrderState.ABANDONED.getStringValue())) .addOrder(SearchOrders.desc(OrderFields.FINISH_DATE)).setMaxResults(1).uniqueResult(); return Optional.ofNullable(lastOrder); }
private Entity getAssignmentToShift(final Entity shift, final Date date) { boolean shiftWorks = shiftsService.checkIfShiftWorkAtDate(date, shift); if (shiftWorks) { return dataDefinitionService .get(AssignmentToShiftConstants.PLUGIN_IDENTIFIER, AssignmentToShiftConstants.MODEL_ASSIGNMENT_TO_SHIFT) .find().add(SearchRestrictions.belongsTo(SHIFT, shift)).add(SearchRestrictions.le(START_DATE, date)) .addOrder(SearchOrders.desc(START_DATE)).setMaxResults(1).uniqueResult(); } else { return null; } }
public void updateFarestLimitDate(final DataDefinition negotiationDD, final Entity negotiation) { if (negotiation.getId() != null) { Entity negotiationProduct = negotiation.getHasManyField(NEGOTIATION_PRODUCTS).find() .add(SearchRestrictions.belongsTo(NEGOTIATION, negotiation)).addOrder(SearchOrders.desc(DUE_DATE)) .setMaxResults(1).uniqueResult(); if (negotiationProduct != null) { Date farestLimitDate = (Date) negotiationProduct.getField(DUE_DATE); negotiation.setField(FARTHEST_LIMIT_DATE, farestLimitDate); } } }
private Date findFinishDateOfLastOrderBeforeInterval(final DataDefinition orderDD, final TimeGapsContext context) { SearchCriteriaBuilder scb = orderDD.find(); scb.setProjection(alias(field(OrderFields.FINISH_DATE), OrderFields.FINISH_DATE)); addProductionLineDomainCriteria(scb, context.getProductionLines()); scb.add(buildCommonCriterion()); scb.add(le(OrderFields.FINISH_DATE, context.getInterval().getStart().toDate())); scb.addOrder(SearchOrders.desc(OrderFields.FINISH_DATE)); Entity projection = scb.setMaxResults(1).uniqueResult(); if (projection == null) { return null; } return projection.getDateField(OrderFields.FINISH_DATE); }
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 isWorkstationTypeComponentsAfterDate(final Entity productionLine, final Entity workstationType, final Date date) { SearchCriteriaBuilder scb = dataDefinitionService .get(ProductionLinesConstants.PLUGIN_IDENTIFIER, ProductionLinesConstants.MODEL_WORKSTATION_TYPE_COMPONENT) .find().add(SearchRestrictions.belongsTo(WorkstationTypeComponentFields.PRODUCTIONLINE, productionLine)) .add(SearchRestrictions.belongsTo(WorkstationTypeComponentFields.WORKSTATIONTYPE, workstationType)) .add(SearchRestrictions.gt(WorkstationTypeComponentFields.DATE_FROM, date)); 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; }
@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(); }