public void visit(LayerInfo layer) {
// first update the groups, remove the layer, and if no
// other layers remained, remove the group as well
for (LayerGroupInfo group : catalog.getLayerGroups()) {
if (group.getLayers().contains(layer)) {
// parallel remove of layer and styles
int index = group.getLayers().indexOf(layer);
group.getLayers().remove(index);
group.getStyles().remove(index);
// either update or remove the group
if (group.getLayers().size() == 0) {
catalog.remove(group);
} 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);
}
public void visit(LayerGroupInfo layerGroupToRemove) {
// remove layerGroupToRemove references from other groups
List<LayerGroupInfo> groups = catalog.getLayerGroups();
for (LayerGroupInfo group : groups) {
if (group.getLayers().remove(layerGroupToRemove)) {
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(StyleInfo style) {
// remove style references in layers
List<LayerInfo> layers = catalog.getLayers();
for (LayerInfo layer : layers) {
removeStyleInLayer(layer, style);
}
// groups can also refer to style, reset each reference to the
// associated layer default style
List<LayerGroupInfo> groups = catalog.getLayerGroups();
for (LayerGroupInfo group : groups) {
removeStyleInLayerGroup(group, style);
}
// finally remove the style
catalog.remove(style);
}
public void visit(StyleInfo style) {
// add users of this style among the related objects: layers
List<LayerInfo> layer = catalog.getLayers();
for (LayerInfo li : layer) {
// if it's the default style, reset it to the default one
if (li.getDefaultStyle().equals(style)) {
try {
li.setDefaultStyle(new CatalogBuilder(catalog).getDefaultStyle(li.getResource()));
catalog.save(li);
} catch (IOException e) {
// we fall back on the default style (since we cannot roll back the
// entire operation, no transactions in the catalog)
LOGGER.log(
Level.WARNING,
"Could not find default style for resource "
+ li.getResource()
+ " resetting the default to null");
li.setDefaultStyle(null);
}
}
// remove it also from the associated styles
if (li.getStyles().remove(style)) catalog.save(li);
}
// groups can also refer styles, reset each reference to the
// associated layer default style
List<LayerGroupInfo> groups = catalog.getLayerGroups();
for (LayerGroupInfo group : groups) {
List<StyleInfo> styles = group.getStyles();
boolean dirty = false;
for (int i = 0; i < styles.size(); i++) {
StyleInfo si = styles.get(i);
if (si != null && si.equals(style)) {
styles.set(i, group.getLayers().get(i).getDefaultStyle());
dirty = true;
}
}
if (dirty) catalog.save(group);
}
// finally remove the style
catalog.remove(style);
}
public MockCatalogBuilder commit() {
if (!featureTypes.isEmpty() || !coverages.isEmpty()) {
if (!featureTypes.isEmpty()) {
DataStoreInfo ds = dataStores.peekLast();
expect(catalog.getResourcesByStore(ds, FeatureTypeInfo.class))
.andReturn(featureTypes)
.anyTimes();
expect(catalog.getResourcesByStore(ds, ResourceInfo.class))
.andReturn((List) featureTypes)
.anyTimes();
expect(catalog.getFeatureTypesByDataStore(ds)).andReturn(featureTypes).anyTimes();
}
if (!coverages.isEmpty()) {
CoverageStoreInfo cs = coverageStores.peekLast();
expect(catalog.getResourcesByStore(cs, CoverageInfo.class)).andReturn(coverages).anyTimes();
expect(catalog.getResourcesByStore(cs, ResourceInfo.class))
.andReturn((List) coverages)
.anyTimes();
expect(catalog.getCoveragesByCoverageStore(cs)).andReturn(coverages).anyTimes();
}
// clear out local lists but push up to be included when this workspace is complete
featureTypesByNamespace.addAll(featureTypes);
featureTypes = new LinkedList<FeatureTypeInfo>();
coveragesByNamespace.addAll(coverages);
coverages = new LinkedList<CoverageInfo>();
} else if (!dataStores.isEmpty() || !coverageStores.isEmpty()) {
WorkspaceInfo ws = workspaces.peekLast();
NamespaceInfo ns = namespaces.peekLast();
expect(catalog.getStoresByWorkspace(ws.getName(), DataStoreInfo.class))
.andReturn(dataStores)
.anyTimes();
expect(catalog.getStoresByWorkspace(ws, DataStoreInfo.class))
.andReturn(dataStores)
.anyTimes();
expect(catalog.getDataStoresByWorkspace(ws.getName())).andReturn(dataStores).anyTimes();
expect(catalog.getDataStoresByWorkspace(ws)).andReturn(dataStores).anyTimes();
expect(catalog.getStoresByWorkspace(ws.getName(), CoverageStoreInfo.class))
.andReturn(coverageStores)
.anyTimes();
expect(catalog.getStoresByWorkspace(ws, CoverageStoreInfo.class))
.andReturn(coverageStores)
.anyTimes();
expect(catalog.getCoverageStoresByWorkspace(ws.getName()))
.andReturn(coverageStores)
.anyTimes();
expect(catalog.getCoverageStoresByWorkspace(ws)).andReturn(coverageStores).anyTimes();
List<StoreInfo> l = new LinkedList<StoreInfo>(dataStores);
l.addAll(coverageStores);
expect(catalog.getStoresByWorkspace(ws.getName(), StoreInfo.class)).andReturn(l).anyTimes();
expect(catalog.getStoresByWorkspace(ws, StoreInfo.class)).andReturn(l).anyTimes();
// add all the resources for this workspace
List<ResourceInfo> m = new LinkedList(featureTypesByNamespace);
m.addAll(coveragesByNamespace);
expect(catalog.getResourcesByNamespace(ns, ResourceInfo.class)).andReturn(m).anyTimes();
// expect(catalog.getResourcesByNamespace(ns.getPrefix(),
// ResourceInfo.class)).andReturn(m).anyTimes();
expect(catalog.getResourcesByNamespace(ns, FeatureTypeInfo.class))
.andReturn(featureTypesByNamespace)
.anyTimes();
// expect(catalog.getResourcesByNamespace(ns.getPrefix(), FeatureTypeInfo.class))
// .andReturn(featureTypesByNamespace).anyTimes();
expect(catalog.getResourcesByNamespace(ns, CoverageInfo.class))
.andReturn(coveragesByNamespace)
.anyTimes();
// expect(catalog.getResourcesByNamespace(ns.getPrefix(), CoverageInfo.class))
// .andReturn(coveragesByNamespace).anyTimes();
dataStoresAll.addAll(dataStores);
dataStores = new LinkedList();
coverageStoresAll.addAll(coverageStores);
coverageStores = new LinkedList();
featureTypesAll.addAll(featureTypesByNamespace);
featureTypesByNamespace = new LinkedList();
coveragesAll.addAll(coveragesByNamespace);
coveragesByNamespace = new LinkedList();
} else if (!workspaces.isEmpty()) {
// all the resources
List<ResourceInfo> l = new LinkedList<ResourceInfo>(featureTypesAll);
l.addAll(coveragesAll);
expect(catalog.getResources(ResourceInfo.class)).andReturn(l).anyTimes();
expect(catalog.getResources(FeatureTypeInfo.class)).andReturn(featureTypesAll).anyTimes();
expect(catalog.getResources(CoverageInfo.class)).andReturn(coverages).anyTimes();
expect(catalog.getFeatureTypes()).andReturn(featureTypesAll).anyTimes();
expect(catalog.getCoverages()).andReturn(coveragesAll).anyTimes();
// add all the stores
List<StoreInfo> m = new LinkedList<StoreInfo>(dataStoresAll);
m.addAll(coverageStoresAll);
expect(catalog.getStores(StoreInfo.class)).andReturn(m).anyTimes();
expect(catalog.getStores(DataStoreInfo.class)).andReturn(dataStoresAll).anyTimes();
expect(catalog.getStores(CoverageStoreInfo.class)).andReturn(coverageStoresAll).anyTimes();
// add all the styles
expect(catalog.getStyles()).andReturn(styles).anyTimes();
// add all the layer groups
expect(catalog.getLayerGroups()).andReturn(layerGroups).anyTimes();
// add all the workspaces/namespaces
expect(catalog.getWorkspaces()).andReturn(workspaces).anyTimes();
expect(catalog.getNamespaces()).andReturn(namespaces).anyTimes();
// default workspace/namespace
expect(catalog.getDefaultWorkspace()).andReturn(workspaces.peekFirst()).anyTimes();
expect(catalog.getDefaultNamespace()).andReturn(namespaces.peekFirst()).anyTimes();
replay(catalog);
featureTypesAll = new LinkedList();
coveragesAll = new LinkedList();
dataStoresAll = new LinkedList();
coverageStoresAll = new LinkedList();
styles = new LinkedList();
workspaces = new LinkedList();
namespaces = new LinkedList();
}
return this;
}
