public Resolution getMinMaxValue() throws JSONException {
JSONObject json = new JSONObject();
json.put("success", Boolean.FALSE);
try {
Layer layer =
applicationLayer
.getService()
.getSingleLayer(applicationLayer.getLayerName(), Stripersist.getEntityManager());
if (layer != null && layer.getFeatureType() != null) {
SimpleFeatureType sft = layer.getFeatureType();
Object value;
if (operator.equals("#MAX#")) {
value = sft.getMaxValue(attribute);
} else {
value = sft.getMinValue(attribute);
}
json.put("value", value.toString());
json.put("success", Boolean.TRUE);
}
} catch (Exception e) {
log.error("getMinMaxValue() failed", e);
json.put(
"msg",
"Minmax waardes bepalen mislukt voor attribuut " + attribute + ": " + e.toString());
}
return new StreamingResolution("application/json", new StringReader(json.toString()));
}
public Resolution getUniqueValues() throws JSONException {
JSONObject json = new JSONObject();
json.put("success", Boolean.FALSE);
try {
Layer layer = applicationLayer.getService().getSingleLayer(applicationLayer.getLayerName());
if (layer != null && layer.getFeatureType() != null) {
SimpleFeatureType sft = layer.getFeatureType();
List<String> beh = sft.calculateUniqueValues(attribute);
json.put("uniqueValues", new JSONArray(beh));
json.put("success", Boolean.TRUE);
}
} catch (Exception e) {
json.put("msg", e.toString());
}
return new StreamingResolution("application/json", new StringReader(json.toString()));
}
private void makeAttributeJSONArray(final SimpleFeatureType layerSft) throws JSONException {
List<ConfiguredAttribute> cas = applicationLayer.getAttributes();
// Sort the attributes, by featuretype and the featuretyp
Collections.sort(
cas,
new Comparator<ConfiguredAttribute>() {
@Override
public int compare(ConfiguredAttribute o1, ConfiguredAttribute o2) {
if (o1.getFeatureType() == null) {
return -1;
}
if (o2.getFeatureType() == null) {
return 1;
}
if (o1.getFeatureType().getId().equals(layerSft.getId())) {
return -1;
}
if (o2.getFeatureType().getId().equals(layerSft.getId())) {
return 1;
}
return o1.getFeatureType().getId().compareTo(o2.getFeatureType().getId());
}
});
for (ConfiguredAttribute ca : cas) {
JSONObject j = ca.toJSONObject();
// Copy alias over from feature type
SimpleFeatureType sft = ca.getFeatureType();
if (sft == null) {
sft = layerSft;
}
AttributeDescriptor ad = sft.getAttribute(ca.getAttributeName());
j.put("alias", ad.getAlias());
j.put("featureTypeAttribute", ad.toJSONObject());
attributesJSON.put(j);
}
}
private List<String> rebuildAttributes(SimpleFeatureType sft) {
Layer layer = applicationLayer.getService().getSingleLayer(applicationLayer.getLayerName());
List<String> attributesToRetain = new ArrayList<String>();
for (AttributeDescriptor ad : sft.getAttributes()) {
String name = ad.getName();
String fullName = sft.getId() + ":" + name;
// if attribute already added return.
if (attributesToRetain.contains(fullName)) {
return attributesToRetain;
}
attributesToRetain.add(fullName);
// Used for display in JSP
if (StringUtils.isNotBlank(ad.getAlias())) {
attributeAliases.put(fullName, ad.getAlias());
}
if (applicationLayer.getAttribute(sft, name) == null) {
ConfiguredAttribute ca = new ConfiguredAttribute();
// default visible if not geometry type
// and not a attribute of a related featuretype
boolean defaultVisible = true;
if (layer.getFeatureType().getId() != sft.getId()
|| AttributeDescriptor.GEOMETRY_TYPES.contains(ad.getType())) {
defaultVisible = false;
}
ca.setVisible(defaultVisible);
ca.setAttributeName(name);
ca.setFeatureType(sft);
applicationLayer.getAttributes().add(ca);
Stripersist.getEntityManager().persist(ca);
if (!"save".equals(getContext().getEventName())) {
String message = "Nieuw attribuut \"{0}\" gevonden in ";
if (layer.getFeatureType().getId() != sft.getId()) {
message += "gekoppelde ";
}
message += "attribuutbron";
if (layer.getFeatureType().getId() == sft.getId()) {
message += ": wordt zichtbaar na opslaan";
}
getContext().getMessages().add(new SimpleMessage(message, name));
}
}
}
if (sft.getRelations() != null) {
for (FeatureTypeRelation rel : sft.getRelations()) {
attributesToRetain.addAll(rebuildAttributes(rel.getForeignFeatureType()));
}
}
return attributesToRetain;
}
public static Filter reformatFilter(Filter filter, SimpleFeatureType ft) throws Exception {
FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
if (Filter.INCLUDE.equals(filter) || Filter.EXCLUDE.equals(filter)) {
return filter;
}
for (FeatureTypeRelation rel : ft.getRelations()) {
if (FeatureTypeRelation.JOIN.equals(rel.getType())) {
filter = reformatFilter(filter, rel.getForeignFeatureType());
filter = (Filter) filter.accept(new ValidFilterExtractor(rel), filter);
}
}
filter = (Filter) filter.accept(new SimplifyingFilterVisitor(), null);
return filter;
}
private JSONObject toJSONFeature(
JSONObject j,
SimpleFeature f,
SimpleFeatureType ft,
ApplicationLayer al,
List<String> propertyNames,
Map<String, String> attributeAliases,
int index)
throws JSONException, Exception {
if (arrays) {
for (String name : propertyNames) {
Object value = f.getAttribute(name);
j.put("c" + index++, formatValue(value));
}
} else {
for (String name : propertyNames) {
String alias = null;
if (attributeAliases != null) {
alias = attributeAliases.get(name);
}
j.put(alias != null ? alias : name, formatValue(f.getAttribute(name)));
}
}
// if edit and not yet set
// removed check for edit variable here because we need to compare features in edit component
// and feature info attributes
// was if(edit && j.optString(FID,null)==null) {
if (j.optString(FID, null) == null) {
String id = f.getID();
j.put(FID, id);
}
if (ft.hasRelations()) {
j = populateWithRelatedFeatures(j, f, ft, al, index);
}
return j;
}
@Before
public void synchronizeFeatureTypeAndLoadInfo() throws JSONException {
Layer layer = applicationLayer.getService().getSingleLayer(applicationLayer.getLayerName());
if (layer == null) {
getContext()
.getValidationErrors()
.addGlobalError(
new SimpleError(
"Laag niet gevonden bij originele service - verwijder deze laag uit niveau"));
return;
}
for (StyleLibrary sld : layer.getService().getStyleLibraries()) {
Map style = new HashMap();
JSONObject styleTitleJson = new JSONObject();
style.put("id", "sld:" + sld.getId());
style.put(
"title", "SLD stijl: " + sld.getTitle() + (sld.isDefaultStyle() ? " (standaard)" : ""));
// Find stuff for layerName
if (sld.getNamedLayerUserStylesJson() != null) {
JSONObject sldNamedLayerJson = new JSONObject(sld.getNamedLayerUserStylesJson());
if (sldNamedLayerJson.has(layer.getName())) {
JSONObject namedLayer = sldNamedLayerJson.getJSONObject(layer.getName());
if (namedLayer.has("title")) {
styleTitleJson.put("namedLayerTitle", namedLayer.get("title"));
}
JSONArray userStyles = namedLayer.getJSONArray("styles");
if (userStyles.length() > 0) {
JSONObject userStyle = userStyles.getJSONObject(0);
if (userStyle.has("title")) {
styleTitleJson.put("styleTitle", userStyle.get("title"));
}
}
}
}
styles.add(style);
stylesTitleJson.put((String) style.get("id"), styleTitleJson);
}
if (layer.getDetails().containsKey(Layer.DETAIL_WMS_STYLES)) {
JSONArray wmsStyles =
new JSONArray(layer.getDetails().get(Layer.DETAIL_WMS_STYLES).getValue());
for (int i = 0; i < wmsStyles.length(); i++) {
JSONObject wmsStyle = wmsStyles.getJSONObject(i);
Map style = new HashMap();
style.put("id", "wms:" + wmsStyle.getString("name"));
style.put(
"title",
"WMS server stijl: "
+ wmsStyle.getString("name")
+ " ("
+ wmsStyle.getString("title")
+ ")");
JSONObject styleTitleJson = new JSONObject();
styleTitleJson.put("styleTitle", wmsStyle.getString("title"));
styles.add(style);
stylesTitleJson.put((String) style.get("id"), styleTitleJson);
}
}
if (!styles.isEmpty()) {
List<Map> temp = new ArrayList();
Map s = new HashMap();
s.put("id", "registry_default");
s.put("title", "In gegevensregister als standaard ingestelde SLD");
temp.add(s);
s = new HashMap();
s.put("id", "none");
s.put("title", "Geen: standaard stijl van WMS service zelf");
temp.add(s);
temp.addAll(styles);
styles = temp;
}
// Synchronize configured attributes with layer feature type
if (layer.getFeatureType() == null || layer.getFeatureType().getAttributes().isEmpty()) {
applicationLayer.getAttributes().clear();
} else {
List<String> attributesToRetain = new ArrayList();
SimpleFeatureType sft = layer.getFeatureType();
editable = sft.isWriteable();
// Rebuild ApplicationLayer.attributes according to Layer FeatureType
// New attributes are added at the end of the list; the original
// order is only used when the Application.attributes list is empty
// So a feature for reordering attributes per applicationLayer is
// possible.
// New Attributes from a join or related featureType are added at the
// end of the list.
attributesToRetain = rebuildAttributes(sft);
// JSON info about attributed required for editing
makeAttributeJSONArray(layer.getFeatureType());
// Remove ConfiguredAttributes which are no longer present
List<ConfiguredAttribute> attributesToRemove = new ArrayList();
for (ConfiguredAttribute ca : applicationLayer.getAttributes()) {
if (ca.getFeatureType() == null) {
ca.setFeatureType(layer.getFeatureType());
}
if (!attributesToRetain.contains(ca.getFullName())) {
// Do not modify list we are iterating over
attributesToRemove.add(ca);
if (!"save".equals(getContext().getEventName())) {
getContext()
.getMessages()
.add(
new SimpleMessage(
"Attribuut \"{0}\" niet meer beschikbaar in attribuutbron: wordt verwijderd na opslaan",
ca.getAttributeName()));
}
}
}
for (ConfiguredAttribute ca : attributesToRemove) {
applicationLayer.getAttributes().remove(ca);
Stripersist.getEntityManager().remove(ca);
}
}
}
/**
* Get the features as JSONArray with the given params
*
* @param al The application layer(if there is a application layer)
* @param ft The featuretype that must be used to get the features
* @param fs The featureSource
* @param q The query
* @param sort The attribute name that is used to sort
* @param dir Sort direction (DESC or ASC)
* @return JSONArray with features.
* @throws IOException if any
* @throws JSONException if transforming to json fails
* @throws Exception if any
*/
public JSONArray getJSONFeatures(
ApplicationLayer al, SimpleFeatureType ft, FeatureSource fs, Query q, String sort, String dir)
throws IOException, JSONException, Exception {
Map<String, String> attributeAliases = new HashMap<String, String>();
if (!edit) {
for (AttributeDescriptor ad : ft.getAttributes()) {
if (ad.getAlias() != null) {
attributeAliases.put(ad.getName(), ad.getAlias());
}
}
}
List<String> propertyNames;
if (al != null) {
propertyNames = this.setPropertyNames(al, q, ft, edit);
} else {
propertyNames = new ArrayList<String>();
for (AttributeDescriptor ad : ft.getAttributes()) {
propertyNames.add(ad.getName());
}
}
if (sort != null) {
setSortBy(q, propertyNames, sort, dir);
}
/* Use the first property as sort field, otherwise geotools while give a error when quering
* a JDBC featureType without a primary key.
*/
else if (fs instanceof org.geotools.jdbc.JDBCFeatureSource && !propertyNames.isEmpty()) {
setSortBy(q, propertyNames.get(0), dir);
}
Integer start = q.getStartIndex();
if (start == null) {
start = 0;
}
boolean offsetSupported = fs.getQueryCapabilities().isOffsetSupported();
// if offSet is not supported, get more features (start + the wanted features)
if (!offsetSupported && q.getMaxFeatures() < MAX_FEATURES) {
q.setMaxFeatures(q.getMaxFeatures() + start);
}
FeatureIterator<SimpleFeature> it = null;
JSONArray features = new JSONArray();
try {
it = fs.getFeatures(q).features();
int featureIndex = 0;
while (it.hasNext()) {
SimpleFeature feature = it.next();
/* if offset not supported and there are more features returned then
* only get the features after index >= start*/
if (offsetSupported || featureIndex >= start) {
JSONObject j =
this.toJSONFeature(
new JSONObject(), feature, ft, al, propertyNames, attributeAliases, 0);
features.put(j);
}
featureIndex++;
}
} finally {
if (it != null) {
it.close();
}
fs.getDataStore().dispose();
}
return features;
}
/** Get the propertynames and add the needed propertynames to the query. */
private List<String> setPropertyNames(
ApplicationLayer appLayer, Query q, SimpleFeatureType sft, boolean edit) {
List<String> propertyNames = new ArrayList<String>();
boolean haveInvisibleProperties = false;
if (propertyNamesQueryCache.containsKey(sft.getId())) {
haveInvisibleProperties = haveInvisiblePropertiesCache.get(sft.getId());
if (haveInvisibleProperties) {
q.setPropertyNames(propertyNamesQueryCache.get(sft.getId()));
}
return propertyNamesReturnCache.get(sft.getId());
} else {
for (ConfiguredAttribute ca : appLayer.getAttributes(sft)) {
if ((!edit && !graph && ca.isVisible())
|| (edit && ca.isEditable())
|| (graph && attributesToInclude.contains(ca.getId()))) {
propertyNames.add(ca.getAttributeName());
} else {
haveInvisibleProperties = true;
}
}
haveInvisiblePropertiesCache.put(sft.getId(), haveInvisibleProperties);
propertyNamesReturnCache.put(sft.getId(), propertyNames);
propertyNamesQueryCache.put(sft.getId(), propertyNames);
if (haveInvisibleProperties) {
// By default Query retrieves Query.ALL_NAMES
// Query.NO_NAMES is an empty String array
q.setPropertyNames(propertyNames);
// If any related featuretypes are set, add the leftside names in the query
// don't add them to propertynames, maybe they are not visible
if (sft.getRelations() != null) {
List<String> withRelations = new ArrayList<String>();
withRelations.addAll(propertyNames);
for (FeatureTypeRelation ftr : sft.getRelations()) {
if (ftr.getRelationKeys() != null) {
for (FeatureTypeRelationKey key : ftr.getRelationKeys()) {
if (!withRelations.contains(key.getLeftSide().getName())) {
withRelations.add(key.getLeftSide().getName());
}
}
}
}
propertyNamesQueryCache.put(sft.getId(), withRelations);
q.setPropertyNames(withRelations);
}
}
propertyNamesReturnCache.put(sft.getId(), propertyNames);
return propertyNames;
}
}
/** Populate the json object with related featues */
private JSONObject populateWithRelatedFeatures(
JSONObject j, SimpleFeature feature, SimpleFeatureType ft, ApplicationLayer al, int index)
throws Exception {
if (ft.hasRelations()) {
JSONArray related_featuretypes = new JSONArray();
for (FeatureTypeRelation rel : ft.getRelations()) {
boolean isJoin = rel.getType().equals(FeatureTypeRelation.JOIN);
if (isJoin) {
FeatureSource foreignFs = rel.getForeignFeatureType().openGeoToolsFeatureSource(TIMEOUT);
FeatureIterator<SimpleFeature> foreignIt = null;
try {
Query foreignQ = new Query(foreignFs.getName().toString());
// create filter
Filter filter = createFilter(feature, rel);
if (filter == null) {
continue;
}
// if join only get 1 feature
foreignQ.setMaxFeatures(1);
foreignQ.setFilter(filter);
// set propertynames
List<String> propertyNames;
if (al != null) {
propertyNames = setPropertyNames(al, foreignQ, rel.getForeignFeatureType(), edit);
} else {
propertyNames = new ArrayList<String>();
for (AttributeDescriptor ad : rel.getForeignFeatureType().getAttributes()) {
propertyNames.add(ad.getName());
}
}
if (propertyNames.isEmpty()) {
// if there are no properties to retrieve just get out
continue;
}
// get aliases
Map<String, String> attributeAliases = new HashMap<String, String>();
if (!edit) {
for (AttributeDescriptor ad : rel.getForeignFeatureType().getAttributes()) {
if (ad.getAlias() != null) {
attributeAliases.put(ad.getName(), ad.getAlias());
}
}
}
// Get Feature and populate JSON object with the values.
foreignIt = foreignFs.getFeatures(foreignQ).features();
while (foreignIt.hasNext()) {
SimpleFeature foreignFeature = foreignIt.next();
// join it in the same json
j =
toJSONFeature(
j,
foreignFeature,
rel.getForeignFeatureType(),
al,
propertyNames,
attributeAliases,
index);
}
} finally {
if (foreignIt != null) {
foreignIt.close();
}
foreignFs.getDataStore().dispose();
}
} else {
Filter filter = createFilter(feature, rel);
if (filter == null) {
continue;
}
JSONObject related_ft = new JSONObject();
related_ft.put("filter", CQL.toCQL(filter));
related_ft.put("id", rel.getForeignFeatureType().getId());
related_ft.put("foreignFeatureTypeName", rel.getForeignFeatureType().getTypeName());
related_featuretypes.put(related_ft);
}
}
if (related_featuretypes.length() > 0) {
j.put("related_featuretypes", related_featuretypes);
}
}
return j;
}
