gb_mapfish_appserver 1.1.1 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c0bd8f62eddc656b9b0e8d45fa7b24bc2e60ed8
+  data.tar.gz: e3a565123819e15f9b4392cacdfab3962042911c
+SHA512:
+  metadata.gz: c5d4d4cb3e680b9eaf524938a5d464d7047ca588b902f2900aac056b9a306692982f74b0867591d056b0cae6b7c1871cf0a1768af44a5012475d8c61441a13cd
+  data.tar.gz: 1e5e2b251baf0d7658a1f67b1ae475214ece3edd9aabce9a17b37b6cd3f65d71f8cc2f19623239b8909a8f39c9a3532b27b124f9b9fa9b7701c41dff6e39d834

data/README.md

@@ -17,6 +17,7 @@ Mapfish Appserver comes with the following out-of-the box features:
 -   Fully customizable legends and feature infos
 -   Creation of complex custom searches
 -   Rich digitizing and editing functionality
+-   Support for differing client and server spatial reference systems
 -   Role-based access control on topic, layer and attribute level
 -   Access control for WMS and WFS
 -   Rich library of ExtJS 4 based map components
@@ -31,7 +32,9 @@ Documentation
 
 For more documentation see the [mapfish-appserver.github.io](http://mapfish-appserver.github.io/)
 
-Note: Mapfish Appserver v1.1.0 or later no longer uses the gb_mapfish_print gem, but uses a
+Note: Mapfish Appserver v2.0.0 requires Ruby 2.3 or greater
+
+Note: Mapfish Appserver v1.1.0 or greater no longer uses the gb_mapfish_print gem, but uses a
 separately installed Mapfish Print v3 for printing (see documentation)
 
 Authors and License
@@ -42,4 +45,4 @@ Stefan Zinggeler and Adrian Herzog, Canton of Zurich.
 
 New BSD License
 
-*Copyright (c) 2009-2015 Sourcepole AG & Canton of Zurich*
+*Copyright (c) 2009-2017 Sourcepole AG & Canton of Zurich*

data/app/controllers/application_controller.rb

@@ -43,7 +43,7 @@ class ApplicationController < ActionController::Base
   end
 
   def current_roles
-    @current_roles ||= Ability::Roles.new(current_user, host_zone(request.host))
+    @current_roles_ ||= Ability::Roles.new(current_user, host_zone(request.host))
   end
 
   # Overide CanCan method

data/app/controllers/apps_controller.rb

@@ -17,6 +17,8 @@ class AppsController < ApplicationController
     @x = params['x'].nil? ? DEFAULT_X : params['x'].to_f
     @y = params['y'].nil? ? DEFAULT_Y : params['y'].to_f
 
+    @client_srid = params[:srid].blank? ? GeoModel.default_client_srid : params[:srid].to_i
+
     @zoom = params['zoom'].nil? ? DEFAULT_ZOOM : params['zoom'].to_i # for mobile
     @gbapp = params['gbapp'].nil? ? 'default' : params['gbapp'] # for mobile
 
@@ -40,7 +42,7 @@ class AppsController < ApplicationController
       if rule.nil?
         logger.info "Locate rule not found: {params['locate']}"
       else
-        location = rule.locate(params['locations'])
+        location = rule.locate(params['locations'], @client_srid)
         unless location.nil?
           @seltopic = location[:selection][:topic] || @topic_name
           @sellayer = location[:selection][:layer]

data/app/controllers/geo_controller.rb

@@ -7,12 +7,14 @@ class GeoController < ApplicationController
   end
 
   def index
+    client_srid = params[:srid].blank? ? geo_model.default_client_srid : params[:srid].to_i
+
     @features = geo_model.bbox_filter(params)
     @features = @features.user_filter(current_ability)
     respond_to do |format|
       # NOTE: return GeoJSON by default (OpenLayers.Protocol.HTTP PUT does not work with '.json' format selection)
       format.html {
-        render :json => @features.json_filter.to_geojson
+        render :json => @features.json_filter.select_geojson_geom(client_srid).to_geojson
       }
       format.csv {
         send_csv_excel(@features.csv_filter)
@@ -21,11 +23,161 @@ class GeoController < ApplicationController
   end
 
   def show
-    @feature = geo_model.user_filter(current_ability).json_filter.find(params[:id])
+    client_srid = params[:srid].blank? ? geo_model.default_client_srid : params[:srid].to_i
+
+    @feature = geo_model.user_filter(current_ability).json_filter.select_geojson_geom(client_srid).find(params[:id])
     render :json => [@feature].to_geojson
   end
 
   def create
+    if params[:editv2]
+      create_v2
+    else
+      create_v1
+    end
+  end
+
+  def update
+    if params[:editv2]
+      update_v2
+    else
+      update_v1
+    end
+  end
+
+  def destroy
+    if params[:editv2]
+      destroy_v2
+    else
+      destroy_v1
+    end
+  end
+
+  def create_v2
+    unless geo_model.can_edit?(current_ability)
+      render :json => {
+        :error => "Forbidden"
+      }, :status => :forbidden
+      return
+    end
+
+    geojson_data = request.raw_post
+    begin
+      feature_collection = geo_model.geojson_decode(geojson_data)
+    rescue => err
+      # JSON parse error
+      render :json => {
+        :error => "Invalid JSON: #{err.message}"
+      }, :status => :bad_request
+      return
+    end
+    error = geo_model.validate_feature_collection(feature_collection, geojson_data)
+    unless error.nil?
+      render :json => error, :status => :bad_request
+      return
+    end
+
+    @features = []
+    feature_collection.each do |feature|
+      if feature.feature_id.is_a? Integer
+        begin
+          new_feature = geo_model.find(feature.feature_id)
+        rescue ActiveRecord::RecordNotFound => err
+          render :json => {
+            :error => "Feature ID not found"
+          }, :status => :not_found
+          return
+        end
+      end
+      if new_feature.nil?
+        new_feature = geo_model.new
+      end
+
+      logger.info "#{geo_model.table_name}.update_attributes_from_feature: #{feature.inspect}"
+      if new_feature.update_attributes_from_geojson_feature(feature, current_user)
+        # transform geometry to SRID from GeoJSON feature
+        client_srid = feature.geometry.nil? ? geo_model.default_client_srid : feature.geometry.srid
+        new_feature = geo_model.json_filter.select_geojson_geom(client_srid).find(new_feature.id)
+
+        @features << new_feature
+      else
+        render :json => {
+          :error => "Feature validation failed",
+          :validation_errors => new_feature.errors.full_messages
+        }, :status => :unprocessable_entity
+        return
+      end
+    end
+
+    render :json => @features.to_geojson, :status => :created
+  end
+
+  def update_v2
+    unless geo_model.can_edit?(current_ability)
+      render :json => {
+        :error => "Forbidden"
+      }, :status => :forbidden
+      return
+    end
+
+    geojson_data = request.raw_post
+    begin
+      feature = geo_model.geojson_decode(geojson_data)
+    rescue => err
+      # JSON parse error
+      render :json => {
+        :error => "Invalid JSON: #{err.message}"
+      }, :status => :bad_request
+      return
+    end
+    error = geo_model.validate_feature(feature, geojson_data)
+    unless error.nil?
+      render :json => error, :status => :bad_request
+      return
+    end
+
+    if feature.feature_id.is_a? Integer
+      begin
+        # NOTE: user_filter may limit editable features; find raises RecordNotFound if feature cannot be found
+        @feature = geo_model.user_filter(current_ability).find(feature.feature_id)
+      rescue ActiveRecord::RecordNotFound => err
+        render :json => {
+          :error => "Feature ID not found"
+        }, :status => :not_found
+        return
+      end
+    end
+
+    if @feature.update_attributes_from_geojson_feature(feature, current_user)
+      # transform geometry to SRID from GeoJSON feature
+      client_srid = feature.geometry.nil? ? geo_model.default_client_srid : feature.geometry.srid
+      @feature = geo_model.json_filter.select_geojson_geom(client_srid).find(@feature.id)
+
+      render :json => @feature.to_geojson, :status => :created
+    else
+      render :json => {
+        :error => "Feature validation failed",
+        :validation_errors => @feature.errors.full_messages
+      }, :status => :unprocessable_entity
+    end
+  end
+
+  def destroy_v2
+    begin
+      @feature = geo_model.user_filter(current_ability).find(params[:id])
+    rescue ActiveRecord::RecordNotFound => err
+      render :json => {
+        :error => "Feature ID not found"
+      }, :status => :not_found
+      return
+    end
+    @feature.destroy
+    render :json => {
+      :message => "Feature removed"
+    }
+  end
+
+  def create_v1
     @features = []
     feature_collection = geo_model.geojson_decode(request.raw_post)
     if feature_collection.nil? || !geo_model.can_edit?(current_ability)
@@ -43,6 +195,10 @@ class GeoController < ApplicationController
 
       logger.info "#{geo_model.table_name}.update_attributes_from_feature: #{feature.inspect}"
       if new_feature.update_attributes_from_geojson_feature(feature, current_user)
+        # transform geometry to SRID from GeoJSON feature
+        client_srid = feature.geometry.nil? ? geo_model.default_client_srid : feature.geometry.srid
+        new_feature = geo_model.json_filter.select_geojson_geom(client_srid).find(new_feature.id)
+
         @features << new_feature
       else
         head :unprocessable_entity
@@ -53,7 +209,7 @@ class GeoController < ApplicationController
     render :json => @features.to_geojson, :status => :created
   end
 
-  def update
+  def update_v1
     # NOTE: user_filter checks if model is editable
     feature = geo_model.user_filter(current_ability).geojson_decode(request.raw_post)
     if feature.nil?
@@ -67,13 +223,17 @@ class GeoController < ApplicationController
     end
 
     if @feature.update_attributes_from_geojson_feature(feature, current_user)
+      # transform geometry to SRID from GeoJSON feature
+      client_srid = feature.geometry.nil? ? geo_model.default_client_srid : feature.geometry.srid
+      @feature = geo_model.json_filter.select_geojson_geom(client_srid).find(@feature.id)
+
       render :json => @feature.to_geojson, :status => :created
     else
       head :unprocessable_entity
     end
   end
 
-  def destroy
+  def destroy_v1
     @feature = geo_model.user_filter(current_ability).find(params[:id])
     @feature.destroy
     head :no_content

data/app/controllers/print_controller.rb

@@ -2,9 +2,9 @@
 
 class PrintController < ApplicationController
   begin
-    require 'RMagick'
+    require 'rmagick'
   rescue LoadError
-    ActionController::Base.logger.info "Couldn't find RMagick. Image export not supported"
+    ActionController::Base.logger.info "Couldn't find rmagick. Image export not supported"
   end
 
   skip_before_filter :verify_authenticity_token, :only => :create # allow /print/create with POST
@@ -392,6 +392,7 @@ class PrintController < ApplicationController
       # convert PDF to image if not supported by Mapfish Print
       pdf = Magick::Image.read(temp_mapfish) { self.density = print_params['dpi'] }.first
       temp_img = "#{TMP_PREFIX}#{temp_id.to_s}.#{output_format}"
+      pdf.alpha(Magick::RemoveAlphaChannel)
       pdf.write(temp_img)
       File.delete(temp_mapfish)
       temp = temp_img
@@ -409,9 +410,13 @@ class PrintController < ApplicationController
       when 'GET'
         # add params to URL
         url = URI.parse("#{url}?#{print_params.to_param}") unless print_params.nil?
-        response = Net::HTTP.get_response(url)
+        http = Net::HTTP.new(url.host, url.port)
+        http.read_timeout = 300
+        req = Net::HTTP::Get.new(uri.request_uri)
+        response = http.request(req)
       when 'POST'
         http = Net::HTTP.new(url.host, url.port)
+        http.read_timeout = 300
         req = Net::HTTP::Post.new(url.path)
         req.set_form_data(print_params)
         response = http.request(req)
@@ -573,6 +578,7 @@ class PrintController < ApplicationController
         end
         call_params[:MAP_BBOX] = page["extent"].join(',')
         call_params[:MAP_CENTER] = page["center"].join(',')
+        call_params[:MAP_SRS] = request.parameters["srs"]
       end
       request.parameters.each do |name, val|
         if name =~ /^REP_/

data/app/controllers/search_controller.rb

@@ -1,14 +1,18 @@
 class SearchController < ApplicationController
 
   def index
-    @rule =  SEARCHRULES[params[:rule]]
+    @rule = SEARCHRULES[params[:rule]]
     if @rule.nil? then
       respond_to do |format|
         format.html # index.html.erb
         format.json { render :json => {:success => false,  :quality => -9999, :msg => "ERROR: #{params[:rule]} model missing"} }
       end
     else
-      result = @rule.model.query(@rule.fields, params)
+      # transform geometry fields to client SRID
+      client_srid = params[:srid].blank? ? GeoModel.default_client_srid : params[:srid].to_i
+      fields = transformed_geom_fields(@rule.fields, @rule.model.srid, client_srid)
+
+      result = @rule.model.query(fields, params)
       @features = result[:features]
       @quality = result[:quality]
       @success = @quality >= 0 
@@ -30,7 +34,8 @@ class SearchController < ApplicationController
     if rule.nil?
       render :json => {:success => false, :msg => "ERROR: #{params[:rule]} model missing"}
     else
-      location = rule.locate(params['locations'])
+      client_srid = params[:srid].blank? ? GeoModel.default_client_srid : params[:srid].to_i
+      location = rule.locate(params['locations'], client_srid)
       unless location.nil?
         location[:success] = true
         render :json => location
@@ -76,6 +81,13 @@ class SearchController < ApplicationController
 
   private
 
+  # replace "*geom*" in fields with SQL for transformed geometry
+  def transformed_geom_fields(fields, geom_srid, target_srid)
+    fields.collect do |field|
+      field.gsub(/\*(\w+)\*/) { |m| GeoModel.transform_geom_sql($1, geom_srid, target_srid) }
+    end
+  end
+
   def features_for_json_reader(features)
     # convert feature list for display in grid panel:
     #

data/app/controllers/topics_controller.rb

@@ -31,6 +31,9 @@ class TopicsController < ApplicationController
   end
 
   def query
+    client_srid = params[:srid].blank? ? GeoModel.default_client_srid : params[:srid].to_i
+    @client_srid = client_srid
+
     # optional parameter to return only the feature nearest to the center of the search geometry, if no custom layer query is used
     # use layer setting by default
     nearest = params['nearest'].nil? ? nil : params['nearest'] == 'true'
@@ -42,15 +45,15 @@ class TopicsController < ApplicationController
       authorize! :show, topic
       query_topic['topicobj'] = topic
       if params['bbox']
-        query_topic['results'] = topic.query(current_ability, query_topic, params['bbox'], nearest, current_user)
+        query_topic['results'] = topic.query(current_ability, query_topic, params['bbox'], nearest, current_user, client_srid)
       elsif params['rect']
         x1, y1, x2, y2 = params['rect'].split(',').collect(&:to_f)
         rect = "POLYGON((#{x1} #{y1}, #{x1} #{y2}, #{x2} #{y2}, #{x2} #{y1} ,#{x1} #{y1}))"
-        query_topic['results'] = topic.query(current_ability, query_topic, rect, nearest, current_user)
+        query_topic['results'] = topic.query(current_ability, query_topic, rect, nearest, current_user, client_srid)
       elsif params['circle']
-        query_topic['results'] = topic.query(current_ability, query_topic, params['circle'], nearest, current_user)
+        query_topic['results'] = topic.query(current_ability, query_topic, params['circle'], nearest, current_user, client_srid)
       elsif params['poly']
-        query_topic['results'] = topic.query(current_ability, query_topic, params['poly'], nearest, current_user)
+        query_topic['results'] = topic.query(current_ability, query_topic, params['poly'], nearest, current_user, client_srid)
       else
         # problem
       end

data/app/controllers/wms_controller.rb

@@ -12,10 +12,10 @@ class WmsController < ApplicationController
     add_filter(topic_name)
 
     #Send redirect for public services
-    if request.get? && public?(topic_name, host_zone(request.host))
+    if MAPSERV_REDIRECT && request.get? && public?(topic_name, host_zone(request.host))
       url, path = mapserv_request_url(request)
       #expires_in 2.minutes, :public => true #FIXME: cache_path "wms-public-#{topic_name}-#{host_zone(request.host)}"
-      redirect_to "#{url.scheme}://#{url.host}#{path}"
+      redirect_to "#{url.scheme}://#{url.host}:#{url.port}#{path}"
       return
     end
 
@@ -89,14 +89,15 @@ class WmsController < ApplicationController
 
   def call_wms(request)
     url, path = mapserv_request_url(request)
-    logger.info "Forward request: #{url.scheme}://#{url.host}#{path}"
+    uri = URI.parse("#{url.scheme}://#{url.host}:#{url.port}#{path}")
+    logger.info "Forward request: #{uri}"
 
     if request.get?
-      result = Net::HTTP.get_response(url.host, path, url.port)
+      result = Net::HTTP.get_response(uri)
       send_data result.body, :status => result.code, :type => result.content_type, :disposition => 'inline'
     else
       #POST
-      http = Net::HTTP.new(url.host, url.port)
+      http = Net::HTTP.new(uri.host, uri.port)
       req = Net::HTTP::Post.new(path)
       post_params = []
       post_params += url.query.split(/&|=/) if url.query

data/app/models/geo_model.rb

@@ -1,3 +1,6 @@
+require 'georuby'
+require 'geo_ruby/ewk'
+
 class GeoModel < ActiveRecord::Base
   establish_connection(GEODB)
 
@@ -30,67 +33,114 @@ class GeoModel < ActiveRecord::Base
     col
   end
 
-  def self.extent_field
-    "ST_Envelope(#{table_name}.#{geometry_column_name}) AS extent"
+  # generate SQL fragment for transforming input geometry geom_sql from geom_srid to target_srid
+  def self.transform_geom_sql(geom_sql, geom_srid, target_srid)
+    if geom_srid.nil? || target_srid.nil? || geom_srid == target_srid
+      # no transformation
+    else
+      # transform to target SRID
+      if target_srid == 2056 && geom_srid == 21781
+        geom_sql = "ST_GeomFromEWKB(ST_Fineltra(#{geom_sql}, 'chenyx06_triangles', 'geom_lv03', 'geom_lv95'))"
+      elsif target_srid == 21781 && geom_srid == 2056
+        geom_sql = "ST_GeomFromEWKB(ST_Fineltra(#{geom_sql}, 'chenyx06_triangles', 'geom_lv95', 'geom_lv03'))"
+      else
+        geom_sql = "ST_Transform(#{geom_sql}, #{target_srid})"
+      end
+    end
+
+    geom_sql
   end
 
-  def self.area_field
-    "ST_Area(#{table_name}.#{geometry_column.name}) AS area"
+  def self.geometry_field
+    "#{table_name}.#{connection.quote_column_name(geometry_column_name)}"
   end
 
-  def self.identify_filter(searchgeo, radius, nearest=false)
+  def self.extent_field(client_srid=nil)
+    # transform geometry to client_srid first
+    "ST_Envelope(#{transform_geom_sql(geometry_field, srid, client_srid)}) AS extent"
+  end
+
+  # NOTE: area in client_srid units
+  def self.area_field(client_srid=nil)
+    # transform geometry to client_srid first
+    "ST_Area(#{transform_geom_sql(geometry_field, srid, client_srid)}) AS area"
+  end
+
+  # NOTE: radius in srid units
+  def self.identify_filter(searchgeo, radius, nearest=false, client_srid=nil)
     filter = scoped
+
+    client_srid ||= default_client_srid
+
     if searchgeo[0..3] == "POLY"
       logger.debug "*** POLY-query: #{searchgeo} ***"
-      polygon = "ST_GeomFromText('#{searchgeo}', #{srid})"
-      filter = filter.where("ST_DWithin(#{table_name}.#{geometry_column_name}, #{polygon}, #{radius})")
-      center = "ST_Centroid(#{polygon})"
+      search_geom = "ST_GeomFromText('#{searchgeo}', #{client_srid})"
+      center = "ST_Centroid(#{search_geom})"
     else
       if searchgeo.split(',').length == 3
         logger.debug "*** CIRCLE-query: #{searchgeo} ***"
         x1, y1, r  = searchgeo.split(',').collect(&:to_f)
-        center = "ST_GeomFromText('POINT(#{x1} #{y1})', #{srid})"
-        filter = filter.where("ST_DWithin(#{table_name}.#{geometry_column_name}, #{center}, #{r})")
+        center = "ST_GeomFromText('POINT(#{x1} #{y1})', #{client_srid})"
+        # NOTE: circle as buffer with radius in client_srid units
+        search_geom = "ST_Buffer(#{center}, #{r}, 32)"
+        radius = 0
       else
         logger.debug "*** BBOX-query: #{searchgeo} ***"
         x1, y1, x2, y2 = searchgeo.split(',').collect(&:to_f)
-        center = "ST_GeomFromText('POINT(#{x1+(x2-x1)/2} #{y1+(y2-y1)/2})', #{srid})"
-        filter = filter.where("ST_DWithin(#{table_name}.#{geometry_column_name}, #{center}, #{radius})")
+        search_geom = "ST_GeomFromText('POINT(#{x1+(x2-x1)/2} #{y1+(y2-y1)/2})', #{client_srid})"
+        center = search_geom
       end
     end
 
+    # transform search geometry to srid
+    search_geom = transform_geom_sql(search_geom, client_srid, srid)
+
+    # get features within radius in srid units
+    filter = filter.where("ST_DWithin(#{geometry_field}, #{search_geom}, #{radius})")
+
     if nearest
       logger.debug "*** query nearest ***"
-      min_dist = filter.select("Min(ST_Distance(#{table_name}.#{geometry_column_name}, #{center})) AS min_dist").first
+      # transform center to srid
+      center = transform_geom_sql(center, client_srid, srid)
+      # get min dist
+      min_dist = filter.select("Min(ST_Distance(#{geometry_field}, #{center})) AS min_dist").first
       unless min_dist.nil?
         logger.debug "*** min_dist = #{min_dist.min_dist} ***"
         if min_dist.min_dist.to_f == 0
           # center of the search geometry is within a feature (may be overlapping features)
-          filter = filter.where("ST_Within(#{center}, #{table_name}.#{geometry_column_name})")
+          filter = filter.where("ST_Within(#{center}, #{geometry_field})")
         else
           # get the feature nearest to the center of the search geometry
-          filter = filter.order("ST_Distance(#{table_name}.#{geometry_column_name}, #{center})").limit(1)
+          filter = filter.order("ST_Distance(#{geometry_field}, #{center})").limit(1)
         end
       end
       # else no features in filter
+    else
+      # order by distance to center
+      center = transform_geom_sql(center, client_srid, srid)
+      filter = filter.order("ST_Distance(#{geometry_field}, #{center})")
     end
 
     filter
   end
 
   #Custom identify query
-  #def self.identify_query(bbox, radius)
-  #  scoped.select().where()....
+  #def self.identify_query(layer, query_topic, searchgeom, ability, user, client_srid=nil)
+  #  # default layer query
+  #  query_fields = (["#{self.table_name}.#{self.primary_key}"] + layer.ident_fields_for(ability).split(',') + [self.extent_field(client_srid), self.area_field(client_srid)]).join(',')
+  #  features = scoped.identify_filter(searchgeom, layer.searchdistance, nil, client_srid).where(layer.where_filter).select(query_fields)
+  #  features.all
   #end
 
-  def bbox
+  def bbox(client_srid=nil)
     if respond_to?('extent')
       # use extent from select(extent_field)
-      envelope = GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb(extent).envelope #TODO: replace with rgeo
+      envelope = GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb(extent).envelope
       [envelope.lower_corner.x, envelope.lower_corner.y, envelope.upper_corner.x, envelope.upper_corner.y]
     else
       # get Box2D for this feature
-      box_query = "Box2D(#{connection.quote_column_name(self.class.geometry_column_name)})"
+      # transform geometry to client_srid first
+      box_query = "Box2D(#{self.class.transform_geom_sql(self.class.geometry_field, self.class.srid, client_srid)})"
       extent = self.class.select("ST_XMin(#{box_query}), ST_YMin(#{box_query}), ST_XMax(#{box_query}), ST_Ymax(#{box_query})").find(id)
       [
         extent.st_xmin.to_f,
@@ -114,37 +164,106 @@ class GeoModel < ActiveRecord::Base
     end
 
     if filter_geom
-      filter = filter.where("ST_Intersects(#{table_name}.#{connection.quote_column_name(geometry_column_name)}, ST_SetSRID(#{filter_geom}, #{srid}))")
+      # transform filter geom to srid
+      client_srid = params['srid'].blank? ? default_client_srid : params['srid'].to_i
+      filter_geom = transform_geom_sql("ST_SetSRID(#{filter_geom}, #{client_srid})", client_srid, srid)
+      filter = filter.where("ST_Intersects(#{geometry_field}, #{filter_geom})")
     end
 
     filter.limit(1000)
   end
 
   def self.geojson_decode(json)
-    RGeo::GeoJSON.decode(json, :json_parser => :json, :geo_factory => geo_factory)
+    geojson = JSON.parse(json)
+
+    # get client_srid from GeoJSON CRS
+    if geojson['crs'].blank?
+      client_srid = default_client_srid
+    else
+      client_srid = geojson['crs']['properties']['name'].split(':').last rescue default_client_srid
+      # use EPSG:4326 for 'urn:ogc:def:crs:OGC:1.3:CRS84'
+      client_srid = 4326 if client_srid == 'CRS84'
+    end
+
+    # NOTE: use dummy factory to set client_srid for update_attributes_from_geojson_feature()
+    RGeo::GeoJSON.decode(geojson, :geo_factory => RGeo::Cartesian.factory(:srid => client_srid))
   end
 
-  def to_geojson(options = {})
+  # select transformed geometry as GeoJSON
+  def self.select_geojson_geom(client_srid=nil)
+    # transform geometry to client_srid
+    geom_sql = transform_geom_sql("#{geometry_field}", srid, client_srid)
+    # select geometry as GeoJSON
+    scoped.select("ST_AsGeoJSON(#{geom_sql}) AS geojson_geom, 'EPSG:' || #{client_srid || srid} AS geojson_srid")
+  end
+
+  # customize GeoJSON contents, e.g. to add custom properties or fields 
+  # override in descendant classes
+  def customize_geojson(geojson, options={})
+    geojson
+  end
+
+  def to_geojson(options={})
     only = options.delete(:only)
-    geoson = { :type => 'Feature' }
-    geoson[:properties] = attributes.delete_if do |name, value|
-      # TODO: support for multiple geometry columns
+    geojson = { :type => 'Feature' }
+    geojson[:properties] = attributes.delete_if do |name, value|
       if name == self.class.geometry_column_name
-        geoson[:geometry] = value
+        geojson[:geometry] = value
+        true
+      elsif name == 'geojson_geom' || name == 'geojson_srid'
+        # skip helper fields
         true
       elsif name == self.class.primary_key then
-        geoson[:id] = value
+        geojson[:id] = value
         true
       elsif only
         !only.include?(name.to_sym)
       end
     end
-    geoson.to_json
+
+    geojson = customize_geojson(geojson, options)
+
+    if attributes.has_key?('geojson_geom')
+      # dummy geometry (ignore value from geometry column)
+      geojson[:geometry] = {}
+
+      unless options[:skip_feature_crs]
+        # add GeoJSON CRS unless part of a FeatureCollection
+        geojson[:crs] = {
+          :type => 'name',
+          :properties => {
+            :name => attributes['geojson_srid']
+          }
+        }
+      end
+
+      # convert to JSON and replace geometry with GeoJSON field from query
+      geojson.to_json.sub(/"geometry":{}/, "\"geometry\":#{attributes['geojson_geom']}")
+    else
+      geojson.to_json
+    end
   end
 
   def update_attributes_from_geojson_feature(feature, user)
     attr = feature.properties
-    attr[self.class.geometry_column_name] = feature.geometry unless feature.geometry.nil?
+
+    unless feature.geometry.nil?
+      # get client_srid from RGeo geometry
+      client_srid = feature.geometry.srid
+      if client_srid != self.class.srid
+        # transform feature geometry to srid
+        geom_sql = self.class.transform_geom_sql("ST_GeomFromText('#{feature.geometry.as_text}', #{client_srid})", client_srid, self.class.srid)
+        sql = "SELECT ST_AsText(#{geom_sql}) AS wkt_geom"
+        results = connection.execute(sql)
+        results.each do |result|
+          attr[self.class.geometry_column_name] = self.class.geo_factory.parse_wkt(result['wkt_geom'])
+        end
+      else
+        # no transformation
+        attr[self.class.geometry_column_name] = feature.geometry
+      end
+    end
+
     ok = update_attributes(attr)
     modified_by(user)
     ok
@@ -202,11 +321,180 @@ class GeoModel < ActiveRecord::Base
     []
   end
 
+  # GeoJSON validations
+
+  def self.validate_feature_collection(feature_collection, geojson_data)
+    if feature_collection.nil?
+      # not a GeoJSON
+      return {
+        :error => "Invalid GeoJSON"
+      }
+    elsif !feature_collection.is_a? RGeo::GeoJSON::FeatureCollection
+      # not a GeoJSON FeatureCollection
+      return {
+        :error => "GeoJSON is not a FeatureCollection"
+      }
+    elsif !feature_collection.any? || feature_collection.select {|feature| feature.geometry.is_empty?}.any?
+      # no features or invalid geometries
+      # NOTE: RGeo::GeoJSON.decode or feature geometry is empty if geometry is invalid
+      errors = []
+      begin
+        geojson = JSON.parse(geojson_data)
+        if geojson['features'].blank?
+          return {
+            :error => "No GeoJSON features found"
+          }
+        end
+
+        geojson['features'].each do |feature|
+          feature_errors = validate_geometry(feature)
+          errors += feature_errors if feature_errors.any?
+        end
+      rescue => err
+        logger.error "Error while checking GeoJSON geometries:\n#{err.message}"
+      end
+
+      return {
+        :error => "Invalid geometry",
+        :geometry_errors => errors
+      }
+    end
+
+    # validate geometry type
+    errors = []
+    feature_collection.each do |feature|
+      error = validate_geometry_type(feature)
+      errors << error unless error.nil?
+    end
+    if errors.any?
+      return {
+        :error => "Invalid geometry type",
+        :geometry_errors => errors
+      }
+    end
+
+    # validations OK
+    return nil
+  end
+
+  def self.validate_feature(feature, geojson_data)
+    if feature.nil? || (feature.is_a?(RGeo::GeoJSON::Feature) && feature.geometry.is_empty?)
+      geojson = JSON.parse(geojson_data)
+      if geojson['type'].blank? || geojson['type'] != 'Feature'
+        # not a GeoJSON
+        return {
+          :error => "Invalid GeoJSON"
+        }
+      else
+        # invalid geometry
+        # NOTE: RGeo::GeoJSON.decode is nil or feature geometry is empty if geometry is invalid
+        errors = []
+        begin
+          errors = validate_geometry(geojson)
+        rescue => err
+          logger.error "Error while checking GeoJSON geometries:\n#{err.message}"
+        end
+
+        return {
+          :error => "Invalid geometry",
+          :geometry_errors => errors
+        }
+      end
+    elsif !feature.is_a? RGeo::GeoJSON::Feature
+      # not a GeoJSON Feature
+      return {
+        :error => "GeoJSON is not a Feature"
+      }
+    end
+
+    # validate geometry type
+    error = validate_geometry_type(feature)
+    unless error.nil?
+      return {
+        :error => "Invalid geometry type",
+        :geometry_errors => [error]
+      }
+    end
+
+    # validations OK
+    return nil
+  end
+
+  def self.validate_geometry(feature)
+    errors = []
+
+    # validate geometry
+    wkt_geom = ""
+    sql = "WITH feature AS (SELECT ST_GeomFromGeoJSON(?) AS geom) SELECT valid, reason, ST_AsText(location) AS location, ST_AsText(geom) AS wkt_geom FROM feature, ST_IsValidDetail(geom)"
+    sql = send :sanitize_sql, [sql, feature['geometry'].to_json]
+    results = connection.execute(sql)
+    results.each do |result|
+      if result['valid'] == 'f'
+        error = {}
+        error[:id] = feature['id'] unless feature['id'].blank?
+        error[:reason] = result['reason'] unless result['reason'].blank?
+        error[:location] = result['location'] unless result['location'].blank?
+        errors << error
+      end
+      wkt_geom = result['wkt_geom']
+    end
+
+    # check for repeated vertices
+    wkt_geom.gsub(/(?<=\()([\d\.,\s]+)(?=\))/) do |m|
+      vertices = m.split(',')
+      vertices.each_with_index do |v, i|
+        if i > 0 && vertices[i-1] == v
+          errors << {
+            :reason => "Duplicated point",
+            :location => "POINT(#{v})"
+          }
+        end
+      end
+    end
+
+    errors
+  end
+
+  def self.validate_geometry_type(feature)
+    if geometry_type != 'GEOMETRY' && feature.geometry.geometry_type.to_s.upcase != geometry_type
+      error = {}
+      error[:id] = feature.feature_id unless feature.feature_id.blank?
+      error.merge({
+        :reason => "Invalid geometry type: #{feature.geometry.geometry_type}",
+        :location => feature.geometry.as_text
+      })
+    end
+  end
+
+  # default client_srid
+
+  @@default_client_srid = 21781
+
+  def self.set_default_client_srid(client_srid)
+    @@default_client_srid = client_srid
+  end
+
+  def self.default_client_srid
+    @@default_client_srid
+  end
+
+  # default geo factory
+
+  @@default_rgeo_factory = RGeo::Cartesian.factory(:srid => 21781, :proj4 => '+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +towgs84=674.4,15.1,405.3,0,0,0,0 +units=m +no_defs')
+
+  def self.set_default_rgeo_factory(factory)
+    @@default_rgeo_factory = factory
+  end
+
+  def self.default_rgeo_factory
+    @@default_rgeo_factory
+  end
+
   def self.geo_factory
     if self.rgeo_factory_generator == RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
       self.rgeo_factory_generator = RGeo::Geos.factory_generator
       rgeo_factory_settings.set_column_factory(table_name, geometry_column_name,
-        RGeo::Cartesian.factory(:srid => 21781, :proj4 => '+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +towgs84=674.4,15.1,405.3,0,0,0,0 +units=m +no_defs')
+        default_rgeo_factory
       )
     end
     rgeo_factory_for_column(geometry_column_name)