gb_mapfish_appserver 0.0.6 → 0.0.7

data/app/controllers/print_controller.rb~

@@ -1,243 +0,0 @@
-#Mapfish print controller with access control and servlet call
-
-class PrintController < ApplicationController
-  require 'popen4'
-  begin
-    require 'RMagick'
-  rescue LoadError
-    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
-
-  caches_action :info
-
-  class JavaError < Exception
-    def initialize(cmd, message)
-      super(cmd+"\n"+message)
-    end
-  end
-
-  def initialize
-    @configFile = "#{Rails.root}/config/print.yml"
-  end
-
-  TMP_PREFIX = "/opt/geodata/tmp/mfPrintTempFile" #WARNING: use NFS for multi-node setups! TODO: external config
-  TMP_SUFFIX = ".pdf"
-  TMP_PURGE_SECONDS = 600
-
-  OUTPUT_FORMATS = ["pdf", "png", "jpg", "tif", "gif"]
-
-  def info
-    #if PRINT_URL.present?
-    #TODO:  call_servlet(request)
-    cmd = baseCmd + " --clientConfig"
-    result = ""
-    errors = ""
-    status = POpen4::popen4(cmd) do |stdout, stderr, stdin, pid|
-
-      result = stdout.readlines.join("\n")
-      errors = stderr.readlines.join("\n")
-    end
-    if status.nil? || status.exitstatus != 0
-      raise JavaError.new(cmd, errors)
-    else
-      info = ActiveSupport::JSON.decode(result)
-      info['createURL'] = url_for(:protocol => request.protocol, :action=>'create') + '.json'
-      # add output formats
-      info['outputFormats'] = []
-      OUTPUT_FORMATS.each do |output_format|
-        info['outputFormats'] << {:name => output_format}
-      end
-
-      respond_to do |format|
-        format.json do
-          if params[:var]
-            render :text=>"var "+params[:var]+"="+result+";"
-          else
-            render :json=>info
-          end
-        end
-      end
-    end
-  end
-
-  def create
-    cleanupTempFiles
-
-    accessible_topics = Topic.accessible_by(current_ability).collect{ |topic| topic.name }
-    layers_to_delete = []
-    request.parameters["layers"].each do |layer|
-      if layer["baseURL"] # WMS layers
-        topic = File.basename(URI.parse(layer["baseURL"]).path)
-        if accessible_topics.include?(topic)
-          # rewrite URL for local WMS, use CGI if layer filter is used
-          use_cgi = !layer["customParams"].nil? && layer["customParams"].any? { |param, value| param =~ LAYER_FILTER_REGEX }
-          layer["baseURL"] = rewrite_wms_uri(layer["baseURL"], use_cgi)
-          if layer["customParams"] #Set map_resolution for mapserver (MapFish print bug?)
-            layer["customParams"].delete("DPI")
-            layer["customParams"]["map_resolution"] = request.parameters["dpi"]
-          end
-          # For permission check in WMS controller: pass session as WMS request parameter
-          #layer["customParams"]["session"] =
-        else
-          # collect inaccessible layers for later removal
-          layers_to_delete << layer
-        end
-      end
-
-      if layer["baseURL"].nil? && layer["styles"] #Vector layers
-        layer["styles"].each_value do |style| #NoMethodError (undefined method `each_value' for [""]:Array):
-          if style["externalGraphic"]
-            style["externalGraphic"].gsub!(LOCAL_GRAPHICS_HOST, '127.0.0.1')
-            style["externalGraphic"].gsub!(/^https:/, 'http:')
-          end
-        end
-      end
-    end
-    # remove inaccessible layers
-    request.parameters["layers"] -= layers_to_delete
-
-    request.parameters["pages"].each do |page|
-      # round center coordinates
-      page["center"].collect! {|coord| (coord * 100.0).round / 100.0  }
-      # add blank user strings if missing
-      page["user_title"] = " " if page["user_title"].blank?
-      page["user_comment"] = " " if page["user_comment"].blank?
-      # base url
-      page["base_url"] = "#{request.protocol}#{request.host}"
-      # disclaimer
-      topic = Topic.accessible_by(current_ability).where(:name => page["topic"]).first
-      page["disclaimer"] = topic.nil? ? Topic.default_print_disclaimer : topic.print_disclaimer
-    end
-
-    logger.info request.parameters.to_yaml
-
-    if PRINT_URL.present?
-      call_servlet(request)
-    else
-      #print-standalone
-      tempId = SecureRandom.random_number(2**31)
-      temp = TMP_PREFIX + tempId.to_s + TMP_SUFFIX
-      cmd = baseCmd + " --output=" + temp
-      result = ""
-      errors = ""
-      status = POpen4::popen4(cmd) do |stdout, stderr, stdin, pid|
-        stdin.puts request.parameters.to_json
-        #body = request.body
-        #FileUtils.copy_stream(body, stdin)
-        #body.close
-        stdin.close
-        result = stdout.readlines.join("\n")
-        errors = stderr.readlines.join("\n")
-      end
-      if status.nil? || status.exitstatus != 0
-        raise JavaError.new(cmd, errors)
-      else
-        convert_and_send_link(temp, tempId, request.parameters["dpi"], request.parameters["outputFormat"])
-      end
-    end
-  end
-
-  def show
-    output_format = params[:format]
-    if OUTPUT_FORMATS.include?(output_format)
-      temp = TMP_PREFIX + params[:id] + ".#{output_format}"
-      case output_format
-      when "pdf"
-        type = 'application/x-pdf'
-      when "png"
-        type = 'image/png'
-      when "jpg"
-        type = 'image/jpeg'
-      when "tif"
-        type = 'image/tiff'
-      when "gif"
-        type = 'image/gif'
-      end
-      send_file temp, :type => type, :disposition => 'attachment', :filename => params[:id] + ".#{output_format}"
-    end
-  end
-
-  protected
-
-  def rewrite_wms_uri(url, use_cgi)
-    #http://wms.zh.ch/basis -> http://127.0.0.1/cgi-bin/mapserv.fcgi?MAP=/opt/geodata/mapserver/maps/intranet/basis.map&
-    out = url
-    # get topic from layer URL
-    uri = URI.parse(url)
-    localwms = LOCAL_WMS.any? { |ref| uri.host =~ ref }
-    if localwms
-      topic = File.basename(uri.path)
-      localhost = (@zone == ZONE_INTRANET) ? '127.0.0.1' : 'localhost'
-      out = "http://#{localhost}#{use_cgi ? MAPSERV_CGI_URL :  MAPSERV_URL}?MAP=#{MAPPATH}/#{@zone}/#{topic}.map&"
-      #out = "http://#{localhost}:#{request.port}/wms/#{topic}"
-    end
-    out
-  end
-
-  def baseCmd
-    "java -cp #{GbMapfishPrint::PRINT_JAR} org.mapfish.print.ShellMapPrinter --config=#{@configFile}"
-  end
-
-  def cleanupTempFiles
-    minTime = Time.now - TMP_PURGE_SECONDS;
-    OUTPUT_FORMATS.each do |output_format|
-      Dir.glob(TMP_PREFIX + "*." + output_format).each do |path|
-        if File.mtime(path) < minTime
-          File.delete(path)
-        end
-      end
-    end
-  end
-
-  def call_servlet(request)
-    url = URI.parse(URI.decode(PRINT_URL))
-    logger.info "Forward request: #{PRINT_URL}"
-    printspec = request.parameters.to_json
-
-    response = nil
-    begin
-      http = Net::HTTP.new(url.host, url.port)
-      http.start do
-        case request.method.to_s
-        when 'GET'  then response = http.get(url.path) #, request.headers
-        #when 'POST' then response = http.post(url.path, printspec)
-        when 'POST'  then response = http.get("#{url.path}?spec=#{CGI.escape(printspec)}") #-> GET print.pdf
-        else
-          raise Exception.new("unsupported method `#{request.method}'.")
-        end
-      end
-    rescue => err
-      logger.info("#{err.class}: #{err.message}")
-      render :nothing => true, :status => 500
-      return
-    end
-    #send_data response.body, :status => response.code, :type=>'application/x-pdf', :disposition=>'attachment', :filename=>'map.pdf'
-    tempId = SecureRandom.random_number(2**31)
-    temp = TMP_PREFIX + tempId.to_s + TMP_SUFFIX
-    File.open(temp, 'w') {|f| f.write(response.body) }
-    convert_and_send_link(temp, tempId, request.parameters["dpi"], request.parameters["outputFormat"])
-  end
-
-  # optionally convert PDF to image and send link to print result
-  def convert_and_send_link(temp_pdf, temp_id, dpi, output_format)
-    temp_suffix = ".pdf"
-
-    if output_format != "pdf" && OUTPUT_FORMATS.include?(output_format)
-        # convert PDF to image
-        pdf = Magick::Image.read(temp_pdf) { self.density = dpi }.first
-        temp_suffix = ".#{output_format}"
-        temp_img = TMP_PREFIX + temp_id.to_s + temp_suffix
-        pdf.write(temp_img)
-        File.delete(temp_pdf)
-    end
-
-    respond_to do |format|
-      format.json do
-        render :json=>{ 'getURL' => url_for(:action=>'show', :id=>temp_id) + temp_suffix }
-      end
-    end
-  end
-
-end

data/app/models/layer.rb~

@@ -1,283 +0,0 @@
-class Layer < ActiveRecord::Base
-  has_many :topics_layers, :dependent => :destroy
-  has_many :topics, :through => :topics_layers
-  belongs_to :sublayer_group
-
-  attr_protected []
-
-  validates :name, :presence => true, :uniqueness => {:scope => :topic_name}
-  validates_format_of :name, :with => /\A[A-Za-z][\w-]*\Z/
-  validates_format_of :topic_name, :with => /\A[\w-]+\Z/
-
-  scope :defaultorder, order(:topic_name, :name)
-  scope :unused, includes(:topics_layers).where('topics_layers.layer_id IS NULL')
-
-  #Namespace for run-time geo classes
-  module Geo
-  end
-
-  # Enum for RailsAdmin form (causes exception in name search)
-  #def sublayer_group_enum
-  #  SublayerGroup.all.collect {|p| [ p.name, p.id ] }
-  #end
-
-  #Structure for Topic selection
-  def self.list(ability, layer_type, topic_name)
-    topic = Topic.accessible_by(ability).includes(:layers).where(:name => topic_name).first
-    layers = topic.nil? ? [] : topic.layers.accessible_by(ability).all
-    topic_layers = topic.nil? ? [] : topic.topics_layers.select {|tl| layers.include?(tl.layer) }
-    wms_layer_list(ability, topic, topic_layers)
-  end
-
-  def self.wms_layer_list(ability, topic, topic_layers)
-    wms_layers = topic_layers.collect do |topic_layer|
-      layer = topic_layer.layer
-      {
-        "id" => topic_layer.id,
-        "layername"=> layer.name,
-        "topic"=> topic.name,
-        "groupname" => layer.sublayer_group.try(:name),
-        "toclayertitle"=> layer.title,
-        "leglayertitle"=> layer.title,
-        "showscale"=> "true",
-        "minscale"=> layer.minscale,
-        "maxscale"=> layer.maxscale,
-        "wms_sort"=> topic_layer.wms_sort, # MapServer layer order
-        #"leg_sort"=> topic_layer.leg_sort, # Not used client side (Legend sort is in defined in HTML). Query result order. 
-        #"query_sort"=> topic_layer.leg_sort, # deprecated
-        "toc_sort"=> topic_layer.toc_sort, # Layer tree order
-        "wms"=> "false",
-        "visini"=> topic_layer.visini,
-        "visuser"=> topic_layer.visini, #User visibility is in request_state
-        "showtoc"=> "true",
-        "editeable"=> ability.can?(:edit, layer)
-      }
-    end
-    {
-      "success" => true,
-      "messageProperty"=> {"topic"=> topic.name, "legendtitle"=> "Legende", "legendraster"=> "true"},
-      "results"=> wms_layers.size,
-      "wmslayers"=> wms_layers
-    }
-  end
-
-  def full_name
-    "#{topic_name}-#{name}".downcase
-  end
-
-  def feature_class
-    fc = "Geo::#{feature_class_name}".constantize rescue nil #Geo.const_defined?(feature_class_name) seems not to work here
-    fc ||= Geo.module_eval <<EOS
-      class #{feature_class_name} < GeoModel
-        self.table_name = '#{table}'
-        self.primary_key = '#{pkey}'
-
-        self
-      end
-EOS
-  end
-
-  def feature_class_name
-    table.camelize.singularize
-  end
-
-  def geometry_column
-    feature_class.try(:geometry_column)
-  end
-
-  def attribute(name)
-    if feature_class.nil?
-      ::Attribute.new(self, name)
-    else
-      @attrs ||= feature_class.columns.inject({}) do |h, c|
-        #logger.info "************************* feature_class column c #{c.inspect}"
-        h[c.name] = ::Attribute.new(self, c.name)
-        h
-      end
-      @attrs[name] ||= ::Attribute.new(self, name) #Add ad-hoc Attr. for calculated columns (e.g. custom SQL in query fields)
-    end
-    #logger.info "************************* Attribute for name '#{name}': #{@attrs[name].inspect}"
-  end
-
-  #def filtered(ability)
-  #  feature_class.where(ability.resource_access_filter(self))
-  #end
-
-  def query_fields(ability)
-    return '' if feature_class.nil?
-    area_field = "ST_Area(#{geometry_column.name}) AS area"
-    #TODO: measure -> Measure(geometry_column, lat, lon)
-    ([pkey]+ident_fields_for(ability)+[feature_class.extent_field, area_field]).join(',')
-  end
-
-  def ident_fields_for(ability)
-    #attributes.accessible_by(ability) & fields
-    #logger.info "************************* fields layer #{name}: #{ident_fields}"
-    #logger.info "************************* roles: #{ability.roles.collect(&:name).join(',')}"
-    allowed_fields = ident_fields.split(',').select { |f| ability.can?(:show, attribute(f))  }
-    #logger.info "************************* ident_fields layer #{name}: #{allowed_fields.inspect}"
-    allowed_fields
-  end
-
-  def query(ability, query_topic, searchbbox)
-    if feature_class
-      begin
-        #query_topic: {... customQueries: {<layername>: <query_method> }
-        #e.g.
-        #{"queryTopics":[{
-        #   "level":"main","topic":"Lageklassen2011ZH","divCls":"legmain","layers":"seen,lageklassen-2011-flaechen,grenzen,gemeindegrenzen,bezirkslabels"
-        #   customQueries: {'seen': 'tiefen_statistik'},
-        #   customParams: {'tiefe': 25}
-        #  }]}
-        custom_query_method = query_topic['customQueries'][name] rescue nil
-        logger.debug "******** #{feature_class} ***************************************************"
-        features = if custom_query_method
-          logger.debug "Custom query on layer #{name}: #{query_topic.inspect}"
-          feature_class.send(custom_query_method, self, query_topic, searchbbox) 
-        else
-          logger.debug "Identify on layer #{name} with query fields #{query_fields(ability)} at #{searchbbox.inspect}"
-          feature_class.identify_filter(searchbbox, searchdistance).select(query_fields(ability)).all
-        end
-        logger.debug "Number of features: #{features.size}"
-        # calculate bbox of all features
-        unless features.empty?
-          envelope = GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb(features.first['extent']).envelope
-          features.each do |feature|
-            next if feature == features.first
-            envelope.extend!(GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb(feature['extent']).envelope)
-          end
-          bbox = [envelope.lower_corner.x, envelope.lower_corner.y, envelope.upper_corner.x, envelope.upper_corner.y]
-        end
-      rescue Exception => e
-        features = "Table: <b>#{table}</b><br/>Exception: #{e}<br/>query fields: #{query_fields(ability)}<br/>db fields: #{feature_class.column_names.join(',')}<br/>missing: <font color='red'>#{(query_fields(ability).split(',') - feature_class.column_names).join(', ')}</font><br/><br/>"
-        logger.info "Identfy error on layer #{name} #{features}"
-      end
-      [self, features, bbox]
-    else
-      logger.warn "Table for layer #{name} not found. (Table name: '#{table}')"
-      nil
-    end
-  end
-
-  # Partial for identify result
-  def info_fname
-    "_#{name}_info.html.erb"
-  end
-
-  def info_file
-    File.join(Rails.root, 'app', 'views', 'layers', 'custom', topic_name.downcase, info_fname)
-  end
-
-  def info_file_auto
-    File.join(Rails.root, 'app', 'views', 'layers', 'custom', topic_name.downcase, 'auto', info_fname)
-  end
-
-  # ignore auto file if empty file exists
-  def info_file_empty
-    File.join(Rails.root, 'app', 'views', 'layers', 'custom', topic_name.downcase, "_#{name}_info_leer.html.erb")
-  end
-
-  def info
-    @info ||= begin
-      if File.exist?(info_file)
-        "layers/custom/#{topic_name.downcase}/#{info_fname[1..-10]}"
-      elsif !File.exist?(info_file_empty) && File.exist?(info_file_auto)
-        "layers/custom/#{topic_name.downcase}/auto/#{info_fname[1..-10]}"
-      else
-        nil
-      end
-    end
-  end
-
-  def infotext(count)
-    count > 0 ? "resultcount_p" : "resultcount_s"
-  end
-
-  def infotab
-    #  INFOLAYOUT=0^1^2^3^4^5^6^7  *** Wenn der Parameter = 1 ist, wird ein leerer String �bergeben.
-    #                              *** Wenn der Parameter = 0 ist, wird der entsprechende Teil weggelassen wenn m�glich
-    #
-    #  LayoutString(0) = "Im Umkreis von <EM>xUmkreisx</EM> Meter(n) wurde <EM>xAnzahlx</EM> Datensatz gefunden.<br><br>"
-    #  LayoutString(1) = "Im Umkreis von <EM>xUmkreisx</EM> Meter(n) wurden <EM>xAnzahlx</EM> Datens&aumltze gefunden.<br><br>"
-    #  LayoutString(2) = "layer"
-    #  LayoutString(3) = "infotext"
-    #  LayoutString(4) = "infotab"
-    #  LayoutString(5) = "tabtitle"
-    #  LayoutString(6) = "tabcell"
-    #  LayoutString(7) = "2"  ( If = "" Then 1 Tabellenzeile pro Record [z.B. "1" oder ""], else [z.B. "2"] 1 Zeile pro Feld)
-
-    "infotable_horizontal"
-  end
-
-  def legend_fname
-    "_#{name}_legend.html.erb"
-  end
-
-  def legend_file
-    File.join(Rails.root, 'app', 'views', 'layers', 'custom', topic_name.downcase, legend_fname)
-  end
-
-  def legend_file_auto
-    File.join(Rails.root, 'app', 'views', 'layers', 'custom', topic_name.downcase, 'auto', legend_fname)
-  end
-
-  def legend
-    @legend ||= begin
-      if File.exist?(legend_file)
-        "layers/custom/#{topic_name.downcase}/#{legend_fname[1..-10]}"
-      elsif File.exist?(legend_file_auto)
-        "layers/custom/#{topic_name.downcase}/auto/#{legend_fname[1..-10]}"
-      else
-        nil
-      end
-    end
-  end
-
-  def quoted_wms_layers
-    wms_layers.split(',').collect {|l| %Q<"#{l}"> }.join(',')
-  end
-
-  DEFAULT_SELECTION_STYLE = {
-    'POLYGON' =>
-      '<PolygonSymbolizer>'+
-        '<Fill>'+
-          '<CssParameter name="fill">#ff0090</CssParameter>'+
-          '<CssParameter name="fill-opacity">0.6</CssParameter>'+
-        '</Fill>'+
-        '<Stroke>'+
-          '<CssParameter name="stroke">#ff0090</CssParameter>'+
-          '<CssParameter name="stroke-width">2.00</CssParameter>'+
-        '</Stroke>'+
-      '</PolygonSymbolizer>',
-    'LINESTRING' =>
-      '<LineSymbolizer>'+
-        '<Stroke>'+
-          '<CssParameter name="stroke">#ff0090</CssParameter>'+
-          '<CssParameter name="stroke-width">10.00</CssParameter>'+
-        '</Stroke>'+
-      '</LineSymbolizer>',
-    'POINT' =>
-      '<PointSymbolizer>'+
-         '<Graphic>'+
-           '<Mark>'+
-             '<WellKnownName>circle</WellKnownName>'+
-             '<Fill>'+
-               '<CssParameter name="fill">#ff0090</CssParameter>'+
-             '</Fill>'+
-           '</Mark>'+
-           '<Size>45.0</Size>'+
-         '</Graphic>'+
-       '</PointSymbolizer>'
-  }
-
-  def selection_symbolizer
-    if selection_style.blank?
-      gtyp = feature_class.geometry_type.sub(/^MULTI/, '').sub(/M$/, '') #MULTIPOINTM -> POINT 
-      logger.error "Unsupported selection geometry type #{feature_class.geometry_type}" unless DEFAULT_SELECTION_STYLE.has_key?(gtyp)
-      DEFAULT_SELECTION_STYLE[gtyp] || ''
-    else
-      selection_style
-    end
-  end
-
-end