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; }
@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; }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param entityName original entity * @return extended or original entity */ public MetaClass getEffectiveMetaClass(String entityName) { return getEffectiveMetaClass(metadata.getSession().getClassNN(entityName)); }
@Nullable @Override public <T extends Entity<K>, K> T find(Class<T> entityClass, K id, View... views) { Preconditions.checkNotNullArgument(entityClass, "entityClass is null"); Preconditions.checkNotNullArgument(id, "id is null"); MetaClass metaClass = metadata.getExtendedEntities().getEffectiveMetaClass(entityClass); return findWithViews(metaClass, id, Arrays.asList(views)); }
@Override public MetaClass getMetaClass() { if (metaClass == null) { MetaClass propertyMetaClass = metaProperty.getRange().asClass(); metaClass = metadata.getExtendedEntities().getEffectiveMetaClass(propertyMetaClass); } return metaClass; }
@Override public MetaClass getMetaClass() { MetaClass metaClass = metaProperty.getRange().asClass(); return metadata.getExtendedEntities().getEffectiveMetaClass(metaClass); }
private static MetaClass getMetaClass(Class clazz) { Metadata metadata = AppBeans.get(Metadata.NAME); return metadata.getExtendedEntities().getEffectiveMetaClass(metadata.getClassNN(clazz)); }
protected void loadFromStream(InputStream stream, Map<String, EntityDescr> map) { Document document = Dom4j.readDocument(stream); for (Element element : document.getRootElement().elements("include")) { String fileName = element.attributeValue("file"); if (!StringUtils.isBlank(fileName)) { InputStream incStream = getClass().getResourceAsStream(fileName); loadFromStream(incStream, map); } } Element rootElem = document.getRootElement(); Element entitiesElem = rootElem.element("entities"); for (Element entityElem : entitiesElem.elements("entity")) { String className = entityElem.attributeValue("class"); MetaClass metaClass = metadata.getClassNN(ReflectionHelper.getClass(className)); if (!metadata.getTools().isPersistent(metaClass)) { log.warn("Entity " + metaClass.getName() + " is not persistent, ignore it"); continue; } metaClass = metadata.getExtendedEntities().getEffectiveMetaClass(metaClass); EntityDescr entityDescr = createEntityDescr(entityElem, metaClass); map.put(className, entityDescr); } }
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; } }
@Override public <T extends Entity<K>, K> T find(Class<T> entityClass, K id) { Preconditions.checkNotNullArgument(entityClass, "entityClass is null"); Preconditions.checkNotNullArgument(id, "id is null"); Object realId = getRealId(id); log.debug("find {} by id={}", entityClass.getSimpleName(), realId); MetaClass metaClass = metadata.getExtendedEntities().getEffectiveMetaClass(entityClass); Class<T> javaClass = metaClass.getJavaClass(); T entity = delegate.find(javaClass, realId); if (entity instanceof SoftDelete && ((SoftDelete) entity).isDeleted() && isSoftDeletion()) return null; // in case of entity cache else return entity; }
/** * @param javaClass class of the loaded entities */ public LoadContext(Class<E> javaClass) { Preconditions.checkNotNullArgument(javaClass, "javaClass is null"); this.metaClass = AppBeans.get(Metadata.class).getExtendedEntities().getEffectiveMetaClass(javaClass).getName(); }
private com.haulmont.chile.core.model.MetaClass getClassFromEntityName(String entityName) { Metadata metadata = AppBeans.get(Metadata.NAME); com.haulmont.chile.core.model.MetaClass metaClass = metadata.getSession().getClass(entityName); return metaClass == null ? null : metadata.getExtendedEntities().getEffectiveMetaClass(metaClass); }
/** * @param metaClass metaclass of the loaded entities */ public LoadContext(MetaClass metaClass) { Preconditions.checkNotNullArgument(metaClass, "metaClass is null"); this.metaClass = AppBeans.get(Metadata.class).getExtendedEntities().getEffectiveMetaClass(metaClass).getName(); }
public JpqlEntityModel getEntityByName(String requiredEntityName) throws UnknownEntityNameException { if (extendedEntities != null) { if (metadata.getSession().getClass(requiredEntityName) == null) { throw new UnknownEntityNameException(requiredEntityName); } MetaClass effectiveMetaClass = extendedEntities.getEffectiveMetaClass(requiredEntityName); requiredEntityName = effectiveMetaClass.getName(); } JpqlEntityModel entity = entities.get(requiredEntityName); if (entity == null) { throw new UnknownEntityNameException(requiredEntityName); } else { return entity; } } }
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 copyUserFolders(User fromUser, User toUser, Map<UUID, Presentation> presentationsMap) { try (Transaction tx = persistence.createTransaction()) { MetaClass effectiveMetaClass = metadata.getExtendedEntities().getEffectiveMetaClass(SearchFolder.class); EntityManager em = persistence.getEntityManager(); try { em.setSoftDeletion(false); Query deleteSettingsQuery = em.createQuery( String.format("delete from %s s where s.user.id = ?1", effectiveMetaClass.getName()) ); deleteSettingsQuery.setParameter(1, toUser.getId()); deleteSettingsQuery.executeUpdate(); } finally { em.setSoftDeletion(true); } TypedQuery<SearchFolder> q = em.createQuery( String.format("select s from %s s where s.user.id = ?1", effectiveMetaClass.getName()), SearchFolder.class); q.setParameter(1, fromUser.getId()); List<SearchFolder> fromUserFolders = q.getResultList(); Map<SearchFolder, SearchFolder> copiedFolders = new HashMap<>(); for (SearchFolder searchFolder : fromUserFolders) { copyFolder(searchFolder, toUser, copiedFolders, presentationsMap); } tx.commit(); } }
protected void addLinkedPropertyEx(StringBuilder sb, Entity entity, String[] propertyPath) { String prop = propertyPath[0]; Object value = entity.getValue(prop); if (value instanceof Entity) { if (propertyPath.length == 1) { String originalMetaClassName = metadata.getExtendedEntities().getEffectiveMetaClass(((Entity) value).getMetaClass()).getName(); String entityInfoStr = new EntityInfo(originalMetaClassName, ((Entity) value).getId(), null, true).toString(); appendString(sb, entityInfoStr); } else { addLinkedPropertyEx(sb, (Entity) value, (String[]) ArrayUtils.subarray(propertyPath, 1, propertyPath.length)); } } else if (value instanceof Collection && !((Collection) value).isEmpty()) { Collection<Entity> collection = (Collection<Entity>) value; for (Entity inst : collection) { if (inst != null) { if (propertyPath.length == 1) { String originalMetaClassName = metadata.getExtendedEntities().getEffectiveMetaClass(inst.getMetaClass()).getName(); String entityInfoStr = new EntityInfo(originalMetaClassName, inst.getId(), null, true).toString(); appendString(sb, entityInfoStr); } else { addLinkedPropertyEx(sb, inst, (String[]) ArrayUtils.subarray(propertyPath, 1, propertyPath.length)); } } } } }
@Override protected void afterLookupWindowOpened(Window lookupWindow) { boolean found = ComponentsHelper.walkComponents(lookupWindow, screenComponent -> { if (!(screenComponent instanceof Filter)) { return false; } else { MetaClass actualMetaClass = ((FilterImplementation) screenComponent).getEntityMetaClass(); MetaClass propertyMetaClass = extendedEntities.getEffectiveMetaClass(pickerField.getMetaClass()); if (Objects.equals(actualMetaClass, propertyMetaClass)) { applyFilter(((Filter) screenComponent)); return true; } return false; } }); if (!found) { Notifications notifications = getScreenContext(pickerField).getNotifications(); notifications.create(NotificationType.WARNING) .withCaption(messages.getMainMessage("dynamicAttributes.entity.filter.filterNotFound")) .show(); } AbstractWindow controller = (AbstractWindow) (lookupWindow).getFrameOwner(); ((DsContextImplementation) controller.getDsContext()).resumeSuspended(); }
@Override public List<SearchFolder> loadSearchFolders() { log.debug("Loading SearchFolders"); StopWatch stopWatch = new Slf4JStopWatch("SearchFolders"); stopWatch.start(); Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); MetaClass effectiveMetaClass = metadata.getExtendedEntities().getEffectiveMetaClass(SearchFolder.class); TypedQuery<SearchFolder> q = em.createQuery("select f from "+ effectiveMetaClass.getName() +" f " + "left join f.user u on u.id = ?1 " + "where (u.id = ?1 or u is null) " + "order by f.sortOrder, f.name", SearchFolder.class); q.setViewName("searchFolders"); q.setParameter(1, userSessionSource.currentOrSubstitutedUserId()); List<SearchFolder> list = q.getResultList(); tx.commit(); return list; } finally { tx.end(); stopWatch.stop(); } }
protected void applyFilter(Filter component, Collection<? extends Entity> selectedParents, RelatedScreenDescriptor descriptor, MetaDataDescriptor metaDataDescriptor) { FilterEntity filterEntity = metadata.create(FilterEntity.class); filterEntity.setComponentId(ComponentsHelper.getFilterComponentPath(component)); if (StringUtils.isNotEmpty(descriptor.getFilterCaption())) { filterEntity.setName(descriptor.getFilterCaption()); } else { MetaProperty metaProperty = metaDataDescriptor.getMetaProperty(); filterEntity.setName(messages.getMainMessage("actions.Related.Filter") + " " + messageTools.getPropertyCaption(metaProperty.getDomain(), metaProperty.getName())); } MetaClass effectiveMetaClass = extendedEntities.getEffectiveMetaClass(metaDataDescriptor.getRelatedMetaClass()); filterEntity.setXml(getRelatedEntitiesFilterXml(effectiveMetaClass, selectedParents, component, metaDataDescriptor)); filterEntity.setUser(userSessionSource.getUserSession().getCurrentOrSubstitutedUser()); component.setFilterEntity(filterEntity); component.apply(Filter.FilterOptions.create() .setNotifyInvalidConditions(true) .setLoadData(false)); }