LoadContext<E> createLoadContext() { LoadContext<E> loadContext = LoadContext.create(loader.entityClass); loader.initCommonLoadContextParameters(loadContext); LoadContext.Query query = LoadContext.createQuery(queryString); for (Map.Entry<String, Object> entry : parameters.entrySet()) { if (noConversionParams.contains(entry.getKey())) query.setParameter(entry.getKey(), entry.getValue(), false); else query.setParameter(entry.getKey(), entry.getValue()); } loadContext.setQuery(query); loadContext.getQuery().setCondition(condition); loadContext.getQuery().setFirstResult(firstResult); loadContext.getQuery().setMaxResults(maxResults); loadContext.getQuery().setCacheable(cacheable); return loadContext; }
protected Query createQuery(EntityManager em, LoadContext context, boolean singleResult) { LoadContext.Query contextQuery = context.getQuery(); RdbmsQueryBuilder queryBuilder = AppBeans.get(RdbmsQueryBuilder.NAME); queryBuilder.init( contextQuery == null ? null : contextQuery.getQueryString(), contextQuery == null ? null : contextQuery.getCondition(), contextQuery == null ? null : contextQuery.getSort(), contextQuery == null ? null : contextQuery.getParameters(), contextQuery == null ? null : contextQuery.getNoConversionParams(), context.getId(), context.getMetaClass() ); queryBuilder.setSingleResult(singleResult); if (!context.getPrevQueries().isEmpty()) { log.debug("Restrict query by previous results"); queryBuilder.restrictByPreviousResults(userSessionSource.getUserSession().getId(), context.getQueryKey()); } Query query = queryBuilder.getQuery(em); if (contextQuery != null) { if (contextQuery.getFirstResult() != 0) query.setFirstResult(contextQuery.getFirstResult()); if (contextQuery.getMaxResults() != 0) query.setMaxResults(contextQuery.getMaxResults()); if (contextQuery.isCacheable()) { query.setCacheable(contextQuery.isCacheable()); } } return query; }
/** * Loads a single instance and wraps it in Optional. */ public Optional<E> optional() { LoadContext<E> loadContext = createLoadContext(); loadContext.getQuery().setMaxResults(1); return Optional.ofNullable(dataManager.load(loadContext)); }
/** * Apply constraints for query to select reports which have input parameter with class matching inputValueMetaClass */ public void applyPoliciesByEntityParameters(LoadContext lc, @Nullable MetaClass inputValueMetaClass) { if (inputValueMetaClass != null) { QueryTransformer transformer = queryTransformerFactory.transformer(lc.getQuery().getQueryString()); StringBuilder parameterTypeCondition = new StringBuilder("r.inputEntityTypesIdx like :type escape '\\'"); lc.getQuery().setParameter("type", wrapIdxParameterForSearch(inputValueMetaClass.getName())); List<MetaClass> ancestors = inputValueMetaClass.getAncestors(); for (int i = 0; i < ancestors.size(); i++) { MetaClass metaClass = ancestors.get(i); String paramName = "type" + (i + 1); parameterTypeCondition.append(" or r.inputEntityTypesIdx like :").append(paramName).append(" escape '\\'"); lc.getQuery().setParameter(paramName, wrapIdxParameterForSearch(metaClass.getName())); } transformer.addWhereAsIs(String.format("(%s)", parameterTypeCondition.toString())); lc.getQuery().setQueryString(transformer.getResult()); } }
/** * Loads a single instance. * * @throws IllegalStateException if nothing was loaded */ public E one() { LoadContext<E> loadContext = createLoadContext(); loadContext.getQuery().setMaxResults(1); E entity = dataManager.load(loadContext); if (entity != null) return entity; else throw new IllegalStateException("No results"); }
/** * Apply security constraints for query to select reports available by roles and screen restrictions */ public void applySecurityPolicies(LoadContext lc, @Nullable String screen, @Nullable User user) { QueryTransformer transformer = queryTransformerFactory.transformer(lc.getQuery().getQueryString()); if (screen != null) { transformer.addWhereAsIs("r.screensIdx like :screen escape '\\'"); lc.getQuery().setParameter("screen", wrapIdxParameterForSearch(screen)); } if (user != null) { List<UserRole> userRoles = user.getUserRoles(); boolean superRole = userRoles.stream().anyMatch(userRole -> userRole.getRole().getType() == RoleType.SUPER); if (!superRole) { StringBuilder roleCondition = new StringBuilder("r.rolesIdx is null"); for (int i = 0; i < userRoles.size(); i++) { UserRole ur = userRoles.get(i); String paramName = "role" + (i + 1); roleCondition.append(" or r.rolesIdx like :").append(paramName).append(" escape '\\'"); lc.getQuery().setParameter(paramName, wrapIdxParameterForSearch(ur.getRole().getId().toString())); } transformer.addWhereAsIs(roleCondition.toString()); } } lc.getQuery().setQueryString(transformer.getResult()); }
@SuppressWarnings("unchecked") protected <E extends Entity> List<E> getResultList(LoadContext<E> context, Query query, boolean ensureDistinct) { List<E> list = executeQuery(query, false); int initialSize = list.size(); if (initialSize == 0) { return list; } boolean needToFilterByInMemoryReadConstraints = needToFilterByInMemoryReadConstraints(context); boolean filteredByConstraints = false; if (needToFilterByInMemoryReadConstraints) { filteredByConstraints = security.filterByConstraints((Collection<Entity>) list); } if (!ensureDistinct) { return filteredByConstraints ? getResultListIteratively(context, query, list, initialSize, true) : list; } int requestedFirst = context.getQuery().getFirstResult(); LinkedHashSet<E> set = new LinkedHashSet<>(list); if (set.size() == list.size() && requestedFirst == 0 && !filteredByConstraints) { // If this is the first chunk and it has no duplicates and security constraints are not applied, just return it return list; } // In case of not first chunk, even if there where no duplicates, start filling the set from zero // to ensure correct paging return getResultListIteratively(context, query, set, initialSize, needToFilterByInMemoryReadConstraints); }
log.debug("loadList: metaClass=" + context.getMetaClass() + ", view=" + context.getView() + (context.getPrevQueries().isEmpty() ? "" : ", from selected") + ", query=" + (context.getQuery() == null ? null : RdbmsQueryBuilder.printQuery(context.getQuery().getQueryString())) + (context.getQuery() == null || context.getQuery().getFirstResult() == 0 ? "" : ", first=" + context.getQuery().getFirstResult()) + (context.getQuery() == null || context.getQuery().getMaxResults() == 0 ? "" : ", max=" + context.getQuery().getMaxResults())); if (serverConfig.getInMemoryDistinct() && context.getQuery() != null) { QueryTransformer transformer = queryTransformerFactory.transformer( context.getQuery().getQueryString()); ensureDistinct = transformer.removeDistinct(); if (ensureDistinct) { context.getQuery().setQueryString(transformer.getResult());
log.debug("getCount: metaClass=" + context.getMetaClass() + (context.getPrevQueries().isEmpty() ? "" : ", from selected") + ", query=" + (context.getQuery() == null ? null : RdbmsQueryBuilder.printQuery(context.getQuery().getQueryString()))); if (context.getQuery() == null) { context.setQuery(LoadContext.createQuery(null)); if (StringUtils.isBlank(context.getQuery().getQueryString())) { context.getQuery().setQueryString("select e from " + metaClass.getName() + " e"); if (serverConfig.getInMemoryDistinct() && context.getQuery() != null) { QueryTransformer transformer = QueryTransformerFactory.createTransformer( context.getQuery().getQueryString()); ensureDistinct = transformer.removeDistinct(); if (ensureDistinct) { context.getQuery().setQueryString(transformer.getResult()); context.getQuery().setFirstResult(0); context.getQuery().setMaxResults(0); QueryTransformer transformer = QueryTransformerFactory.createTransformer(context.getQuery().getQueryString()); transformer.replaceWithCount(); context.getQuery().setQueryString(transformer.getResult());
/** * This method is invoked by {@link #loadData(Map)} method immediately after loading entities from {@code DataSupplier}. * <p>If you override this method, be sure to call {@code super()}. If you process the loaded entities somehow, * call {@code super()} after processing. * * @param params datasource parameters, as described in {@link CollectionDatasource#refresh(java.util.Map)} * @param context {@code LoadContext} which was used for loading data * @param entities loaded entities */ protected void afterLoadData(@SuppressWarnings("unused") Map<String, Object> params, LoadContext context, Collection<T> entities) { detachListener(data.values()); data.clear(); for (T entity : entities) { data.put(entity.getId(), entity); attachListener(entity); } lastQuery = context.getQuery(); }
protected void printAll() { MetaClass metaClass; LoadContext loadContext; if (listComponent.getItems() instanceof ContainerDataUnit) { ContainerDataUnit unit = (ContainerDataUnit) listComponent.getItems(); CollectionContainer container = unit.getContainer(); CollectionLoader loader = (CollectionLoader) ((HasLoader) unit.getContainer()).getLoader(); metaClass = container.getEntityMetaClass(); loadContext = loader.createLoadContext(); } else { CollectionDatasource ds = listComponent.getDatasource(); metaClass = ds.getMetaClass(); loadContext = ds.getCompiledLoadContext(); } ParameterPrototype parameterPrototype = new ParameterPrototype(metaClass.getName()); parameterPrototype.setMetaClassName(metaClass.getName()); LoadContext.Query query = loadContext.getQuery(); parameterPrototype.setQueryString(query.getQueryString()); parameterPrototype.setQueryParams(query.getParameters()); parameterPrototype.setViewName(loadContext.getView().getName()); Window window = ComponentsHelper.getWindowNN(listComponent); openRunReportScreen(window.getFrameOwner(), parameterPrototype, metaClass); } }