@Override public <T extends CatalogInfo> CloseableIterator<T> list( Class<T> of, Filter filter, Integer offset, Integer count, SortBy sortOrder) { return delegate.list(of, filter, offset, count, sortOrder); }
@Override public <T extends CatalogInfo> CloseableIterator<T> list(Class<T> of, Filter filter) { return delegate.list(of, filter); }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( Class<T> of, Filter filter, Integer offset, Integer count, SortBy sortBy) { Filter securityFilter = securityFilter(of, filter); CloseableIterator<T> filtered; filtered = delegate.list(of, securityFilter, offset, count, sortBy); // create secured decorators on-demand final Function<T, T> securityWrapper = securityWrapper(of); final CloseableIterator<T> filteredWrapped; filteredWrapped = CloseableIteratorAdapter.transform(filtered, securityWrapper); return filteredWrapped; }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( Class<T> of, Filter filter, Integer offset, Integer count, SortBy sortBy) { Filter securityFilter = securityFilter(of, filter); CloseableIterator<T> filtered; filtered = delegate.list(of, securityFilter, offset, count, sortBy); // create secured decorators on-demand. Assume this method is used only for listing, not // for accessing a single resource by name/id, thus use hide policy for mixed mode final Function<T, T> securityWrapper = securityWrapper(of, MixedModeBehavior.HIDE); final CloseableIterator<T> filteredWrapped; filteredWrapped = CloseableIteratorAdapter.transform(filtered, securityWrapper); // wrap the iterator in a notNull filter to ensure any filtered // layers (result is null) don't get passed on from the securityWrapper // Function. When the AccessLevel is HIDDEN and a layer gets filtered // out via a CatalogFilter - for example, this can happen with a // LocalWorkspaceCatalogFilter and a virtual service request return CloseableIteratorAdapter.filter( filteredWrapped, com.google.common.base.Predicates.<T>notNull()); }
public void visit(LayerGroupInfo layerGroupToRemove) { Filter associatedTo = Predicates.equal("layers", layerGroupToRemove, MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, associatedTo)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); if (group.getLayers().contains(layerGroupToRemove)) { final List<PublishedInfo> layers = new ArrayList<>(group.getLayers()); layers.removeAll(objects.keySet()); if (layers.size() == 0) { visit(group); } else { add(group, ModificationType.GROUP_CHANGED); } } } } add(layerGroupToRemove, ModificationType.DELETE); } }
public void visit(LayerInfo layer) { // mark layer and resource as removed add(layer.getResource(), ModificationType.DELETE); add(layer, ModificationType.DELETE); // scan the layer groups and find those that do use the // current layer Filter groupContainsLayer = Predicates.equal("layers", layer, MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, groupContainsLayer)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); // mark the layer as one that will be removed Set<LayerInfo> layers = groups.get(group); if (layers == null) { layers = new HashSet<LayerInfo>(); groups.put(group, layers); } layers.add(layer); // a group can contain the same layer multiple times. We want to // make sure to mark the group as removed if all the layers inside of // it are going to be removed, just changed otherwise if (layers.size() == new HashSet<PublishedInfo>(group.getLayers()).size()) { visit(group); } else { add(group, ModificationType.GROUP_CHANGED); } } } }
/** * Returns a decorating iterator over the one returned by the delegate that wraps every object * it returns, if possible. * * @see #wrap(Object, Class) * @see org.geoserver.catalog.Catalog#list(java.lang.Class, org.geoserver.catalog.Predicate, * java.lang.Integer, java.lang.Integer, org.geoserver.catalog.OrderBy) */ @Override public <T extends CatalogInfo> CloseableIterator<T> list( final Class<T> of, final Filter filter, final Integer offset, final Integer count, final SortBy sortBy) { CloseableIterator<T> iterator = delegate.list(of, filter, offset, count, sortBy); if (iterator.hasNext() && useNameDequalifyingProxy()) { return CloseableIteratorAdapter.transform( iterator, obj -> obj == null ? null : NameDequalifyingProxy.create(obj, of)); } return iterator; }
public void visit(LayerGroupInfo layerGroupToRemove) { // remove layerGroupToRemove references from other groups Filter associatedTo = Predicates.equal("layers.id", layerGroupToRemove.getId(), MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, associatedTo)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); // parallel remove of layer and styles int index = getLayerGroupIndex(layerGroupToRemove, group); while (index != -1) { group.getLayers().remove(index); group.getStyles().remove(index); index = getLayerGroupIndex(layerGroupToRemove, group); } if (group.getLayers().size() == 0) { // if group is empty, delete it visit(group); } else { catalog.save(group); } } } // finally remove the group catalog.remove(layerGroupToRemove); }
public void visit(LayerInfo layer) { // first update the groups, remove the layer, and if no // other layers remained, remove the group as well Filter groupContainsLayer = Predicates.equal("layers.id", layer.getId(), MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> groups = catalog.list(LayerGroupInfo.class, groupContainsLayer)) { while (groups.hasNext()) { LayerGroupInfo group = groups.next(); // parallel remove of layer and styles int index = group.getLayers().indexOf(layer); while (index != -1) { group.getLayers().remove(index); group.getStyles().remove(index); index = group.getLayers().indexOf(layer); } // either update or remove the group if (group.getLayers().size() == 0) { visit(catalog.getLayerGroup(group.getId())); } else { catalog.save(group); } } } // remove the layer and (for the moment) its resource as well // TODO: change this to just remove the resource once the // resource/publish split is done ResourceInfo resource = layer.getResource(); catalog.remove(layer); catalog.remove(resource); }
assertEquals(newHashSet(l, l2), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(ft, cv), asSet(catalog.list(ResourceInfo.class, filter))); assertEquals(newHashSet(ft), asSet(catalog.list(FeatureTypeInfo.class, filter))); assertEquals(newHashSet(cv), asSet(catalog.list(CoverageInfo.class, filter))); assertEquals(newHashSet(l), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(ft), asSet(catalog.list(ResourceInfo.class, filter))); assertEquals(newHashSet(ft), asSet(catalog.list(FeatureTypeInfo.class, filter))); assertEquals(newHashSet(), asSet(catalog.list(CoverageInfo.class, filter))); assertEquals(newHashSet(l2), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(cv), asSet(catalog.list(ResourceInfo.class, filter))); assertEquals(newHashSet(), asSet(catalog.list(FeatureTypeInfo.class, filter))); assertEquals(newHashSet(cv), asSet(catalog.list(CoverageInfo.class, filter))); assertEquals(newHashSet(), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(), asSet(catalog.list(ResourceInfo.class, filter))); assertEquals(newHashSet(), asSet(catalog.list(FeatureTypeInfo.class, filter))); assertEquals(newHashSet(), asSet(catalog.list(CoverageInfo.class, filter)));
@Test public void testFullTextSearchLayerGroupName() { addLayer(); // geos-6882 catalog.add(lg); Filter filter = Predicates.fullTextSearch("Group"); assertEquals(newHashSet(lg), asSet(catalog.list(LayerGroupInfo.class, filter))); }
public void visit(StyleInfo style) { // find the layers having this style as primary or secondary Filter anyStyle = Predicates.equal("styles.id", style.getId(), MatchAction.ANY); Filter layersAssociated = Predicates.or(Predicates.equal("defaultStyle.id", style.getId()), anyStyle); // remove style references in layers try (CloseableIterator<LayerInfo> it = catalog.list(LayerInfo.class, layersAssociated)) { while (it.hasNext()) { LayerInfo layer = it.next(); removeStyleInLayer(layer, style); } } // groups can also refer to style, reset each reference to the // associated layer default style Filter groupAssociated = Predicates.or(Predicates.equal("rootLayerStyle.id", style.getId()), anyStyle); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, groupAssociated)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); removeStyleInLayerGroup(group, style); } } // finally remove the style catalog.remove(style); }
assertEquals(newHashSet(ft, cv), asSet(catalog.list(ResourceInfo.class, filter))); assertEquals(newHashSet(ft), asSet(catalog.list(FeatureTypeInfo.class, filter))); assertEquals(newHashSet(cv), asSet(catalog.list(CoverageInfo.class, filter))); assertEquals(newHashSet(l, l2), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(l), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(l2), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(l, l2), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(l), asSet(catalog.list(LayerInfo.class, filter))); assertEquals(newHashSet(l2), asSet(catalog.list(LayerInfo.class, filter)));
@Test public void testFullTextSearchAddedKeyword() { ft.getKeywords().add(new Keyword("air_temp")); ft.getKeywords().add(new Keyword("temperatureAir")); l.setResource(ft); addLayer(); LayerInfo lproxy = catalog.getLayer(l.getId()); FeatureTypeInfo ftproxy = (FeatureTypeInfo) lproxy.getResource(); ftproxy.getKeywords().add(new Keyword("newKeyword")); catalog.save(ftproxy); Filter filter = Predicates.fullTextSearch("newKeyword"); assertEquals(newHashSet(ftproxy), asSet(catalog.list(FeatureTypeInfo.class, filter))); assertEquals(newHashSet(lproxy), asSet(catalog.list(LayerInfo.class, filter))); }
@Test public void testFullTextSearchLayerGroupTitle() { addLayer(); // geos-6882 lg.setTitle("LayerGroup title"); catalog.add(lg); // test layer group title and abstract search Filter filter = Predicates.fullTextSearch("title"); assertEquals(newHashSet(lg), asSet(catalog.list(LayerGroupInfo.class, filter))); }
@Test public void testFullTextSearchLayerGroupAbstract() { addLayer(); lg.setAbstract("GeoServer OpenSource GIS"); catalog.add(lg); Filter filter = Predicates.fullTextSearch("geoserver"); assertEquals(newHashSet(lg), asSet(catalog.list(LayerGroupInfo.class, filter))); }
private <T extends CatalogInfo> void testOrderBy( Class<T> clazz, Filter filter, Integer offset, Integer limit, SortBy sortOrder, List<T> expected) { CatalogPropertyAccessor pe = new CatalogPropertyAccessor(); List<Object> props = new ArrayList<Object>(); List<Object> actual = new ArrayList<Object>(); String sortProperty = sortOrder.getPropertyName().getPropertyName(); for (T info : expected) { Object pval = pe.getProperty(info, sortProperty); props.add(pval); } CloseableIterator<T> it = catalog.list(clazz, filter, offset, limit, sortOrder); try { while (it.hasNext()) { Object property = pe.getProperty(it.next(), sortProperty); actual.add(property); } } finally { it.close(); } assertEquals(props, actual); }
actual = Sets.newHashSet(catalog.list(FeatureTypeInfo.class, filter)); assertEquals(3, actual.size()); assertEquals(expected, actual); actual = Sets.newHashSet(catalog.list(FeatureTypeInfo.class, filter)); assertTrue(expected.equals(actual)); assertEquals(expected, actual); actual = Sets.newHashSet(catalog.list(FeatureTypeInfo.class, filter)); assertEquals(expected, actual); actual = Sets.newHashSet(catalog.list(LayerInfo.class, filter)); assertEquals(expected, actual); actual = Sets.newHashSet(catalog.list(LayerInfo.class, filter)); assertEquals(expected, actual); actual = Sets.newHashSet(catalog.list(LayerInfo.class, filter)); assertEquals(expected, actual); Lists.newArrayList(catalog.list(LayerInfo.class, filter)); assertEquals(3, naturalOrder.size()); assertEquals( naturalOrder.subList(0, 2), Lists.newArrayList(catalog.list(LayerInfo.class, filter, offset, limit, null))); Lists.newArrayList(catalog.list(LayerInfo.class, filter, offset, limit, null)));
layers2.add(null); expect( cat.list( LayerInfo.class, Filter.INCLUDE,