public List<LayerInfo> getLayers() { return filterLayers(acceptAll()); }
@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; }
PublishedInfo localPublished = LocalPublished.get(); if (localWS == null && localPublished == null) { return Predicates.acceptAll(); localLayerFilter = Predicates.acceptAll(); } else { return Predicates.or(localLayerFilter, inWorkspace()); } else if (WorkspaceInfo.class.isAssignableFrom(clazz)) { if (localWS == null) return Predicates.acceptAll(); return Predicates.equal("id", localWS.getId()); } else if (LayerGroupInfo.class.isAssignableFrom(clazz)) { Filter filter = standardFilter(clazz); Predicates.and( filter, factory.equals(factory.literal(Boolean.TRUE), subLayersHidden)); Predicates.and(filter, Predicates.equal("id", localPublished.getId())); } else if (localPublished instanceof LayerGroupInfo) { LayerGroupInfo lg = (LayerGroupInfo) localPublished; List<Filter> groupIdFilters = new ArrayList<>(); for (LayerGroupInfo group : groups) { groupIdFilters.add(Predicates.equal("id", group.getId())); return Predicates.or(groupIdFilters);
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 equal(property, expected, MatchAction.ANY);
if (nodeAccess != rootAccess) { if (rootAccess) { exceptions.add(Predicates.notEqual("name", wsName)); } else { exceptions.add(Predicates.equal("name", wsName)); return rootAccess ? Filter.INCLUDE : Filter.EXCLUDE; } else { return rootAccess ? Predicates.and(exceptions) : Predicates.or(exceptions); if (wsAccess) { layerExceptions.add( Predicates.notEqual("prefixedName", wsName + ":" + layerName)); } else { layerExceptions.add( Predicates.equal("prefixedName", wsName + ":" + layerName)); wsFilter = Predicates.notEqual(wsNameProperty, wsName); } else if (!rootAccess && wsAccess) { wsFilter = Predicates.equal(wsNameProperty, wsName); ? 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);
Filter enabled = equal("enabled", Boolean.TRUE); Filter advertised = equal("advertised", Boolean.TRUE); filter = and(enabled, advertised); Filter lgFilter = Predicates.acceptAll(); SortBy lgOrder = asc("name"); SortBy order = asc("name"); try (CloseableIterator<LayerGroupInfo> lgIter = catalog.list(LayerGroupInfo.class, lgFilter, null, null, lgOrder);
Filter filter = acceptAll(); Set<? extends CatalogInfo> expected; Set<? extends CatalogInfo> actual; filter = contains("name", "t"); actual = Sets.newHashSet(catalog.list(FeatureTypeInfo.class, filter)); assertTrue(expected.equals(actual)); assertEquals(expected, actual); filter = or(contains("name", "t2"), contains("name", "t1")); expected = Sets.newHashSet(ft1, ft2); actual = Sets.newHashSet(catalog.list(FeatureTypeInfo.class, filter)); filter = contains("styles.name", "s6"); expected = Sets.newHashSet(l3); actual = Sets.newHashSet(catalog.list(LayerInfo.class, filter)); assertEquals(expected, actual); filter = equal("defaultStyle.name", "s1"); expected = Sets.newHashSet(l1); actual = Sets.newHashSet(catalog.list(LayerInfo.class, filter)); assertEquals(expected, actual); filter = or(contains("styles.name", "s6"), equal("defaultStyle.name", "s1")); expected = Sets.newHashSet(l1, l3); actual = Sets.newHashSet(catalog.list(LayerInfo.class, filter)); assertEquals(expected, actual); filter = acceptAll();
@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()])); } }
List<LayerInfo> expected; filter = acceptAll(); sortOrder = asc("resource.name"); expected = Lists.newArrayList(l1, l2, l3); sortOrder = desc("resource.name"); expected = Lists.newArrayList(l3, l2, l1); sortOrder = asc("defaultStyle.name"); expected = Lists.newArrayList(l1, l2, l3); testOrderBy(LayerInfo.class, filter, null, null, sortOrder, expected); sortOrder = desc("defaultStyle.name"); expected = Lists.newArrayList(l3, l2, l1); sortOrder = asc("defaultStyle.name"); expected = Lists.newArrayList(l2, l3); testOrderBy(LayerInfo.class, filter, 1, 10, sortOrder, expected); filter = equal("styles.name", s3.getName()); expected = Lists.newArrayList(l2); testOrderBy(LayerInfo.class, filter, 0, 10, sortOrder, expected);
/** * This method returns a filter based on the defined keywords. * * @return a {@link Filter} which uses the defined Keywords. If no keyword is present * Filter.INCLUDE is returned */ protected Filter getFilter() { final String[] keywords = getKeywords(); Filter filter = acceptAll(); if (null != keywords) { for (String keyword : keywords) { Filter propContains = Predicates.fullTextSearch(keyword); // chain the filters together if (Filter.INCLUDE == filter) { filter = propContains; } else { filter = or(filter, propContains); } } } return filter; }
/** * Returns a list of name-ordered LayerGroupInfo, and filtered by namespace if needed * * @return LayerGroupInfo list */ private List<LayerGroupInfo> getOrderedLayerGroups() { Catalog catalog = wmsConfig.getCatalog(); // namespace filter Filter filter = Predicates.acceptAll(); addNameSpaceFilterIfNeed(filter, "workspace.name"); // order by name ASC SortBy order = asc("name"); // get list from iterator try (CloseableIterator<LayerGroupInfo> iter = catalog.list(LayerGroupInfo.class, filter, null, null, order)) { return Lists.newArrayList(iter); } }
/** * Returns a list of name-ordered LayerInfo, and filtered by namespace if needed * * @return LayerInfo list */ private List<LayerInfo> getOrderedLayers() { Catalog catalog = wmsConfig.getCatalog(); Filter filter = equal("enabled", Boolean.TRUE); // namespace filter addNameSpaceFilterIfNeed(filter, "resource.namespace.prefix"); // order by name ASC SortBy order = asc("name"); // get list: try (CloseableIterator<LayerInfo> iter = catalog.list(LayerInfo.class, filter, null, null, order)) { return Lists.newArrayList(iter); } }
public static SortBy asc(final String propertyName) { return sortBy(propertyName, true); }
@Test public void testFunction() { Filter filter = Predicates.isInstanceOf(Object.class); // Ensure the filter exists assertNotNull(filter); // Ensure the filter returned is a PropertyIsEqual filter assertTrue(filter instanceof PropertyIsEqualTo); }
private Filter buildSearchTermsFilter(Object value) { String converted = getParameter(SEARCH_TERMS.key, value, String.class); // split into parts separated by spaces, but not bits in double quotes Pattern MATCH_TERMS_SPLITTER = Pattern.compile("([^\"]\\S*|\".+?\")\\s*"); Matcher m = MATCH_TERMS_SPLITTER.matcher(converted); List<String> keywords = new ArrayList<>(); while (m.find()) { String group = m.group(1); if (group.startsWith("\"") && group.endsWith("\"") && group.length() > 1) { group = group.substring(1, group.length() - 1); } keywords.add(group); } // turn into a list of Like filters // TODO: actually implement a full text search function List<Filter> filters = keywords.stream() .map(s -> FF.like(FF.property("htmlDescription"), "%" + s + "%")) .collect(Collectors.toList()); // combine and return Filter result = Predicates.or(filters); return result; }
private int countFeatureTypesOf(DataStoreInfo ds) { Filter filter = Predicates.equal("store.id", ds.getId()); int dsTypeCount = catalog.count(FeatureTypeInfo.class, filter); return dsTypeCount; }
@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); }