@Override public Filter getSecurityFilter(Authentication user, Class<? extends CatalogInfo> clazz) { // If there are no CatalogFilters, just get the delegate's filter if (filters == null || filters.isEmpty()) return delegate.getSecurityFilter(user, clazz); // Result is the conjunction of delegate's filter, and those of all the CatalogFilters ArrayList<Filter> convertedFilters = new ArrayList<Filter>(this.filters.size() + 1); convertedFilters.add(delegate.getSecurityFilter(user, clazz)); // Delegate's filter for (CatalogFilter filter : getCatalogFilters()) { convertedFilters.add(filter.getSecurityFilter(clazz)); // Each CatalogFilter's filter } return Predicates.and(convertedFilters.toArray(new Filter[convertedFilters.size()])); } }
@Override public Filter getSecurityFilter(Class<? extends CatalogInfo> clazz) { if (shouldApplyFilter()) { if (LayerInfo.class.isAssignableFrom(clazz)) { return Predicates.and( Predicates.equal("enabled", true), Predicates.equal("resource.enabled", true), Predicates.equal("resource.store.enabled", true)); } else if (ResourceInfo.class.isAssignableFrom(clazz)) { return Predicates.and( Predicates.equal("enabled", true), Predicates.equal("store.enabled", true)); } } return Filter.INCLUDE; }
return Predicates.and(filter, securityFilter);
return Predicates.and(filter, securityFilter);
private Filter standardFilter(Class<? extends CatalogInfo> clazz) { final Filter forGlobal; if (LocalWorkspace.get() != null) { // TODO need a well known implementation // Show globals unless an object with the same name is in the local workspace forGlobal = super.getSecurityFilter(clazz); } else { // Global request, show all globals forGlobal = Predicates.acceptAll(); } // If it's a global use the global filter, otherwise check if it's in the local workspace return Predicates.or( Predicates.and(Predicates.isNull("workspace.id"), forGlobal), Predicates.and( Predicates.factory.not(Predicates.isNull("workspace.id")), inWorkspace())); }
return rootAccess ? Filter.INCLUDE : Filter.EXCLUDE; } else { return rootAccess ? Predicates.and(exceptions) : Predicates.or(exceptions); ? Predicates.and(layerExceptions) : Predicates.or(layerExceptions); exceptions.add(combined); return rootAccess ? Filter.INCLUDE : Filter.EXCLUDE; } else { Filter filter = rootAccess ? Predicates.and(exceptions) : Predicates.or(exceptions); Predicates.and(Predicates.isInstanceOf(LayerInfo.class), filter); Filter layerGroupFilter = Predicates.isInstanceOf(LayerGroupInfo.class); return Predicates.or(layerFilter, layerGroupFilter); return rootAccess ? Filter.INCLUDE : Filter.EXCLUDE; } else { return rootAccess ? Predicates.and(exceptions) : Predicates.or(exceptions);
pvalue.setValue(readFilter); } else { Filter combined = Predicates.and(originalFilter, readFilter); pvalue.setValue(combined);
/** * If the current request contains a namespace we build a filter using the provided property * and request namespace and adds it to the provided filter. If the request doesn't contain * a namespace the original filter is returned as is. */ private Filter addNameSpaceFilterIfNeed(Filter filter, String nameSpaceProperty) { String nameSpacePrefix = request.getNamespace(); if (nameSpacePrefix == null) { return filter; } Filter equals = equal(nameSpaceProperty, nameSpacePrefix); return and(filter, equals); }
/** * If the current request contains a namespace we build a filter using the provided property * and request namespace and adds it to the provided filter. If the request doesn't contain * a namespace the original filter is returned as is. */ private Filter addNameSpaceFilterIfNeed(Filter filter, String nameSpaceProperty) { String nameSpacePrefix = request.getNamespace(); if (nameSpacePrefix == null) { return filter; } Filter equals = Predicates.equal(nameSpaceProperty, nameSpacePrefix); return Predicates.and(filter, equals); }
Filter filter = Predicates.and(filters); return filter;
public List<DataStoreInfo> findDataStores(final String repoId) { // get the name String repoName = null; try { repoName = this.get(repoId).getRepoName(); } catch (NoSuchElementException ioe) { Throwables.propagate(ioe); } Filter filter = equal("type", GeoGigDataStoreFactory.DISPLAY_NAME); String locationKey = "connectionParameters." + GeoGigDataStoreFactory.REPOSITORY.key; filter = and(filter, equal(locationKey, GeoServerGeoGigRepositoryResolver.getURI(repoName))); List<DataStoreInfo> dependent; try (CloseableIterator<DataStoreInfo> stores = this.catalog.list(DataStoreInfo.class, filter)) { dependent = Lists.newArrayList(stores); } return dependent; }
boolean layerConfigured(final WMTSStoreInfo store, final String nativeName) { final Filter filter = Predicates.and( Predicates.equal("store.name", store.getName()), Predicates.equal("nativeName", nativeName)); try (CloseableIterator<WMTSLayerInfo> it = catalog.list(WMTSLayerInfo.class, filter, 0, 1, null)) { return it.hasNext(); } }
boolean layerConfigured(final WMSStoreInfo store, final String nativeName) { final Filter filter = Predicates.and( Predicates.equal("store.name", store.getName()), Predicates.equal("nativeName", nativeName)); try (CloseableIterator<WMSLayerInfo> it = catalog.list(WMSLayerInfo.class, filter, 0, 1, null)) { return it.hasNext(); } }
@Override protected Filter getFilter() { Filter filter = super.getFilter(); // need to get only advertised and enabled layers Filter isLayerInfo = Predicates.isInstanceOf(LayerInfo.class); Filter isLayerGroupInfo = Predicates.isInstanceOf(LayerGroupInfo.class); Filter enabledFilter = Predicates.equal("resource.enabled", true); Filter storeEnabledFilter = Predicates.equal("resource.store.enabled", true); Filter advertisedFilter = Predicates.equal("resource.advertised", true); // return only layer groups that are not containers Filter nonContainerGroup = Predicates.or( Predicates.equal("mode", LayerGroupInfo.Mode.EO), Predicates.equal("mode", LayerGroupInfo.Mode.NAMED), Predicates.equal("mode", LayerGroupInfo.Mode.OPAQUE_CONTAINER), Predicates.equal("mode", LayerGroupInfo.Mode.SINGLE)); // Filter for the Layers Filter layerFilter = Predicates.and(isLayerInfo, enabledFilter, storeEnabledFilter, advertisedFilter); // Filter for the LayerGroups Filter layerGroupFilter = Predicates.and(isLayerGroupInfo, nonContainerGroup); // Or filter for merging them Filter orFilter = Predicates.or(layerFilter, layerGroupFilter); // And between the new filter and the initial filter return Predicates.and(filter, orFilter); }
private void handlePostWorkspaceChange(WorkspaceInfo source) { Catalog catalog = geoserver.getCatalog(); final String wsId = source.getId(); final String storeType = DISPLAY_NAME; Filter filter = and( equal("resource.store.workspace.id", wsId), equal("resource.store.type", storeType)); CloseableIterator<LayerInfo> affectedLayers = catalog.list(LayerInfo.class, filter); updateLayers(affectedLayers); }
@Override public GridCoverage2D answer() throws Throwable { GeneralParameterValue[] params = (GeneralParameterValue[]) EasyMock.getCurrentArguments()[0]; ParameterValue param = (ParameterValue) params[0]; Filter filter = (Filter) param.getValue(); assertEquals(Predicates.and(requestFilter, securityFilter), filter); return null; } });
query.setFilter(Predicates.and(filters));
filter = and(enabled, advertised);
FF.equal(parentIdProperty, FF.literal(parentId), true); resultsQuery = new Query(resultsQuery); resultsQuery.setFilter(Predicates.and(resultsQuery.getFilter(), parentIdFilter));