AbstractManagedType<X> managedType = (AbstractManagedType<X>) managedTypeField.get(builder); Assert.assertNotNull(managedType); Assert.assertEquals(clazz, ((EntityType<X>) managedType).getBindableJavaType()); Assert.assertEquals(BindableType.ENTITY_TYPE, ((EntityType<X>) managedType).getBindableType()); Assert.assertEquals(PersistenceType.ENTITY, ((EntityType<X>) managedType).getPersistenceType());
/** * Assert on managed type. * * @param <X> * the generic type * @param builder * the builder * @param managedTypeField * the managed type field * @param clazz * the clazz * @return the abstract managed type * @throws IllegalAccessException * the illegal access exception */ @SuppressWarnings({ "rawtypes", "unchecked" }) private <X> AbstractManagedType<X> assertOnManagedType(MetaModelBuilder builder, Field managedTypeField, Class<?> clazz) throws IllegalAccessException { log.info("Assert on managedType"); AbstractManagedType<X> managedType = (AbstractManagedType<X>) managedTypeField.get(builder); Assert.assertNotNull(managedType); Assert.assertEquals(clazz, ((EntityType<X>) managedType).getBindableJavaType()); Assert.assertEquals(BindableType.ENTITY_TYPE, ((EntityType<X>) managedType).getBindableType()); Assert.assertEquals(PersistenceType.ENTITY, ((EntityType<X>) managedType).getPersistenceType()); Assert.assertEquals(clazz.getSimpleName(), ((EntityType<X>) managedType).getName()); Assert.assertNotSame(clazz.getDeclaredFields().length, managedType.getSingularAttributes().size()); Assert.assertEquals(3, managedType.getSingularAttributes().size()); return managedType; }
/** * {@inheritDoc} */ @Override protected synchronized void initializeMetadata(Collection<Class<?>> types) { LOG.info("Initializing JPA Metadata from " + entityManager); masterMetadataMap.clear(); // QUESTION: When is JPA loaded so this service can initialize itself? // Build and store the map for ( IdentifiableType<?> identifiableType : entityManager.getMetamodel().getEntities() ) { //Only extract the metadata if EntityType and not a MappedSuperClass if(identifiableType instanceof EntityType<?>){ EntityType<?> type = (EntityType<?>)identifiableType; try { masterMetadataMap.put(type.getBindableJavaType(), getMetadataForClass(type.getBindableJavaType())); if (LOG.isDebugEnabled()) { LOG.debug("Added Metadata For: " + type.getBindableJavaType()); } } catch (Exception ex) { LOG.error("Error obtaining JPA metadata for type: " + type.getJavaType(), ex); } } } }
@Override public void afterPropertiesSet() throws Exception { Set<EntityType<?>> entities = entityManager.getMetamodel().getEntities(); // key:table,value:EntityClass entities.forEach(e -> entityMap.put(e.getName(), e.getBindableJavaType().getName())); }
/** * Add a query root corresponding to the given entity, forming a Cartesian * product with any existing roots. * * @param entity * metamodel entity representing the entity of type X * @return query root corresponding to the given entity */ public Root internalFrom(EntityType entity) { RootImpl root = new RootImpl(entity, this.metamodel, entity.getBindableJavaType(), new ExpressionBuilder(entity.getBindableJavaType()), entity); integrateRoot(root); return root; }
.getBindableJavaType()) && !AbstractComponent.class.isAssignableFrom(type .getBindableJavaType())) { continue; if (AbstractComponent.class.isAssignableFrom(type.getBindableJavaType())) { if (terminology != null) {
public <T extends Identifiable<?>> Predicate byExampleOnEntity(Root<T> rootPath, T entityValue, SearchParameters sp, CriteriaBuilder builder) { if (entityValue == null) { return null; } Class<T> type = rootPath.getModel().getBindableJavaType(); ManagedType<T> mt = em.getMetamodel().entity(type); List<Predicate> predicates = newArrayList(); predicates.addAll(byExample(mt, rootPath, entityValue, sp, builder)); predicates.addAll(byExampleOnCompositePk(rootPath, entityValue, sp, builder)); return jpaUtil.orPredicate(builder, predicates); }
public <T extends Identifiable<?>> Predicate byExampleOnEntity(Root<T> rootPath, T entityValue, SearchParameters sp, CriteriaBuilder builder) { if (entityValue == null) { return null; } Class<T> type = rootPath.getModel().getBindableJavaType(); ManagedType<T> mt = em.getMetamodel().entity(type); List<Predicate> predicates = newArrayList(); predicates.addAll(byExample(mt, rootPath, entityValue, sp, builder)); predicates.addAll(byExampleOnCompositePk(rootPath, entityValue, sp, builder)); return jpaUtil.orPredicate(builder, predicates); }
public <T extends Identifiable<?>> Predicate byExampleOnEntity(Root<T> rootPath, T entityValue, CriteriaBuilder builder, SearchParameters sp) { if (entityValue == null) { return null; } Class<T> type = rootPath.getModel().getBindableJavaType(); ManagedType<T> mt = em.getMetamodel().entity(type); List<Predicate> predicates = newArrayList(); predicates.addAll(byExample(mt, rootPath, entityValue, sp, builder)); predicates.addAll(byExampleOnCompositePk(rootPath, entityValue, sp, builder)); predicates.addAll(byExampleOnXToOne(mt, rootPath, entityValue, sp, builder)); // 1 level deep only predicates.addAll(byExampleOnXToMany(mt, rootPath, entityValue, sp, builder)); return jpaUtil.concatPredicate(sp, builder, predicates); }
public <T extends Identifiable<?>> Predicate byExampleOnEntity(Root<T> rootPath, T entityValue, CriteriaBuilder builder, SearchParameters sp) { if (entityValue == null) { return null; } Class<T> type = rootPath.getModel().getBindableJavaType(); ManagedType<T> mt = em.getMetamodel().entity(type); List<Predicate> predicates = newArrayList(); predicates.addAll(byExample(mt, rootPath, entityValue, sp, builder)); predicates.addAll(byExampleOnCompositePk(rootPath, entityValue, sp, builder)); predicates.addAll(byExampleOnXToOne(mt, rootPath, entityValue, sp, builder)); // 1 level deep only predicates.addAll(byExampleOnXToMany(mt, rootPath, entityValue, sp, builder)); return jpaUtil.concatPredicate(sp, builder, predicates); }
EntityType<T> entityType = from.getModel(); try { Field sortField = getSortAnnotation(entityType.getBindableJavaType()); if (sortField == null) query.orderBy(criteriaBuilder.asc(from.get(entityType.getId(entityType.getIdType().getJavaType()).getName())));
metadata.setPrimaryKeyAttributeNames(getPrimaryKeyAttributeNames(entityType)); } catch (RuntimeException ex) { LOG.error("Error processing PK metadata for " + entityType.getBindableJavaType().getName()); throw new RuntimeException( "Error processing PK metadata for " + entityType.getBindableJavaType().getName(), ex); LOG.error("Error processing attribute metadata for " + entityType.getBindableJavaType().getName()); throw ex; metadata.setCollections(getCollectionsFromMetadata((Set) entityType.getPluralAttributes())); } catch (RuntimeException ex) { LOG.error("Error processing collection metadata for " + entityType.getBindableJavaType().getName()); throw ex; metadata.setRelationships(relationships); } catch (RuntimeException ex) { LOG.error("Error processing relationship metadata for " + entityType.getBindableJavaType().getName()); throw ex;
/** * if query orders are empty, then apply default ascending ordering * by root id attribute to prevent paging inconsistencies * * @param query * @param from * @param cb */ protected void mayBeAddDefaultOrderBy(CriteriaQuery<?> query, From<?,?> from, CriteriaBuilder cb) { if (query.getOrderList() == null || query.getOrderList().isEmpty()) { EntityType<?> fromEntityType = entityType; try { java.lang.reflect.Field sortField = getSortAnnotation(fromEntityType.getBindableJavaType()); if (sortField == null) query.orderBy(cb.asc(from.get(fromEntityType.getId(fromEntityType.getIdType().getJavaType()).getName()))); else { GraphQLDefaultOrderBy order = sortField.getAnnotation(GraphQLDefaultOrderBy.class); if (order.asc()) { query.orderBy(cb.asc(from.get(sortField.getName()))); } else { query.orderBy(cb.desc(from.get(sortField.getName()))); } } } catch (Exception ex) { //log.warn("In" + this.getClass().getName(), ex); } } }