public void setNativeBox(Catalog catalog, String name) throws Exception {
FeatureTypeInfo fti = catalog.getFeatureTypeByName(name);
fti.setNativeBoundingBox(fti.getFeatureSource(null, null).getBounds());
fti.setLatLonBoundingBox(
new ReferencedEnvelope(fti.getNativeBoundingBox(), DefaultGeographicCRS.WGS84));
catalog.save(fti);
}
private LayerReference vectorLayer() throws IOException {
Catalog catalog = getCatalog();
FeatureTypeInfo typeInfo = catalog.getFeatureTypeByName(VECTOR_LAYER_NAME);
FeatureSource<? extends FeatureType, ? extends Feature> source;
source = typeInfo.getFeatureSource(null, null);
LayerReference layerReference = new LayerReference(VECTOR_LAYER_NAME, source);
return layerReference;
}
public MockCatalogBuilder featureType(
final String name,
String srs,
ProjectionPolicy projPolicy,
ReferencedEnvelope envelope,
ReferencedEnvelope latLonEnvelope) {
String ftId = newId();
final DataStoreInfo ds = dataStores.peekLast();
NamespaceInfo ns = namespaces.peekLast();
final FeatureTypeInfo ft = createNiceMock(FeatureTypeInfo.class);
featureTypes.add(ft);
initResource(
ft, FeatureTypeInfo.class, ftId, name, ds, ns, srs, projPolicy, envelope, latLonEnvelope);
expect(ft.getNumDecimals()).andReturn(8);
// setup the property file data
File propDir = new File(dataDirRoot, ds.getName());
propDir.mkdirs();
String fileName = name + ".properties";
try {
IOUtils.copy(getClass().getResourceAsStream(fileName), new File(propDir, fileName));
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
expect(ft.getFeatureType())
.andAnswer(
new IAnswer<FeatureType>() {
@Override
public FeatureType answer() throws Throwable {
return ((DataStore) ds.getDataStore(null)).getSchema(name);
}
})
.anyTimes();
expect(ft.getFeatureSource(null, null))
.andAnswer(
(IAnswer)
new IAnswer<FeatureSource>() {
@Override
public FeatureSource answer() throws Throwable {
return ((DataStore) ds.getDataStore(null)).getFeatureSource(name);
}
})
.anyTimes();
} catch (IOException e) {
}
expect(catalog.getFeatureTypeByName(or(eq(name), eq(ns.getPrefix() + ":" + name))))
.andReturn(ft)
.anyTimes();
expect(
catalog.getFeatureTypeByName(
or(eq(new NameImpl(ns.getPrefix(), name)), eq(new NameImpl(ns.getURI(), name)))))
.andReturn(ft)
.anyTimes();
expect(catalog.getFeatureTypeByName(ns, name)).andReturn(ft).anyTimes();
expect(catalog.getFeatureTypeByName(ns.getPrefix(), name)).andReturn(ft).anyTimes();
// expect(catalog.getFeatureTypeByName(or(eq(ns.getPrefix()), eq(ns.getURI())), name))
// .andReturn(ft).anyTimes();
expect(catalog.getFeatureTypeByStore(ds, name)).andReturn(ft).anyTimes();
expect(catalog.getFeatureTypeByDataStore(ds, name)).andReturn(ft).anyTimes();
ft.accept((CatalogVisitor) anyObject());
expectLastCall()
.andAnswer(
new VisitAnswer() {
@Override
protected void doVisit(CatalogVisitor visitor) {
visitor.visit(ft);
}
})
.anyTimes();
callback.onResource(name, ft, ds, this);
replay(ft, createLayer(ft, name, ns));
return this;
}
/**
* Loads the feature collection based on the current styling and the scale denominator. If no
* feature is going to be returned a null feature collection will be returned instead
*
* @param featureSource
* @param layer
* @param mapContent
* @param wms
* @param scaleDenominator
* @return
* @throws Exception
*/
public static SimpleFeatureCollection loadFeatureCollection(
SimpleFeatureSource featureSource,
Layer layer,
WMSMapContent mapContent,
WMS wms,
double scaleDenominator)
throws Exception {
SimpleFeatureType schema = featureSource.getSchema();
Envelope envelope = mapContent.getRenderingArea();
ReferencedEnvelope aoi =
new ReferencedEnvelope(envelope, mapContent.getCoordinateReferenceSystem());
CoordinateReferenceSystem sourceCrs = schema.getCoordinateReferenceSystem();
boolean reprojectBBox =
(sourceCrs != null)
&& !CRS.equalsIgnoreMetadata(aoi.getCoordinateReferenceSystem(), sourceCrs);
if (reprojectBBox) {
aoi = aoi.transform(sourceCrs, true);
}
Filter filter = createBBoxFilter(schema, aoi);
// now build the query using only the attributes and the bounding
// box needed
Query q = new Query(schema.getTypeName());
q.setFilter(filter);
// now, if a definition query has been established for this layer,
// be sure to respect it by combining it with the bounding box one.
Query definitionQuery = layer.getQuery();
if (definitionQuery != Query.ALL) {
if (q == Query.ALL) {
q = (Query) definitionQuery;
} else {
q = (Query) DataUtilities.mixQueries(definitionQuery, q, "KMLEncoder");
}
}
// handle startIndex requested by client query
q.setStartIndex(definitionQuery.getStartIndex());
// check the regionating strategy
RegionatingStrategy regionatingStrategy = null;
String stratname = (String) mapContent.getRequest().getFormatOptions().get("regionateBy");
if (("auto").equals(stratname)) {
Catalog catalog = wms.getGeoServer().getCatalog();
Name name = layer.getFeatureSource().getName();
stratname =
catalog
.getFeatureTypeByName(name)
.getMetadata()
.get("kml.regionateStrategy", String.class);
if (stratname == null || "".equals(stratname)) {
stratname = "best_guess";
LOGGER.log(
Level.FINE,
"No default regionating strategy has been configured in "
+ name
+ "; using automatic best-guess strategy.");
}
}
if (stratname != null) {
regionatingStrategy = findStrategyByName(stratname);
// if a strategy was specified but we did not find it, let the user
// know
if (regionatingStrategy == null)
throw new ServiceException("Unknown regionating strategy " + stratname);
}
// try to load less features by leveraging regionating strategy and the
// SLD
Filter regionatingFilter = Filter.INCLUDE;
if (regionatingStrategy != null)
regionatingFilter = regionatingStrategy.getFilter(mapContent, layer);
Filter ruleFilter =
summarizeRuleFilters(
getLayerRules(featureSource.getSchema(), layer.getStyle()), scaleDenominator);
Filter finalFilter = joinFilters(q.getFilter(), ruleFilter, regionatingFilter);
if (finalFilter == Filter.EXCLUDE) {
// if we don't have any feature to return
return null;
}
q.setFilter(finalFilter);
// make sure we output in 4326 since that's what KML mandates
CoordinateReferenceSystem wgs84;
try {
wgs84 = CRS.decode("EPSG:4326");
} catch (Exception e) {
throw new RuntimeException(
"Cannot decode EPSG:4326, the CRS subsystem must be badly broken...");
}
if (sourceCrs != null && !CRS.equalsIgnoreMetadata(wgs84, sourceCrs)) {
return new ReprojectFeatureResults(featureSource.getFeatures(q), wgs84);
}
return featureSource.getFeatures(q);
}
public ValueCollectionType run(GetPropertyValueType request) throws WFSException {
// check the request resolve
if (request.isSetResolve() && !ResolveValueType.NONE.equals(request.getResolve())) {
throw new WFSException(request, "Only resolve = none is supported", "InvalidParameterValue")
.locator("resolve");
}
if (request.getValueReference() == null) {
throw new WFSException(request, "No valueReference specified", "MissingParameterValue")
.locator("valueReference");
}
// do a getFeature request
GetFeatureType getFeature = Wfs20Factory.eINSTANCE.createGetFeatureType();
getFeature.getAbstractQueryExpression().add(request.getAbstractQueryExpression());
FeatureCollectionType fc =
(FeatureCollectionType) delegate.run(GetFeatureRequest.adapt(getFeature)).getAdaptee();
QueryType query = (QueryType) request.getAbstractQueryExpression();
QName typeName = (QName) query.getTypeNames().iterator().next();
FeatureTypeInfo featureType =
catalog.getFeatureTypeByName(typeName.getNamespaceURI(), typeName.getLocalPart());
try {
// look for the attribute type
AttributeTypeInfo attribute = null;
for (AttributeTypeInfo at : featureType.attributes()) {
if (at.getName().equals(request.getValueReference())) {
attribute = at;
break;
}
}
if (attribute == null) {
throw new WFSException(request, "No such attribute: " + request.getValueReference());
}
AttributeDescriptor descriptor = attribute.getAttribute();
if (descriptor == null) {
PropertyDescriptor pd = featureType.getFeatureType().getDescriptor(attribute.getName());
if (pd instanceof AttributeDescriptor) {
descriptor = (AttributeDescriptor) pd;
}
}
if (descriptor == null) {
throw new WFSException(request, "Unable to obtain descriptor for " + attribute.getName());
}
// create value collection type from feature collection
ValueCollectionType vc = Wfs20Factory.eINSTANCE.createValueCollectionType();
vc.setTimeStamp(fc.getTimeStamp());
vc.setNumberMatched(fc.getNumberMatched());
vc.setNumberReturned(fc.getNumberReturned());
vc.getMember().add(new PropertyValueCollection(fc.getMember().iterator().next(), descriptor));
// TODO: next/previous but point back at GetPropertyValue
// vc.setNext(fc.getNext());
// vc.setPrevious(fc.getPrevious());
return vc;
} catch (IOException e) {
throw new WFSException(request, e);
}
}
