public List<Entity> findComponentRegistryEntries(final Entity order) { StringBuilder query = new StringBuilder(); query.append("select registry from #orderSupplies_coverageRegister as registry, "); query.append("#technologies_operationProductInComponent as operationProductInComponent "); query.append("where registry.order.id = :orderId and eventType in ('04orderInput','03operationInput') "); query.append("and productType = '02intermediate' "); query.append("and operationProductInComponent.operationComponent = registry.technologyOperationComponent "); query.append("and operationProductInComponent.product = registry.product order by operationProductInComponent.priority "); return dataDefinitionService.get(OrderSuppliesConstants.PLUGIN_IDENTIFIER, "coverageRegister").find(query.toString()) .setParameter("orderId", order.getId()).list().getEntities(); }
private Optional<Entity> getGenerateingMRC() { SearchCriteriaBuilder searchCriteriaBuilder = dataDefinitionService.get(OrderSuppliesConstants.PLUGIN_IDENTIFIER, OrderSuppliesConstants.MODEL_MATERIAL_REQUIREMENT_COVERAGE).find(); searchCriteriaBuilder.add(SearchRestrictions.eq("orderGenerationInProgress", true)); List<Entity> entities = searchCriteriaBuilder.list().getEntities(); if (entities.isEmpty()) { return Optional.absent(); } else { return Optional.of(entities.get(0)); } }
public List<Long> getRegisterOrderProductsIds(final List<Entity> order) { List<Long> orderIds = order.stream().map(o -> o.getId()).collect(Collectors.toList()); List<Entity> entries = dataDefinitionService .get(OrderSuppliesConstants.PLUGIN_IDENTIFIER, OrderSuppliesConstants.MODEL_COVERAGE_REGISTER).find() .createAlias(CoverageRegisterFields.ORDER, "ord", JoinType.LEFT) .add(SearchRestrictions.in("ord.id", Lists.newArrayList(orderIds))).list().getEntities(); return entries.stream().map(r -> r.getBelongsToField(CoverageRegisterFields.PRODUCT).getId()) .collect(Collectors.toList()); }
private Date findCalculatedStartAllOrders(final Entity order) { List<Entity> ordersTimeCalculations = dataDefinitionService .get(TimeNormsConstants.PLUGIN_PRODUCTION_SCHEDULING_IDENTIFIER, TimeNormsConstants.MODEL_ORDER_TIME_CALCULATION) .find().createAlias("order", "ord", JoinType.LEFT) .add(SearchRestrictions.in("ord.id", getOrderAndSubOrders(order.getId()).stream().map(entity -> entity.getId()).collect(Collectors.toList()))) .list().getEntities(); return ordersTimeCalculations.stream().map(e -> e.getDateField(OrderTimeCalculationFields.EFFECTIVE_DATE_FROM)) .min(Comparator.<Date>naturalOrder()).get(); }
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)); }
public List<Entity> findFinalProductsForTechnology(final Long technologyId) { List<Entity> intermediateOutProducts = dataDefinitionService .get(TechnologiesConstants.PLUGIN_IDENTIFIER, TechnologiesConstants.MODEL_OPERATION_PRODUCT_OUT_COMPONENT) .find(finalHQL) .setLong(L_TECHNOLOGY_ID, technologyId).list().getEntities(); return intermediateOutProducts; }
public Optional<Entity> findStorageLocationForProduct(final Entity product, final Entity location) { SearchCriteriaBuilder scb = getStorageLocationDD().find(); scb.add(SearchRestrictions.belongsTo(StorageLocationFields.PRODUCT, product)); scb.add(SearchRestrictions.belongsTo(StorageLocationFields.LOCATION, location)); return Optional.ofNullable(scb.setMaxResults(1).uniqueResult()); }
public Entity findOrderForTechnology(Entity technology) { String sql = "select o from #orders_order o left join o.technology tech where tech.id = :technologyID"; return dataDefinitionService.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER).find(sql) .setParameter("technologyID", technology.getId()).setMaxResults(1).uniqueResult(); }
public Long getPpsIdForOrder(final Long orderId) { DataDefinition ppsDateDef = getProductionPerShiftDD(); String query = "select id as ppsId from #productionPerShift_productionPerShift where order.id = :orderId"; Entity projectionResults = ppsDateDef.find(query).setLong("orderId", orderId).setMaxResults(1).uniqueResult(); if (projectionResults == null) { return null; } return (Long) projectionResults.getField("ppsId"); }
private Entity getDictionaryItemWithProductionOnLine() { Entity occupationTypeDictionary = dataDefinitionService .get(QcadooModelConstants.PLUGIN_IDENTIFIER, QcadooModelConstants.MODEL_DICTIONARY).find() .add(SearchRestrictions.eq(DictionaryFields.NAME, L_OCCUPATION_TYPE)).uniqueResult(); return dataDefinitionService.get(QcadooModelConstants.PLUGIN_IDENTIFIER, QcadooModelConstants.MODEL_DICTIONARY_ITEM) .find().add(SearchRestrictions.belongsTo(DictionaryItemFields.DICTIONARY, occupationTypeDictionary)) .add(SearchRestrictions.eq(DictionaryItemFields.TECHNICAL_CODE, OccupationType.WORK_ON_LINE.getStringValue())) .uniqueResult(); }
private List<Entity> findReservationsForDelivery(final Entity delivery) { String query = buildQueryForDeliveredProductReservations(delivery); return dataDefinitionService .get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_DELIVERED_PRODUCT_RESERVATION).find(query) .setParameter(DELIVER_ID, delivery.getId()).list().getEntities(); }
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; }
@Override public Entity findMergedByOperationComponent(Entity operationComponent) { return mergesProductInDD().find() .add(SearchRestrictions.and( SearchRestrictions.belongsTo(TechnologyOperationComponentMergeProductFields.OPERATION_COMPONENT, operationComponent), SearchRestrictions.belongsTo(TechnologyOperationComponentMergeProductFields.MERGED_OPERATION_COMPONENT, operationComponent))) .uniqueResult(); }
public void updateRequestForQuotationsNumber(final DataDefinition negotiationProductDD, final Entity negotiationProduct) { Entity negotiation = negotiationProduct.getBelongsToField(NEGOTIATION); Entity product = negotiationProduct.getBelongsToField(PRODUCT); if (product != null) { int requestForQuotationsNumber = supplyNegotiationsService.getRequestForQuotationProductDD().find() .createAlias(REQUEST_FOR_QUOTATION, REQUEST_FOR_QUOTATION) .add(SearchRestrictions.belongsTo(PRODUCT, product)) .add(SearchRestrictions.belongsTo(REQUEST_FOR_QUOTATION + "." + NEGOTIATION, negotiation)).list() .getEntities().size(); negotiationProduct.setField(REQUEST_FOR_QUOTATIONS_NUMBER, requestForQuotationsNumber); } }
@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(); }
public List<Entity> getAssignmentToShift(final Entity assignmentToShiftReport) { return dataDefinitionService .get(AssignmentToShiftConstants.PLUGIN_IDENTIFIER, AssignmentToShiftConstants.MODEL_ASSIGNMENT_TO_SHIFT) .find() .add(SearchRestrictions.belongsTo(AssignmentToShiftFields.SHIFT, assignmentToShiftReport.getBelongsToField(AssignmentToShiftReportFields.SHIFT))) .add(SearchRestrictions.belongsTo(AssignmentToShiftFields.FACTORY, assignmentToShiftReport.getBelongsToField(AssignmentToShiftReportFields.FACTORY))).list().getEntities(); }
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 List<Entity> getTransferTemplates(final Entity locationFrom, final Entity locationTo) { return dataDefinitionService .get(MaterialFlowMultitransfersConstants.PLUGIN_IDENTIFIER, MaterialFlowMultitransfersConstants.MODEL_TRANSFER_TEMPLATE).find().createAlias(PRODUCT, PRODUCT) .add(SearchRestrictions.belongsTo(LOCATION_FROM, locationFrom)) .add(SearchRestrictions.belongsTo(LOCATION_TO, locationTo)).addOrder(SearchOrders.asc(PRODUCT + "." + NAME)) .list().getEntities(); }
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(); }