@PostConstruct protected void init() { this.storeName = metadata.getTools().getStoreName(metaClass); }
protected String getDataStore(String entityName) { if (!serverConfig.getUseEntityDataStoreForIdSequence()) { return Stores.MAIN; } else { return metadataTools.getStoreName(metadata.getClassNN(entityName)); } }
protected Collection getFilteredIds(Entity entity, String propertyName) { if (entity instanceof BaseGenericIdEntity) { String storeName = metadata.getTools().getStoreName(entity.getMetaClass()); DataStore dataStore = storeFactory.get(storeName); if (dataStore instanceof RdbmsStore) { persistenceSecurity.restoreSecurityState(entity); return Optional.ofNullable(BaseEntityInternalAccess.getFilteredData(entity)) .map(v -> v.get(propertyName)) .orElse(Collections.emptyList()); } } return Collections.emptyList(); }
protected String getStoreName(MetaClass metaClass) { return getStoreName(metadata.getTools().getStoreName(metaClass)); }
@Override public EnumSet<Op> availableOps(MetaClass metaClass, MetaProperty metaProperty) { Class javaClass = metaProperty.getJavaType(); if (String.class.equals(javaClass) && metadataTools.isLob(metaProperty)) { String storeName = metadata.getTools().getStoreName(metaClass); PersistenceManagerService persistenceManagerService = AppBeans.get(PersistenceManagerService.class); if (!persistenceManagerService.supportsLobSortingAndFiltering(storeName)) { return EnumSet.of(CONTAINS, DOES_NOT_CONTAIN, NOT_EMPTY, STARTS_WITH, ENDS_WITH); } } return availableOps(javaClass); } }
private void traverseView(View view, Map<Class<? extends Entity>, List<CrossDataStoreProperty>> crossPropertiesMap, Set<View> visited) { if (visited.contains(view)) return; visited.add(view); String storeName = metadataTools.getStoreName(metaClass); Class<? extends Entity> entityClass = view.getEntityClass(); for (ViewProperty viewProperty : view.getProperties()) { MetaProperty metaProperty = metadata.getClassNN(entityClass).getPropertyNN(viewProperty.getName()); if (metaProperty.getRange().isClass()) { MetaClass propertyMetaClass = metaProperty.getRange().asClass(); if (!Objects.equals(metadataTools.getStoreName(propertyMetaClass), storeName)) { List<String> relatedProperties = metadataTools.getRelatedProperties(metaProperty); if (relatedProperties.size() == 0) { continue; } if (relatedProperties.size() > 1) { log.warn("More than 1 related property is defined for attribute {}, skip handling cross-datastore reference", metaProperty); continue; } List<CrossDataStoreProperty> crossProperties = crossPropertiesMap.computeIfAbsent(entityClass, k -> new ArrayList<>()); if (crossProperties.stream().noneMatch(aProp -> aProp.property == metaProperty)) crossProperties.add(new CrossDataStoreProperty(metaProperty, viewProperty)); } View propertyView = viewProperty.getView(); if (propertyView != null) { traverseView(propertyView, crossPropertiesMap, visited); } } } }
/** * If the given property is a reference to an entity from different data store, returns the name of a persistent * property which stores the identifier of the related entity. * * @param thisStore name of a base data store * @param metaProperty property * @return name of the ID property or null if the given property is not a cross-datastore reference or it does not * satisfy the convention of declaring related properties for such references */ @Nullable public String getCrossDataStoreReferenceIdProperty(String thisStore, MetaProperty metaProperty) { checkNotNullArgument(metaProperty, "metaProperty is null"); if (!metaProperty.getRange().isClass()) return null; String propStore = getStoreName(metaProperty.getRange().asClass()); if (Objects.equals(thisStore, propStore)) return null; List<String> relatedProperties = getRelatedProperties(metaProperty); if (relatedProperties.size() == 1) return relatedProperties.get(0); else return null; }
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); }
/** * Get query results from query cache by specified {@code queryKey} */ @SuppressWarnings("unchecked") public <T> List<T> getResultListFromCache(QueryKey queryKey, List<View> views) { log.debug("Looking for query in cache: {}", queryKey.printDescription()); List<T> resultList = null; QueryResult queryResult = queryCache.get(queryKey); if (queryResult != null) { MetaClass metaClass = metadata.getClassNN(queryResult.getType()); String storeName = metadata.getTools().getStoreName(metaClass); EntityManager em = persistence.getEntityManager(storeName); resultList = new ArrayList<>(queryResult.getResult().size()); if (!metadata.getTools().isCacheable(metaClass)) { log.warn("Using cacheable query without entity cache for {}", queryResult.getType()); } for (Object id : queryResult.getResult()) { resultList.add(em.find(metaClass.getJavaClass(), id, views.toArray(new View[views.size()]))); } } else { log.debug("Query results are not found in cache: {}", queryKey.printDescription()); } return resultList; }
protected Entity reload(Entity entity) { String storeName = metadataTools.getStoreName(entity.getMetaClass()); if (storeName == null) throw new RuntimeException("Cannot determine data store for " + entity); try (Transaction tx = persistence.createTransaction(storeName)) { Entity reloaded = persistence.getEntityManager(storeName).find(entity.getClass(), entity.getId(), createFullView(entity.getMetaClass())); if (reloaded != null) { entity = reloaded; } tx.commit(); } return entity; }
@SuppressWarnings("unchecked") protected List<Entity> loadItemsWithCompositeKey(LoadDescriptor ld) { Preconditions.checkNotNull(ld.getMetaClass(), "metaClass is null"); TransactionalDataManager secureDataManager = txDataManager.secure(); String storeName = metadataTools.getStoreName(ld.getMetaClass()); if (storeName == null) { storeName = Stores.MAIN; } List<Entity> items; try (Transaction tx = persistence.createTransaction(storeName)) { // for composite key we can only load with N queries, since IN operator is not supported for composite keys items = ld.getSelectedItems().stream() .map(item -> secureDataManager.load(Id.of(item)) .view(ld.getView()) .softDeletion(false) .dynamicAttributes(ld.isLoadDynamicAttributes()) .optional() ) .filter(Optional::isPresent) .map(o -> (Entity) o.get()) .collect(Collectors.toList()); tx.commit(); } return items; }
protected boolean isEntityAvailableForFts() { return adapter != null && ftsFilterHelper != null && ftsFilterHelper.isEntityIndexed(adapter.getMetaClass().getName()) && Stores.isMain(metadata.getTools().getStoreName(adapter.getMetaClass())); }
@Override public void restoreEntities(Collection<Entity> entities) { for (Entity entity : entities) { if (!(entity instanceof SoftDelete)) continue; String storeName = metadata.getTools().getStoreName(metadata.getClassNN(entity.getClass())); if (storeName == null) { log.warn("Unable to restore entity {}: cannot determine data store", entity); continue; } Transaction tx = persistence.createTransaction(storeName); try { persistence.getEntityManager(storeName).setSoftDeletion(false); restoreEntity(entity, storeName); tx.commit(); } finally { tx.end(); } } }
@Override public SecurityState computeSecurityState(Entity entity) { Preconditions.checkNotNullArgument(entity, "entity is null"); SecurityState state; String storeName = metadataTools.getStoreName(metadata.getClassNN(entity.getClass())); Transaction tx = persistence.createTransaction(storeName); try { EntityManager em = persistence.getEntityManager(storeName); Entity managedEntity = em.merge(entity); support.setupAttributeAccess(managedEntity); state = BaseEntityInternalAccess.getSecurityState(managedEntity); // do not commit the transaction } finally { tx.end(); } return state; } }
/** * @param filter filter * @param hierarchyDepth max level of properties hierarchy * @param hideDynamicAttributes hide dynamic attributes conditions from wizard */ public ConditionDescriptorsTreeBuilder(Filter filter, int hierarchyDepth, boolean hideDynamicAttributes, boolean hideCustomConditions, ConditionsTree conditionsTree) { this.filter = filter; this.hierarchyDepth = hierarchyDepth; this.hideDynamicAttributes = hideDynamicAttributes; this.hideCustomConditions = hideCustomConditions; this.conditionsTree = conditionsTree; security = AppBeans.get(Security.class); metadataTools = AppBeans.get(MetadataTools.NAME); dynamicAttributes = AppBeans.get(DynamicAttributes.class); filterComponentName = getFilterComponentName(); excludedProperties = new ArrayList<>(); storeName = metadataTools.getStoreName(((FilterImplementation) filter).getEntityMetaClass()); entityMetaClass = ((FilterImplementation) filter).getEntityMetaClass(); entityAlias = ((FilterImplementation) filter).getEntityAlias(); }
protected int executeReindexInTx(String entityName, Function<EntityDescr, Integer> indexAction) { MetaClass metaClass = metadata.getSession().getClassNN(entityName); String storeName = metadata.getTools().getStoreName(metaClass); Preconditions.checkNotNullArgument(storeName, "Storage not found for %s", metaClass.getName()); EntityDescr entityDescr = entityDescrsManager.getDescrByEntityName(metaClass.getName()); int count = 0; if (entityDescr != null) { try (Transaction tx = persistence.createTransaction()) { if (Stores.isMain(storeName)) { count = indexAction.apply(entityDescr); } else { try (Transaction storeTx = persistence.createTransaction(storeName)) { count = indexAction.apply(entityDescr); storeTx.commit(); } } tx.commit(); } } return count; }
@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); } }
@SuppressWarnings("unchecked") protected void assignIdentifier(Entity entity) { if (!(entity instanceof BaseGenericIdEntity)) return; MetaClass metaClass = getClassNN(entity.getClass()); MetaProperty primaryKeyProperty = tools.getPrimaryKeyProperty(metaClass); if (primaryKeyProperty != null && tools.isEmbedded(primaryKeyProperty)) { // create an instance of embedded ID Entity key = create(primaryKeyProperty.getRange().asClass()); ((BaseGenericIdEntity) entity).setId(key); } else { if (!config.getEnableIdGenerationForEntitiesInAdditionalDataStores() && !Stores.MAIN.equals(tools.getStoreName(metaClass))) { return; } if (tools.isPersistent(metaClass)) { if (entity instanceof BaseLongIdEntity) { ((BaseGenericIdEntity<Long>) entity).setId(numberIdSource.createLongId(getEntityNameForIdGeneration(metaClass))); } else if (entity instanceof BaseIntegerIdEntity) { ((BaseGenericIdEntity<Integer>) entity).setId(numberIdSource.createIntegerId(getEntityNameForIdGeneration(metaClass))); } } } }
protected void addColumnInternal(ColumnImpl<E> column, int index) { Grid.Column<E, ?> gridColumn = component.addColumn( new EntityValueProvider<>(column.getPropertyPath())); columns.put(column.getId(), column); columnsOrder.add(index, column); final String caption = StringUtils.capitalize(column.getCaption() != null ? column.getCaption() : generateColumnCaption(column)); column.setCaption(caption); if (column.getOwner() == null) { column.setOwner(this); } MetaPropertyPath propertyPath = column.getPropertyPath(); if (propertyPath != null) { MetaProperty metaProperty = propertyPath.getMetaProperty(); MetaClass propertyMetaClass = metadataTools.getPropertyEnclosingMetaClass(propertyPath); String storeName = metadataTools.getStoreName(propertyMetaClass); if (metadataTools.isLob(metaProperty) && !persistenceManagerClient.supportsLobSortingAndFiltering(storeName)) { column.setSortable(false); } } setupGridColumnProperties(gridColumn, column); component.setColumnOrder(getColumnOrder()); }
internalRegisterModifyAttributeValue((CategoryAttributeValue) entity, null, attributes); } else { String storeName = metadata.getTools().getStoreName(metaClass); if (Stores.isMain(storeName)) { internalRegisterCreate(entity, masterEntityName, attributes);