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;
  }
Example #2
0
 private Filter createFilter(SimpleFeature feature, FeatureTypeRelation rel) {
   FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
   List<Filter> filters = new ArrayList<Filter>();
   for (FeatureTypeRelationKey key : rel.getRelationKeys()) {
     AttributeDescriptor rightSide = key.getRightSide();
     AttributeDescriptor leftSide = key.getLeftSide();
     Object value = feature.getAttribute(leftSide.getName());
     if (value == null) {
       continue;
     }
     if (AttributeDescriptor.GEOMETRY_TYPES.contains(rightSide.getType())
         && AttributeDescriptor.GEOMETRY_TYPES.contains(leftSide.getType())) {
       filters.add(ff.not(ff.isNull(ff.property(rightSide.getName()))));
       filters.add(ff.intersects(ff.property(rightSide.getName()), ff.literal(value)));
     } else {
       filters.add(ff.equals(ff.property(rightSide.getName()), ff.literal(value)));
     }
   }
   if (filters.size() > 1) {
     return ff.and(filters);
   } else if (filters.size() == 1) {
     return filters.get(0);
   } else {
     return null;
   }
 }
  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);
    }
  }
Example #4
0
 /**
  * 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;
 }
Example #5
0
 /** 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;
 }