return equal(property, expected, MatchAction.ANY);
@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; }
private int countFeatureTypesOf(DataStoreInfo ds) { Filter filter = Predicates.equal("store.id", ds.getId()); int dsTypeCount = catalog.count(FeatureTypeInfo.class, filter); return dsTypeCount; }
public List<LayerInfo> getLayers(ResourceInfo resource) { return filterLayers(Predicates.equal("resource.id", resource.getId())); }
private Filter inWorkspace() { WorkspaceInfo localWS = LocalWorkspace.get(); if (localWS == null) return Predicates.acceptAll(); return Predicates.equal("workspace.id", localWS.getId()); }
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); } } } }
@Test public void testPropertyEqualsSimple() { assertTrue(equal("prefix", ns.getPrefix()).evaluate(ns)); assertTrue(equal("id", ws.getId()).evaluate(ws)); assertFalse(equal("id", "somethingElse").evaluate(ws)); Set<StyleInfo> styles = new HashSet<StyleInfo>(); styles.add(style1); assertFalse(equal("styles", styles, MatchAction.ALL).evaluate(vectorLayer)); assertTrue(equal("styles", styles, MatchAction.ANY).evaluate(vectorLayer)); styles.add(style2); assertTrue(equal("styles", styles).evaluate(vectorLayer)); }
public void visit(StyleInfo style) { Filter anyStyle = Predicates.equal("styles", style, MatchAction.ANY); Filter layersAssociated = Predicates.or(Predicates.equal("defaultStyle", style), anyStyle); Filter groupAssociated = Predicates.or(Predicates.equal("rootLayerStyle", style), anyStyle); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, groupAssociated)) {
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); }
@Test public void testPropertyEqualsCompound() { assertTrue(equal("resource.id", featureType.getId()).evaluate(vectorLayer)); assertTrue( equal("resource.maxFeatures", featureType.getMaxFeatures()).evaluate(vectorLayer)); assertTrue(equal("resource.store.type", dataStore.getType()).evaluate(vectorLayer)); assertTrue( equal("resource.store.connectionParameters.boolParam", true).evaluate(vectorLayer)); assertFalse( equal("resource.store.connectionParameters.boolParam", false) .evaluate(vectorLayer)); ws.getMetadata().put("checkMe", new java.util.Date(1000)); assertTrue(equal("metadata.checkMe", new java.util.Date(1000)).evaluate(ws)); assertFalse( equal("resource.store.someNonExistentProperty", "someValue").evaluate(vectorLayer)); }
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); }
@Test public void testPropertyEqualsConverters() { Object expected; expected = featureType.getMaxFeatures(); assertTrue(equal("resource.maxFeatures", expected).evaluate(vectorLayer)); expected = String.valueOf(featureType.getMaxFeatures()); assertTrue(equal("resource.maxFeatures", expected).evaluate(vectorLayer)); expected = new Double(featureType.getMaxFeatures()); assertTrue(equal("resource.maxFeatures", expected).evaluate(vectorLayer)); expected = "true"; assertTrue( equal("resource.store.connectionParameters.boolParam", expected) .evaluate(vectorLayer)); expected = "false"; assertFalse( equal("resource.store.connectionParameters.boolParam", false) .evaluate(vectorLayer)); ws.getMetadata().put("checkMe", new java.util.Date(1000)); expected = new java.sql.Timestamp(1000); assertTrue( equal("resource.store.workspace.metadata.checkMe", expected).evaluate(vectorLayer)); assertFalse( equal("resource.store.someNonExistentProperty", "someValue").evaluate(vectorLayer)); }
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); }
@Test public void testPropertyEqualsIndexed() { AuthorityURLInfo aurl1 = new AuthorityURL(); aurl1.setName("url1"); AuthorityURLInfo aurl2 = new AuthorityURL(); aurl2.setName("url2"); AuthorityURLInfo aurl3 = new AuthorityURL(); aurl3.setName("url3"); vectorLayer.setAuthorityURLs(Arrays.asList(aurl1, aurl2, aurl3)); assertTrue(equal("authorityURLs[1]", aurl1).evaluate(vectorLayer)); assertTrue(equal("authorityURLs[1].name", aurl1.getName()).evaluate(vectorLayer)); assertTrue(equal("authorityURLs[2]", aurl2).evaluate(vectorLayer)); assertTrue(equal("authorityURLs[2].name", aurl2.getName()).evaluate(vectorLayer)); assertTrue(equal("authorityURLs[3]", aurl3).evaluate(vectorLayer)); assertTrue(equal("authorityURLs[3].name", aurl3.getName()).evaluate(vectorLayer)); }
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));
filter = equal("id", ft1.getId()); FeatureTypeInfo featureTypeInfo = catalog.get(FeatureTypeInfo.class, filter); assertEquals(ft1.getId(), featureTypeInfo.getId()); filter = equal("name", ft2.getName()); assertEquals(ft2.getName(), catalog.get(ResourceInfo.class, filter).getName()); filter = equal("keywords[1].value", ft1.getKeywords().get(0).getValue()); assertEquals(ft1.getName(), catalog.get(ResourceInfo.class, filter).getName()); filter = equal("keywords[2]", ft2.getKeywords().get(1)); assertEquals(ft2.getName(), catalog.get(FeatureTypeInfo.class, filter).getName()); filter = equal("keywords[3].value", "repeatedKw"); try { catalog.get(FeatureTypeInfo.class, filter).getName(); filter = equal("defaultStyle.filename", "s1Filename"); assertEquals(l1.getId(), catalog.get(LayerInfo.class, filter).getId()); filter = equal("defaultStyle.name", s2.getName()); assertEquals(l2.getId(), catalog.get(LayerInfo.class, filter).getId()); filter = equal("styles.id", s2.getId(), MatchAction.ONE); assertEquals(l1.getId(), catalog.get(LayerInfo.class, filter).getId()); filter = equal("styles.id", s3.getId(), MatchAction.ANY); // s3 is shared by l1 and l2 try { catalog.get(LayerInfo.class, filter);
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);