protected Map<String, Path> generateEntitiesPaths() { Map<String, Path> paths = new LinkedHashMap<>(); for (MetaClass metaClass : metadataTools.getAllPersistentMetaClasses()) { if (metadataTools.isSystemLevel(metaClass)) { continue; } paths.putAll(generateEntityPaths(metaClass)); } return paths; }
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 void loadAllPersistentClasses() { List<MetaClass> metaClasses = new ArrayList<>(metadata.getTools().getAllPersistentMetaClasses()); metaClassLookup.setOptionsList(metaClasses); }
@EventListener(AppContextInitializedEvent.class) @Order(Events.HIGHEST_PLATFORM_PRECEDENCE + 300) protected void init() { ClientConfig clientConfig = configuration.getConfig(ClientConfig.class); String property = clientConfig.getScreenIdsToSaveHistory(); if (StringUtils.isNotBlank(property)) { screenIds.addAll(Arrays.asList(StringUtils.split(property, ','))); } for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { Map<String, Object> attributes = metadata.getTools().getMetaAnnotationAttributes(metaClass.getAnnotations(), TrackEditScreenHistory.class); if (Boolean.TRUE.equals(attributes.get("value"))) { screenIds.add(windowConfig.getEditorScreenId(metaClass)); } } }
protected Map<String, Object> getEntitiesLookupFieldOptions() { Map<String, Object> options = new TreeMap<>(); for (MetaClass metaClass : metadataTools.getAllPersistentMetaClasses()) { if (SoftDelete.class.isAssignableFrom(metaClass.getJavaClass())) { Boolean enableRestore = (Boolean) metadataTools .getMetaAnnotationAttributes(metaClass.getAnnotations(), EnableRestore.class) .get("value"); if (enableRestore == null || enableRestore) { options.put(messageTools.getEntityCaption(metaClass) + " (" + metaClass.getName() + ")", metaClass); } } } return options; } }
protected Map<String, MetaClass> getAvailableEntities() { Map<String, MetaClass> result = new TreeMap<>(String::compareTo); Collection<MetaClass> classes = wizard.metadataTools.getAllPersistentMetaClasses(); for (MetaClass metaClass : classes) { MetaClass effectiveMetaClass = wizard.metadata.getExtendedEntities().getEffectiveMetaClass(metaClass); if (!wizard.reportWizardService.isEntityAllowedForReportWizard(effectiveMetaClass)) { continue; } result.put(wizard.messageTools.getEntityCaption(effectiveMetaClass) + " (" + effectiveMetaClass.getName() + ")", effectiveMetaClass); } return result; } }
protected Map<String, MetaClass> getEntitiesLookupFieldOptions() { Map<String, MetaClass> options = new TreeMap<>(); for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { if (readPermitted(metaClass)) { Class javaClass = metaClass.getJavaClass(); if (Entity.class.isAssignableFrom(javaClass)) { options.put(messages.getTools().getEntityCaption(metaClass) + " (" + metaClass.getName() + ")", metaClass); } } } return options; }
protected List<Tag> generateTags() { List<Tag> tags = new ArrayList<>(); List<Tag> entityTags = metadataTools.getAllPersistentMetaClasses() .stream() .filter(mc -> !metadataTools.isSystemLevel(mc))
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; }
Set<String> addedEnums = new HashSet<>(); Set<MetaClass> metas = new HashSet<>(metadataTools.getAllPersistentMetaClasses()); metas.addAll(metadataTools.getAllEmbeddableMetaClasses()); for (MetaClass meta : metas) {
protected void initEntityTypeField() { Map<String, MetaClass> metaClasses = new LinkedHashMap<>(); for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { metaClasses.put(metaClass.getName(), metaClass); } entitiesMetaClasses.setOptionsMap(metaClasses); entitiesMetaClasses.addValueChangeListener(e -> { setEntityViewsLookup(); String entitiesMetaClass = ((MetaClass) entitiesMetaClasses.getValue()).getName(); if (entitiesMetaClass != null) { setSimpleQuery(entitiesMetaClass); } }); }
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()); }); }
Object selectedItem = null; if (ParamType.ENTITY.equals(typeSelect.getValue())) { for (MetaClass metaClass : metadataTools.getAllPersistentMetaClasses()) { if (!metadataTools.isSystemLevel(metaClass)) { items.put(messageTools.getEntityCaption(metaClass) + " (" + metaClass.getName() + ")", metaClass);
@Override public Component generateField(Datasource datasource, String propertyId) { entityNameLookup = componentsFactory.createComponent(LookupField.class); Collection<MetaClass> persistentMetaClasses = metadata.getTools().getAllPersistentMetaClasses(); entityNameLookup.setOptionsList(new ArrayList<>(persistentMetaClasses)); entityNameLookup.setValue(metadata.getClass(getItem().getEntityName())); entityNameLookup.addValueChangeListener(e -> { if (e.getValue() != null) { MetaClass metaClass = (MetaClass) e.getValue(); getItem().setEntityName(metaClass.getName()); fieldGroup.setFieldValue("entity", null); entityIdPickerField.setMetaClass(metaClass); entityIdPickerField.setEditable(false); } else { getItem().setEntityName(null); } fieldGroup.setFieldValue("entity", null); entityIdPickerField.setEditable(e.getValue() != null); }); return entityNameLookup; } });
for (MetaClass metaClass : metadataTools.getAllPersistentMetaClasses()) { if (!metadataTools.isSystemLevel(metaClass)) { if (metadata.getTools().hasCompositePrimaryKey(metaClass) && !HasUuid.class.isAssignableFrom(metaClass.getJavaClass())) {
@Override public void init(Map<String, Object> params) { Map<String, Object> options = new TreeMap<>(); for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { if (metadata.getExtendedEntities().getExtendedClass(metaClass) == null) { MetaClass originalMetaClass = metadata.getExtendedEntities().getOriginalMetaClass(metaClass);