/** * @return MetaProperty representing a primary key attribute, or null if the entity has no primary key (e.g. * embeddable) */ @Nullable public MetaProperty getPrimaryKeyProperty(MetaClass metaClass) { String primaryKeyName = getPrimaryKeyName(metaClass); return primaryKeyName == null ? null : metaClass.getPropertyNN(primaryKeyName); }
/** * Checks if current MetaClass contains given id property. * * @param property property to check * @param metaClass metaClass * @return true if MetaClass contains given id property */ protected boolean isIdProperty(String property, MetaClass metaClass) { String primaryId = metadata.getTools().getPrimaryKeyName(metaClass); return property.equals(primaryId); }
protected void extractPrimaryKeyName(Class type) { Metadata metadata = AppBeans.get(Metadata.class); MetaClass metaClass = metadata.getClass(type); if (metaClass != null) { primaryKey = metadata.getTools().getPrimaryKeyName(metaClass); if (primaryKey == null) { log.debug("Unable to resolve primary key for type {}", type.getSimpleName()); } } else { log.debug("Unable to resolve metaClass for type {}", type.getSimpleName()); } } }
public CrossDataStoreProperty(MetaProperty metaProperty, ViewProperty viewProperty) { this.property = metaProperty; this.viewProperty = viewProperty; List<String> relatedProperties = metadataTools.getRelatedProperties(property); relatedPropertyName = relatedProperties.get(0); String pkName = metadataTools.getPrimaryKeyName(property.getRange().asClass()); primaryKeyName = pkName != null ? pkName : "id"; // sensible default for non-persistent entities }
/** * @param metaClass of entity * @return metaProperty name for loading entity from database by primary key stored in the database */ public String getPrimaryKeyForLoadingEntity(MetaClass metaClass) { if (HasUuid.class.isAssignableFrom(metaClass.getJavaClass())) { MetaProperty primaryKeyProperty = metadata.getTools().getPrimaryKeyProperty(metaClass); if (primaryKeyProperty != null && !UUID.class.isAssignableFrom(primaryKeyProperty.getJavaType())) return "uuid"; } return metadata.getTools().getPrimaryKeyName(metaClass); } }
protected List<String> getEmbeddedIdProperties(MetaClass metaClass) { List<String> result = new ArrayList<>(); if (hasEmbeddedId(metaClass)) { MetaClass embeddedMetaClass = getEmbeddedIdMetaClass(metaClass); if (embeddedMetaClass == null) { return null; } String primaryKey = metadata.getTools().getPrimaryKeyName(metaClass); for (MetaProperty metaProperty : embeddedMetaClass.getOwnProperties()) { result.add(primaryKey + "." + metaProperty.getName()); } } return result; }
protected <T extends Entity> T findWithViews(MetaClass metaClass, Object id, List<View> views) { Object realId = getRealId(id); log.debug("find {} by id={}, views={}", metaClass.getJavaClass().getSimpleName(), realId, views); String pkName = metadata.getTools().getPrimaryKeyName(metaClass); if (pkName == null) throw new IllegalStateException("Cannot determine PK name for entity " + metaClass); Query query = createQuery(String.format("select e from %s e where e.%s = ?1", metaClass.getName(), pkName)); ((QueryImpl) query).setSingleResultExpected(true); query.setParameter(1, realId); for (View view : views) { query.addView(view); } //noinspection unchecked return (T) query.getFirstResult(); }
public void setEntity(Entity entity) { this.entity = entity; this.metaClass = metadata.getSession().getClass(entity.getClass()); primaryKeyName = metadata.getTools().getPrimaryKeyName(metaClass); String storeName = metadata.getTools().getStoreName(metaClass); entityManager = persistence.getEntityManager(storeName == null ? Stores.MAIN : storeName); }
public void deleteRecord(Entity... entities) { if (entities == null) return; for (Entity entity : entities) { if (entity == null) continue; MetadataTools metadataTools = metadata().getTools(); MetaClass metaClass = metadata().getClassNN(entity.getClass()); String table = metadataTools.getDatabaseTable(metaClass); String primaryKey = metadataTools.getPrimaryKeyName(metaClass); if (table == null || primaryKey == null) throw new RuntimeException("Unable to determine table or primary key name for " + entity); deleteRecord(table, primaryKey, entity.getId()); } }
@Nullable protected AbstractCondition getManyToManyCondition(List<Object> parentIds, MetaClass metaClass, String filterComponentName, String relatedPrimaryKey, MetaDataDescriptor descriptor) { MetaClass parentMetaClass = descriptor.getMetaClass(); String parentPrimaryKey = metadataTools.getPrimaryKeyName(parentMetaClass); CustomCondition customCondition = getParentEntitiesCondition(parentIds, parentPrimaryKey, metaClass, filterComponentName, parentMetaClass); String parentEntityAlias = RandomStringUtils.randomAlphabetic(6); String entityAlias = RandomStringUtils.randomAlphabetic(6); String select = String.format("select %s.%s from %s %s ", entityAlias, relatedPrimaryKey, parentMetaClass, parentEntityAlias); String joinWhere = String.format("join %s.%s %s where %s.%s in :%s", parentEntityAlias, descriptor.getMetaProperty().getName(), entityAlias, parentEntityAlias, parentPrimaryKey, customCondition.getParam().getName()); String whereString = String.format("{E}.%s in (%s)", relatedPrimaryKey, select + joinWhere); customCondition.setWhere(whereString); return customCondition; }
protected Set<String> findSystemProperties(Class entityClass) { Set<String> result = new LinkedHashSet<>(); Metadata metadata = AppBeans.get(Metadata.NAME); MetaClass metaClass = metadata.getClassNN(entityClass); String pkName = metadata.getTools().getPrimaryKeyName(metaClass); if (pkName != null) { result.add(pkName); } addSystemPropertiesFrom(Versioned.class, entityClass, metaClass, metadata, result); addSystemPropertiesFrom(Creatable.class, entityClass, metaClass, metadata, result); addSystemPropertiesFrom(Updatable.class, entityClass, metaClass, metadata, result); addSystemPropertiesFrom(SoftDelete.class, entityClass, metaClass, metadata, result); return result; }
@Nullable protected AbstractCondition getManyToOneCondition(List<Object> parentIds, MetaClass metaClass, String filterComponentName, String relatedPrimaryKey, MetaDataDescriptor descriptor) { MetaClass parentMetaClass = descriptor.getMetaClass(); String parentPrimaryKey = metadataTools.getPrimaryKeyName(parentMetaClass); CustomCondition customCondition = getParentEntitiesCondition(parentIds, parentPrimaryKey, metaClass, filterComponentName, parentMetaClass); String entityAlias = RandomStringUtils.randomAlphabetic(6); String subQuery = String.format("select %s.%s.%s from %s %s where %s.%s in :%s", entityAlias, descriptor.getMetaProperty().getName(), relatedPrimaryKey, parentMetaClass.getName(), entityAlias, entityAlias, parentPrimaryKey, customCondition.getParam().getName()); String whereString = String.format("{E}.%s in (%s)", relatedPrimaryKey, subQuery); customCondition.setWhere(whereString); return customCondition; }
protected MetaClass getEmbeddedIdMetaClass(MetaClass metaClass) { String primaryKey = metadata.getTools().getPrimaryKeyName(metaClass); if (primaryKey == null) { return null; } MetaProperty metaProperty = metaClass.getPropertyNN(primaryKey); MetaModel metaModel = metaProperty.getModel(); // in this case we should use `metaProperty.getJavaType()` because // we need to get class type of EmbeddedId property and then get MetaClass of it return metaModel == null ? null : metaModel.getClass(metaProperty.getJavaType()); }
@Nullable protected AbstractCondition getOneToManyCondition(List<Object> parentIds, MetaClass metaClass, String filterComponentName, MetaDataDescriptor descriptor) { MetaProperty inverseField = descriptor.getMetaProperty().getInverse(); if (inverseField == null) { return null; } MetaClass parentMetaClass = descriptor.getMetaClass(); String parentPrimaryKey = metadataTools.getPrimaryKeyName(parentMetaClass); CustomCondition customCondition = getParentEntitiesCondition(parentIds, parentPrimaryKey, metaClass, filterComponentName, parentMetaClass); String whereString = String.format("{E}.%s.%s in :%s", inverseField.getName(), parentPrimaryKey, customCondition.getParam().getName()); customCondition.setWhere(whereString); return customCondition; }
protected List<Entity> loadItemsWithDirectKey(LoadDescriptor ld) { LoadContext.Query query = new LoadContext.Query( String.format("select e from %s e where e.%s in :ids", ld.getMetaClass(), metadataTools.getPrimaryKeyName(ld.getMetaClass()))); List<Object> ids = ld.getSelectedItems().stream() .map(Entity::getId) .collect(Collectors.toList()); query.setParameter("ids", ids); LoadContext<Entity> lc = new LoadContext<>(ld.getMetaClass()); lc.setSoftDeletion(false); lc.setQuery(query); lc.setView(ld.getView()); lc.setLoadDynamicAttributes(ld.isLoadDynamicAttributes()); return dataManager.secure().loadList(lc); } }
/** * Loads single item by id. * * @param meta item's meta class * @param id item's id * @param view view * @return loaded item if found, null otherwise */ protected Entity loadSingleItem(MetaClass meta, Object id, View view) { String primaryKeyName = metadata.getTools().getPrimaryKeyName(meta); if (primaryKeyName == null) { throw new IllegalStateException(String.format("Entity %s has no primary key", meta.getName())); } LoadContext ctx = new LoadContext(meta); ctx.setLoadDynamicAttributes(true); ctx.setSoftDeletion(false); ctx.setView(view); String query = String.format("select e from %s e where e.%s = :id", meta.getName(), primaryKeyName); LoadContext.Query q = ctx.setQueryString(query); q.setParameter("id", id); return dataSupplier.load(ctx); }
protected void loadAllProperties() { Metadata metadata = AppBeans.get(Metadata.class); if (!loaded) { MetaClass metaClass = instance.getMetaClass(); String pkName = metadata.getTools().getPrimaryKeyName(metaClass); for (MetaProperty property : metaClass.getProperties()) { if (view != null && view.getProperty(property.getName()) != null) { explicitData.put(property.getName(), getValue(instance, property.getName())); } else if (view != null && Objects.equals(pkName, property.getName())) { explicitData.put(property.getName(), getValue(instance, property.getName())); } else if (view == null) { explicitData.put(property.getName(), getValue(instance, property.getName())); } } if (instanceNameAvailable(metaClass)) explicitData.put(INSTANCE_NAME_KEY, metadata.getTools().getInstanceName(instance)); else explicitData.put(INSTANCE_NAME_KEY, null); loaded = true; } }
protected boolean isCollectionEmpty(MetaProperty property) { MetaProperty inverseProperty = property.getInverse(); if (inverseProperty == null) { log.warn("Inverse property not found for property {}", property); Collection<Entity> value = entity.getValue(property.getName()); return value == null || value.isEmpty(); } String invPropName = inverseProperty.getName(); String collectionPkName = metadata.getTools().getPrimaryKeyName(property.getRange().asClass()); String qlStr = "select e." + collectionPkName + " from " + property.getRange().asClass().getName() + " e where e." + invPropName + "." + primaryKeyName + " = ?1"; Query query = entityManager.createQuery(qlStr); query.setParameter(1, entity.getId()); query.setMaxResults(1); List<Entity> list = query.getResultList(); return list.isEmpty(); }
protected String getRelatedEntitiesFilterXml(MetaClass relatedMetaCLass, Collection<? extends Entity> selectedEntities, Filter component, MetaDataDescriptor descriptor) { ConditionsTree tree = new ConditionsTree(); String filterComponentPath = ComponentsHelper.getFilterComponentPath(component); String[] strings = ValuePathHelper.parse(filterComponentPath); String filterComponentName = ValuePathHelper.format(Arrays.copyOfRange(strings, 1, strings.length)); MetaClass metaClass = getFilterMetaClass(component); String relatedPrimaryKey = metadataTools.getPrimaryKeyName(relatedMetaCLass); AbstractCondition condition = getOptimizedCondition(getParentIds(selectedEntities), metaClass, filterComponentName, relatedPrimaryKey, descriptor); if (condition == null) { condition = getNonOptimizedCondition(relatedMetaCLass, getRelatedIds(selectedEntities, descriptor), component, filterComponentName, relatedPrimaryKey); } tree.setRootNodes(Collections.singletonList(new Node<>(condition))); return filterParser.getXml(tree, Param.ValueProperty.VALUE); }
/** * Reload dynamic attributes on the entity */ @SuppressWarnings("unchecked") public void reloadDynamicAttributes(BaseGenericIdEntity entity) { MetaClass metaClass = entity.getMetaClass(); View view = new View(metaClass.getJavaClass(), false) .addProperty(metadata.getTools().getPrimaryKeyName(metaClass)); LoadContext loadContext = new LoadContext(metaClass) .setView(view) .setLoadDynamicAttributes(true) .setId(entity.getId()); BaseGenericIdEntity reloadedEntity = (BaseGenericIdEntity) dataManager.load(loadContext); if (reloadedEntity != null) { entity.setDynamicAttributes(reloadedEntity.getDynamicAttributes()); } } }