atlas_middleware 0.0.1 → 0.0.2

data/README

@@ -1,3 +1,24 @@
-== AtlasRack
+== Atlas Middleware
 
-You should document your project here.
+Rack middleware components to support NBADW Atlas maps.
+
+Includes the following:
+
+* Place Name Search
+  Powered by Natural Resources Canada's CGNS (Canadian Geographical Names Service), an
+  on-line web service providing information about Canada's geographical names including
+  location, status, classification and other details with each official geographical name.
+
+* Postal Code Lookup
+  Powered by the CGDI Postal Code Lookup Service which returns geometries for known forward
+  sortation area (FSA) postal codes.
+
+* ArcGIS Server REST Proxy
+  Provides proxied access to ESRI's ArcGIS Server 9.3 REST interface.  Useful for
+  handling XHR requests without having to worry about the same origin security policy
+  enforced by browsers.
+
+* MapServer Legend Info
+  Uses ArcGIS Server's SOAP API to load legend information (layer names and symbols)
+  for MapServer services.
+  

data/lib/{rest_proxy.rb → arcgis_server_rest_proxy.rb}

@@ -1,7 +1,7 @@
 require 'rack'
 require 'httparty'
 
-class RestProxy
+class ArcgisServerRestProxy
   def call(env)
     request = Rack::Request.new(env)
     url = request.params.delete('url')

data/lib/cgns_search.rb

@@ -1,5 +1,4 @@
 require 'rack'
-#require 'rack/cache'
 require 'activesupport'
 require 'httparty'
 
@@ -13,18 +12,29 @@ class CgnsSearch
     request = Rack::Request.new(env)
 
     headers = { "Content-Type" => "application/json" }
-    r = Rack::Response
     begin
-      response = r.new(find(request.params), 200, headers)
+      response = Rack::Response.new(find(request.params), 200, headers)
+      response = maybe_cache_response(response)
     rescue Exception => e
-      response = r.new(e.message, 500, headers)
+      response = Rack::Response.new({ :error => e.message }.to_json, 500, headers)
     end
-    #response.max_age = 1.month
     
     response.to_a
   end
-  
+
+  private
   def find(query = {})
     CgnsSearch.get('/gnss-srt/api', { :query => query }).to_json
   end
+
+  def maybe_cache_response(response)
+    begin
+      # using rack cache
+      cached_response = Rack::Cache::Response.new(response.status, response.headers, response.body)
+      cached_response.max_age = 1.month
+      cached_response
+    rescue
+      response # just return the original response
+    end
+  end
 end

data/lib/export_map_services.rb

@@ -0,0 +1,56 @@
+require 'arcserver'
+require 'RMagick'
+
+class ExportMapServices
+  def call(env)
+    request = Rack::Request.new(env)
+
+    begin
+      response = Rack::Response.new(export_map_services(request), 200, headers)
+      response = maybe_cache_response(response)
+    rescue Exception => e
+      response = Rack::Response.new({ :error => e.message }.to_json, 500, headers)
+    end
+
+    response.to_a
+  end
+
+  private
+  def export_map_services(request)
+    opts = {
+      :bbox        => request['bbox'],
+      :f           => request['f'],
+      :format      => request['format'],
+      :transparent => request['transparent'],
+      :size        => request['size'],
+      :dpi         => request['dpi']
+    }
+
+    base_image = generate_base_image(opts)
+    request['urls'].split(',').each do |url|
+      map_service = ArcServer::MapServer.new(url)
+      exported_image = map_service.export(opts)
+#      merge(base_image, exported_image)
+    end
+
+
+  end
+
+  def generate_base_image(opts)
+    base_image = Magick::Image.new(width, height)
+    base_image.background_color = 'transparent'
+    base_image.format = 'PNG'
+    base_image
+  end
+
+  def maybe_cache_response(response)
+    begin
+      # using rack cache
+      cached_response = Rack::Cache::Response.new(response.status, response.headers, response.body)
+      cached_response.max_age = 1.week
+      cached_response
+    rescue
+      response # just return the original response
+    end
+  end
+end

data/lib/map_server_legend_info.rb

@@ -1,17 +1,37 @@
 require 'arcserver'
+require 'activesupport'
 
 class MapServerLegendInfo
   def call(env)
     request = Rack::Request.new(env)
-    
+    headers = { "Content-Type" => "application/json" }
+
     begin
-      map_server = ArcServer::MapServer.new(request['url'])
-      map_name = map_server.get_default_map_name
-      legend = map_server.get_default_map_name(:map_name => map_name)
+      response = Rack::Response.new(get_legends(request['url']), 200, headers)
+      response = maybe_cache_response(response)
     rescue Exception => e
-      return [500, { "Content-Type" => "text/plain" }, e.message]
+      response = Rack::Response.new({ :error => e.message }.to_json, 500, headers)
     end
 
-    [200, { "Content-Type" => "application/json" }, legend.to_json]
+    response.to_a
+  end
+
+  private
+  def get_legends(map_server_url)
+    map_server = ArcServer::MapServer.new(map_server_url)
+    map_name = map_server.get_default_map_name
+    legend = map_server.get_legend_info(:map_name => map_name)
+    legend.to_json
+  end
+
+  def maybe_cache_response(response)
+    begin
+      # using rack cache
+      cached_response = Rack::Cache::Response.new(response.status, response.headers, response.body)
+      cached_response.max_age = 1.week
+      cached_response
+    rescue
+      response # just return the original response
+    end
   end
 end

data/lib/postal_code_lookup.rb

@@ -1,5 +1,4 @@
 require 'rack'
-#require 'rack/cache'
 require 'activesupport'
 require 'httparty'
 
@@ -16,22 +15,19 @@ class PostalCodeLookup
   def call(env)
     request = Rack::Request.new(env)
 
-    headers = { "Content-Type" => "text/plain" }
-    r = Rack::Response # shorthand
+    headers = { "Content-Type" => "application/json" }
     begin
-      response = r.new(200, headers, find(request.params['code']))
+      response = Rack::Response.new(find(request.params['code']), 200, headers)
+      response = maybe_cache_response(response)
     rescue Exception => e
-      response = r.new(500, headers, e.message)
+      response = Rack::Response.new({ :error => e.message }.to_json, 500, headers)
     end
-#    response.max_age = 1.month
 
     response.to_a
   end
 
   def find(code)
-    result = PostalCodeLookup.get('/cgi-bin/postalcode/postalcode.cgi', {
-        :query => { :code => code }
-      })
+    result = PostalCodeLookup.get('/cgi-bin/postalcode/postalcode.cgi', { :query => { :code => code } })
 
     if error = result["ServiceExceptionReport"]
       raise ServiceException.new(error['ServiceException'])
@@ -42,13 +38,24 @@ class PostalCodeLookup
       lng, lat = location["gml:coordinates"].split(',')
       return {
         :postal_code => postal_code["gml:name"],
-        :epsg => epsg,
+        :epsg => epsg.to_i,
         :srs_name => location["srsName"],
-        :latitude => lat,
-        :longitude => lng,
+        :latitude => lat.to_f,
+        :longitude => lng.to_f,
         :placename => postal_code["Placename"],
         :province_or_territory => postal_code["ProvinceOrTerritory"]
       }.to_json
     end
   end
+
+  def maybe_cache_response(response)
+    begin
+      # using rack cache
+      cached_response = Rack::Cache::Response.new(response.status, response.headers, response.body)
+      cached_response.max_age = 1.month
+      cached_response
+    rescue
+      response # just return the original response
+    end
+  end
 end

data/test/print_map/job_test.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'print_map/job'
+
+module PrintMap
+  class JobTest < Test::Unit::TestCase
+    context "created job" do
+      should "not contain any services if none were specified" do
+        job = Job.new
+        assert job.services.empty?
+      end
+
+      should "not contain any services if 'services' parameter is blank" do
+        job = Job.new('services' => '')
+      end
+
+      should "be able to accept a single service" do
+        job = Job.new('services' => 's')
+        assert_equal 1, job.services.length
+        assert_equal 's', job.services[0]
+      end
+
+      should "be able to accept multiple services" do
+        job = Job.new('services' => 's1,s2')
+        assert_equal 2, job.services.length
+        assert_equal 's1', job.services[0]
+        assert_equal 's2', job.services[1]
+      end
+
+      should "have an empty bounding box if parameter is not specified" do
+        job = Job.new
+        assert job.bbox.empty?
+      end
+
+      should "have an empty bounding box if 'bbox' parameter is blank" do
+        job = Job.new('bbox' => '')
+        assert job.bbox.empty?
+      end
+
+      should "be able to configure the bounding box" do
+        job = Job.new('bbox' => "1,2,3,4")
+        assert_equal [1,2,3,4], job.bbox
+      end
+
+      should "use :portrait as default page layout" do
+        job = Job.new
+        assert_equal :portrait, job.page_layout
+      end
+
+      should "be able to set page layout to :portrait" do
+        job = Job.new('page_layout' => 'portrait')
+        assert_equal :portrait, job.page_layout
+      end
+
+      should "be able to set page layout to :landscape" do
+        job = Job.new('page_layout' => 'landscape')
+        assert_equal :landscape, job.page_layout
+      end
+
+      should "use A4 paper as default page size" do
+        job = Job.new
+        assert_equal 'A4', job.page_size
+      end
+
+      should "be able to set the page size" do
+        job = Job.new('page_size' => 'LEGAL')
+        assert_equal 'LEGAL', job.page_size
+      end
+
+      should "use 96 as the default DPI" do
+        job = Job.new
+        assert_equal 96, job.dpi
+      end
+
+      should "be able to set the DPI" do
+        job = Job.new('dpi' => 300)
+        assert_equal 300, job.dpi
+      end
+
+      should "use 'Untitled Map' as the default title" do
+        job = Job.new
+        assert_equal 'Untitled Map', job.title
+      end
+
+      should "be able to set the title" do
+        job = Job.new('title' => 'My Title')
+        assert_equal 'My Title', job.title
+      end
+    end
+
+    context "when validating a job" do
+      should "require at least one service" do
+        job = Job.new
+        job.validate_only("length_of/services")
+        assert_match /at least one service needs to be requested/, job.errors.on(:services)
+      end
+
+      should "require all service urls to be MapServer urls" do
+        job = Job.new('services' => 'http://not.a.map/server/url')
+        job.validate_only("true_for/services")
+        assert_match /all services need to be valid MapServer urls/, job.errors.on(:services)
+      end
+
+      should "require bbox to contain four values" do
+        job = Job.new('bbox' => '1,2,3')
+        job.validate_only("length_of/bbox")
+        assert_match /bad format for 'bbox'/, job.errors.on(:bbox)
+
+        job = Job.new('bbox' => '1,2,3,4,5')
+        job.validate_only("length_of/bbox")
+        assert_match /bad format for 'bbox'/, job.errors.on(:bbox)
+
+        job = Job.new('bbox' => '1,2,3,4')
+        job.validate_only('length_of/bbox')
+        assert_nil job.errors.on(:bbox)
+      end
+
+      should "require bbox to be composed of only positive or negative numbers" do
+        job = Job.new('bbox' => 'a,b,c,d')
+        job.validate_only('true_for/bbox')
+        assert_match /all bbox values must be valid positive\/negative number/, job.errors.on(:bbox)
+
+        job = Job.new('bbox' => '0,1,0.1,-0.1')
+        job.validate_only('true_for/bbox')
+        assert_nil job.errors.on(:bbox)
+      end
+
+      should "be able to pass validations" do
+        job = Job.new(
+          'bbox' => [0, 1, 0.1, -0.1].join(','),
+          'services' => [
+            'http://sampleserver1.arcgisonline.com/ArcGIS/services/Portland/ESRI_LandBase_WebMercator/MapServer',
+            'http://sampleserver2.arcgisonline.com/ArcGIS/services/Portland/ESRI_LandBase_WebMercator/MapServer'
+          ].join(',')
+        )
+        assert job.valid?, job.errors.full_messages.join(', ')
+      end
+    end
+  end
+end

data/test/print_map/worker_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'print_map/worker'
+require 'print_map/job'
+require 'print_map/legend_images_collector'
+
+module PrintMap
+  class WorkerTest < Test::Unit::TestCase
+    should "create a pdf from a job request that responds to :render" do
+      job = Job.new
+      worker = Worker.new
+      pdf = worker.do_job(job)
+      assert_respond_to(pdf, :render)
+    end
+
+    context "when verifying expected behavior" do
+      setup do
+        @mock_map_exporter = mock do
+          expects(:export).times(2).returns(Magick::Image.new(1,1), Magick::Image.new(1,1))
+        end
+
+        @mock_pdf_generator = mock do
+          expects(:generate).once().returns(Prawn::Document.new)
+        end
+
+        services = [
+          'http://sampleserver1.arcgisonline.com/ArcGIS/services/Demographics/ESRI_Census_USA/MapServer',
+          'http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Petroleum/KGS_OilGasFields_Kansas/MapServer'
+        ]
+
+        @mock_legend_images_collector = mock do
+          expects(:collect).times(2).returns([Magick::Image.new(1,1), Magick::Image.new(1,1)])
+        end
+
+        @job = Job.new('services' => services.join(','))
+      end
+
+      should "delegate third-party api work to adapters" do
+        worker = Worker.new(
+          :map_exporter => @mock_map_exporter,
+          :pdf_generator => @mock_pdf_generator,
+          :legend_images_collector => @mock_legend_images_collector
+        )
+        worker.do_job(@job)
+      end
+    end
+  end
+end

data/test/print_map_service_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'print_map_service'
+
+class PrintMapServiceTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    @app ||= PrintMapService.new
+  end
+
+  context "when requested job is valid" do
+    setup do
+      mock_job = mock do
+        expects(:valid?).returns(true)
+        expects(:title).returns('Test Title')
+      end
+
+      mock_pdf = mock(:render => 'pdf content')
+
+      mock_worker = mock do
+        expects(:do_job).with(mock_job).returns(mock_pdf)
+      end
+      
+      @app = PrintMapService.new(:worker => mock_worker, :create_job => proc { |opts| mock_job })
+    end
+
+    should "return a pdf document for download" do
+      get "/"
+      assert_equal 200, last_response.status
+      assert_equal "application/pdf", last_response.headers["Content-Type"]
+      assert_equal 'attachment; filename="Test Title.pdf"', last_response["Content-Disposition"]
+      assert_equal 'pdf content', last_response.body
+    end
+  end
+
+  context "when requested job is invalid" do
+    setup do
+      mock_job = mock do
+        expects(:valid?).returns(false)
+        expects(:errors).returns([])
+      end
+      @app = PrintMapService.new(:create_job => proc { |opts| mock_job })
+    end
+
+    should "return an error report" do
+      get "/"
+      assert_equal 500, last_response.status
+      assert_equal "text/plain", last_response.headers['Content-Type']
+      assert_match(/^Print map failed because of the following errors:/, last_response.body)
+    end
+  end
+
+  context "when an error occurs during execution" do
+    setup do
+      mock_job = mock do
+        expects(:valid?).raises('Test Error')
+      end
+      @app = PrintMapService.new(:create_job => proc { |opts| mock_job })
+    end
+
+    should "trap the error and return a friendly response detailing what happened" do
+      get "/"
+      assert_equal 500, last_response.status
+      assert_equal "text/plain", last_response.headers['Content-Type']
+      assert_match /^An internal error occurred:\sTest Error/, last_response.body
+    end
+  end
+end