protected List<String> getEffectiveEntities(String entitiesList) { List<String> effectiveEntities = new ArrayList<>(); if (StringUtils.isNotBlank(entitiesList)) { for (String className : Arrays.asList(StringUtils.split(entitiesList, ','))) { MetaClass clazz = metadata.getClassNN(className); effectiveEntities.add(extendedEntities.getEffectiveMetaClass(clazz).getName()); } } return effectiveEntities; }
/** * @return original meta class or received meta class if it's not extended */ public MetaClass getOriginalOrThisMetaClass(MetaClass metaClass) { MetaClass originalMetaClass = getOriginalMetaClass(metaClass); return originalMetaClass != null ? originalMetaClass : metaClass; }
public TreeMap<String, String> getEntityMetaClasses() { TreeMap<String, String> options = new TreeMap<>(); for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { if (metadata.getExtendedEntities().getExtendedClass(metaClass) == null) { MetaClass originalMetaClass = metadata.getExtendedEntities().getOriginalOrThisMetaClass(metaClass); String originalName = originalMetaClass.getName(); Class javaClass = originalMetaClass.getJavaClass(); if (metadata.getTools().hasCompositePrimaryKey(metaClass) && !HasUuid.class.isAssignableFrom(javaClass)) { continue; } String caption = messages.getMessage(javaClass, javaClass.getSimpleName()) + " (" + originalName + ")"; options.put(caption, originalName); } } return options; }
protected void initEntityTypeField() { final ExtendedEntities extendedEntities = metadata.getExtendedEntities(); Map<String, MetaClass> options = new TreeMap<>();//the map sorts meta classes by the string key for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { if (metadata.getTools().hasCompositePrimaryKey(metaClass) && !HasUuid.class.isAssignableFrom(metaClass.getJavaClass())) { continue; } options.put(messageTools.getDetailedEntityCaption(metaClass), metaClass); } entityType.setOptionsMap(options); if (category.getEntityType() != null) { entityType.setValue(extendedEntities.getEffectiveMetaClass( extendedEntities.getEffectiveClass(category.getEntityType()))); } entityType.addValueChangeListener(e -> { MetaClass metaClass = (MetaClass) e.getValue(); MetaClass originalClass = extendedEntities.getOriginalMetaClass(metaClass); category.setEntityType(originalClass == null ? metaClass.getName() : originalClass.getName()); }); }
protected void registerPrimaryEditor(WindowInfo windowInfo, AnnotationMetadata annotationMetadata) { Map<String, Object> primaryEditorAnnotation = annotationMetadata.getAnnotationAttributes(PrimaryEditorScreen.class.getName()); if (primaryEditorAnnotation != null) { Class entityClass = (Class) primaryEditorAnnotation.get("value"); if (entityClass != null) { MetaClass metaClass = metadata.getClass(entityClass); MetaClass originalMetaClass = metadata.getExtendedEntities().getOriginalOrThisMetaClass(metaClass); primaryEditors.put(originalMetaClass.getJavaClass(), windowInfo); } } }
if (metadata.getExtendedEntities().getExtendedClass(metaClass) != null) { continue; MetaClass originalMetaClass = metadata.getExtendedEntities().getOriginalMetaClass(metaClass); String entityName = originalMetaClass == null ? name : originalMetaClass.getName();
@Nullable protected Class getEffectiveResultClass() { if (resultClass == null) { return null; } if (Entity.class.isAssignableFrom(resultClass)) { return metadata.getExtendedEntities().getEffectiveClass(resultClass); } return resultClass; }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param originalMetaClass original entity * @return extended or original entity */ public Class getEffectiveClass(MetaClass originalMetaClass) { Class extClass = getExtendedClass(originalMetaClass); return extClass == null ? originalMetaClass.getJavaClass() : extClass; }
MetaClass effectiveMetaClass = session.getClass(extendedEntities.getEffectiveClass(metaClass)); Class effectiveDomainClass = extendedEntities.getEffectiveClass(metaProperty.getDomain()); MetaClass effectiveDomainMeta = session.getClass(effectiveDomainClass); if (metaProperty.getDomain() != effectiveDomainMeta) { Class effectiveRangeClass = extendedEntities.getEffectiveClass(range.asClass()); MetaClass effectiveRangeMeta = session.getClass(effectiveRangeClass); if (effectiveRangeMeta != range.asClass()) { extendedEntities.registerReplacedMetaClass(replacedMetaClass);
/** * Searches for an original entity for the provided extended entity. * * @param extendedMetaClass extended entity * @return original entity or null if the provided entity is not an extension */ @Nullable public MetaClass getOriginalMetaClass(MetaClass extendedMetaClass) { Class originalClass = getOriginalClass(extendedMetaClass); if (originalClass == null) { return null; } MetaClass metaClass = replacedMetaClasses.get(originalClass); if (metaClass != null) { return metaClass; } return metadata.getSession().getClassNN(originalClass); }
protected void registerPrimaryLookup(WindowInfo windowInfo, AnnotationMetadata annotationMetadata) { Map<String, Object> primaryEditorAnnotation = annotationMetadata.getAnnotationAttributes(PrimaryLookupScreen.class.getName()); if (primaryEditorAnnotation != null) { Class entityClass = (Class) primaryEditorAnnotation.get("value"); if (entityClass != null) { MetaClass metaClass = metadata.getClass(entityClass); MetaClass originalMetaClass = metadata.getExtendedEntities().getOriginalOrThisMetaClass(metaClass); primaryLookups.put(originalMetaClass.getJavaClass(), windowInfo); } } }
Map<String, Object> options = new TreeMap<>(); for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { if (metadata.getExtendedEntities().getExtendedClass(metaClass) == null) { MetaClass originalMetaClass = metadata.getExtendedEntities().getOriginalMetaClass(metaClass); String originalName = originalMetaClass == null ? metaClass.getName() : originalMetaClass.getName(); options.put(messages.getTools().getEntityCaption(metaClass) + " (" + metaClass.getName() + ")", originalName);
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param originalClass original entity * @return extended or original entity */ public Class getEffectiveClass(Class originalClass) { return getEffectiveClass(metadata.getSession().getClassNN(originalClass)); }
public Collection<MetaClassInfo> getAllMetaClassesInfo() { Set<MetaClass> metaClasses = new HashSet<>(metadata.getTools().getAllPersistentMetaClasses()); metaClasses.addAll(metadata.getTools().getAllEmbeddableMetaClasses()); return metaClasses.stream() .filter(metaClass -> metadata.getExtendedEntities().getExtendedClass(metaClass) == null) .map(MetaClassInfo::new) .collect(Collectors.toList()); }
protected String getSystemAttributeDescription(MetaClass metaClass, MetaProperty metaProperty) { String localizedCaption = getPropertyCaption(metaClass, metaProperty); Class originalClass = extendedEntities.getOriginalClass(metaClass); Class<?> ownClass = originalClass != null ? originalClass : metaClass.getJavaClass(); String key = ownClass.getSimpleName() + "." + metaProperty.getName(); return key.equals(localizedCaption) ? null : String.format("%s (%s)", metaProperty.getName(), localizedCaption); }
@Override public void setup(DsContext dsContext, DataSupplier dataSupplier, String id, MetaClass metaClass, @Nullable View view) { Preconditions.checkNotNullArgument(metaClass, "metaClass is null"); this.id = id; this.dsContext = dsContext; this.dataSupplier = dataSupplier; this.metaClass = metadata.getExtendedEntities().getEffectiveMetaClass(metaClass); this.view = view; }
@Nullable protected MetaClass resolveTargetMetaClass(MetaClass metaClass) { if (metaClass == null) { return null; } MetaClass targetMetaClass = metadata.getExtendedEntities().getOriginalMetaClass(metaClass); if (targetMetaClass == null) { targetMetaClass = metaClass; } return targetMetaClass; }
protected List<ConstraintData> getConstraints(MetaClass metaClass) { UserSession userSession = userSessionSource.getUserSession(); MetaClass mainMetaClass = extendedEntities.getOriginalOrThisMetaClass(metaClass); List<ConstraintData> constraints = new ArrayList<>(); constraints.addAll(userSession.getConstraints(mainMetaClass.getName())); for (MetaClass parent : mainMetaClass.getAncestors()) { constraints.addAll(userSession.getConstraints(parent.getName())); } return constraints; }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param originalMetaClass original entity * @return extended or original entity */ public MetaClass getEffectiveMetaClass(MetaClass originalMetaClass) { if (originalMetaClass instanceof KeyValueMetaClass) return originalMetaClass; return metadata.getSession().getClassNN(getEffectiveClass(originalMetaClass)); }
entities = new HashMap<>(); for (MetaClass metaClass : metadata.getSession().getClasses()) { if (extendedEntities.getExtendedClass(metaClass) == null && BaseGenericIdEntity.class.isAssignableFrom(metaClass.getJavaClass())) { if (!isUnavailableInSecurityConstraints(metaClass)) { MetaClass mainMetaClass = extendedEntities.getOriginalOrThisMetaClass(metaClass); String originalName = mainMetaClass.getName(); options.put(messageTools.getEntityCaption(metaClass) + " (" + metaClass.getName() + ")", originalName);