/** * Determine whether the given property is not persistent. Inverse of {@link #isPersistent(MetaProperty)}. */ public boolean isNotPersistent(MetaProperty metaProperty) { return !isPersistent(metaProperty); }
/** * Determine whether the given property is not persistent. Inverse of {@link #isPersistent(MetaClass, MetaProperty)}. */ public boolean isNotPersistent(MetaClass metaClass, MetaProperty metaProperty) { return !isPersistent(metaClass, metaProperty); }
/** * DEPRECATED! * Use {@link #isNotPersistent(MetaProperty)}. */ @Deprecated public boolean isTransient(MetaProperty metaProperty) { return !isPersistent(metaProperty); } }
public boolean isPersistent() { MetadataTools metadataTools = AppBeans.get(MetadataTools.NAME); return metadataTools.isPersistent(property); } }
/** * @return name of a data store of the given entity or null if the entity is not persistent and no data store is * defined for it */ @Nullable public String getStoreName(MetaClass metaClass) { String storeName = (String) metaClass.getAnnotations().get(STORE_ANN_NAME); if (storeName == null) { return isPersistent(metaClass) ? Stores.MAIN : null; } else return storeName; }
/** * Determine whether the given property is persistent, that is managed by ORM. */ public boolean isPersistent(MetaClass metaClass, MetaProperty metaProperty) { Objects.requireNonNull(metaClass, "metaClass is null"); Objects.requireNonNull(metaProperty, "metaProperty is null"); return isPersistent(metaClass) && Boolean.TRUE.equals(metaProperty.getAnnotations().get(PERSISTENT_ANN_NAME)); }
/** * Determine whether all the properties defined by the given property path are persistent. * * @see #isPersistent(com.haulmont.chile.core.model.MetaProperty) */ public boolean isPersistent(MetaPropertyPath metaPropertyPath) { Objects.requireNonNull(metaPropertyPath, "metaPropertyPath is null"); for (MetaProperty metaProperty : metaPropertyPath.getMetaProperties()) { if (!isPersistent(metaProperty)) return false; } return true; }
/** * @return collection of all persistent entities */ public Collection<MetaClass> getAllPersistentMetaClasses() { Set<MetaClass> result = new LinkedHashSet<>(); for (MetaClass metaClass : metadata.getSession().getClasses()) { if (isPersistent(metaClass)) { result.add(metaClass); } } return result; }
protected boolean propertyWritingAllowed(MetaProperty metaProperty, Entity entity) { return !"id".equals(metaProperty.getName()) && (DynamicAttributesUtils.isDynamicAttribute(metaProperty) || (entity instanceof AbstractNotPersistentEntity) || !metadataTools.isPersistent(metaProperty) || (metadataTools.isPersistent(metaProperty) && PersistenceHelper.isLoaded(entity, metaProperty.getName()))); }
protected void addSystemPropertiesFrom(Class<?> baseClass, Class<?> entityClass, MetaClass metaClass, Metadata metadata, Set<String> result) { if (baseClass.isAssignableFrom(entityClass)) { MetadataTools metadataTools = metadata.getTools(); for (String property : getInterfaceProperties(baseClass)) { MetaProperty metaProperty = metaClass.getProperty(property); if (metaProperty != null && metadataTools.isPersistent(metaProperty)) { result.add(property); } } } }
/** * Determine whether the given class represents a persistent entity. * <p> * A persistent entity is an entity that is managed by ORM (i.e. registered in a persistence.xml file) * and is not a MappedSuperclass or Embeddable. */ public boolean isPersistent(Class aClass) { checkNotNullArgument(aClass, "class is null"); return isPersistent(metadata.getClassNN(aClass)); }
protected String getEntityNameForIdGeneration(MetaClass metaClass) { List<MetaClass> persistentAncestors = metaClass.getAncestors().stream() .filter(mc -> tools.isPersistent(mc)) // filter out all mapped superclasses .collect(Collectors.toList()); if (persistentAncestors.size() > 0) { MetaClass root = persistentAncestors.get(persistentAncestors.size() - 1); Class<?> javaClass = root.getJavaClass(); Inheritance inheritance = javaClass.getAnnotation(Inheritance.class); if (inheritance == null || inheritance.strategy() != InheritanceType.TABLE_PER_CLASS) { // use root of inheritance tree if the strategy is JOINED or SINGLE_TABLE because ID is stored in the root table return root.getName(); } } return metaClass.getName(); }
/** * Determine whether the given property is not persistent. Inverse of {@link #isPersistent(MetaClass, MetaProperty)}. * <p> * For objects and properties not registered in metadata this method returns {@code true}. */ public boolean isNotPersistent(Object object, String property) { Objects.requireNonNull(object, "object is null"); MetaClass metaClass = metadata.getSession().getClass(object.getClass()); if (metaClass == null) return true; MetaProperty metaProperty = metaClass.getProperty(property); return metaProperty == null || !isPersistent(metaClass, metaProperty); }
@Nullable public String getDatabaseColumn(MetaProperty metaProperty) { if (!isPersistent(metaProperty)) return null; Column column = metaProperty.getAnnotatedElement().getAnnotation(Column.class); if (column != null) { return StringUtils.isEmpty(column.name()) ? metaProperty.getName() : column.name(); } JoinColumn joinColumn = metaProperty.getAnnotatedElement().getAnnotation(JoinColumn.class); if (joinColumn != null) { return StringUtils.isEmpty(joinColumn.name()) ? metaProperty.getName() : joinColumn.name(); } return null; }
protected boolean isPropertyAllowed(MetaClass metaClass, MetaProperty property) { return security.isEntityAttrPermitted(metaClass, property.getName(), EntityAttrAccess.VIEW) && !metadataTools.isSystemLevel(property) // exclude system level attributes && (metadataTools.isPersistent(property) // exclude transient properties || (metadataTools.getCrossDataStoreReferenceIdProperty(storeName, property) != null)) && !defaultExcludedProps.contains(property.getName()) && !(byte[].class.equals(property.getJavaType())) && !property.getRange().getCardinality().isMany(); // exclude ToMany }
private void setMultipleTableConstraintDependency(MetaClass metaClass, ClassDescriptor desc) { InheritancePolicy policy = desc.getInheritancePolicyOrNull(); if (policy != null && policy.isJoinedStrategy() && policy.getParentClass() != null) { boolean hasOneToMany = metaClass.getOwnProperties().stream().anyMatch(metaProperty -> metadata.getTools().isPersistent(metaProperty) && metaProperty.getRange().isClass() && metaProperty.getRange().getCardinality() == Range.Cardinality.ONE_TO_MANY); if (hasOneToMany) { desc.setHasMultipleTableConstraintDependecy(true); } } }
@Override public void refresh() { backgroundWorker.checkUIAccess(); State prevState = state; if (!prevState.equals(State.VALID)) { state = State.VALID; fireStateChanged(prevState); } if (item != null && metadata.getTools().isPersistent(item.getClass())) { T prevItem = item; T reloadedItem = dataSupplier.reload(item, view); __setItem(reloadedItem); fireItemChanged(prevItem); } }
protected void addAttributesToLocalView(MetaClass metaClass, View view) { for (MetaProperty property : metaClass.getProperties()) { if (!property.getRange().isClass() && !metadata.getTools().isSystem(property) && metadata.getTools().isPersistent(property)) { view.addProperty(property.getName()); } } }
@Override protected boolean isLoadedSpecificCheck(Object entity, String property, MetaClass metaClass, MetaProperty metaProperty) { if (metadataTools.isEmbeddable(metaClass) || (entity instanceof BaseGenericIdEntity && BaseEntityInternalAccess.isNew((BaseGenericIdEntity) entity))) { //TODO eude: // this is workaround for unexpected EclipseLink behaviour when PersistenceUnitUtil.isLoaded // throws exception if embedded entity refers to persistent entity return checkIsLoadedWithGetter(entity, property); } if (!metadataTools.isPersistent(metaClass)) { return checkIsLoadedWithGetter(entity, property); } EntityManagerFactory jpaEmf = ((PersistenceImpl) persistence).getJpaEmf(metadataTools.getStoreName(metaClass)); return jpaEmf.getPersistenceUnitUtil().isLoaded(entity, property); } }
public DomainModel produce() { Collection<MetaClass> classes = metadata.getSession().getClasses(); DomainModel result = new DomainModel(extendedEntities, metadata); EntityBuilder builder = new EntityBuilder(); for (MetaClass aClass : classes) { builder.startNewEntity(aClass.getName()); Collection<MetaProperty> props = aClass.getProperties(); for (MetaProperty prop : props) { if (metadataTools.isPersistent(prop)) addProperty(builder, aClass, prop); } JpqlEntityModel entity = builder.produce(); result.add(entity); } return result; }