weather-forecasts 1.1.1

data/lib/weather_forecasts/client/query/query_property.rb

@@ -0,0 +1,68 @@
+module WeatherForecasts
+  class Client
+    class QueryProperty
+      attr_accessor :name, :type, :options, :required_keys, :required, :default
+
+      def initialize(attr, parameters = {})
+        @name          = attr
+        @default       = parameters[:default]
+        @options       = parameters[:options]
+        @type          = parameters[:type] || String
+        @required      = parameters[:required] || false
+        @required_keys = parameters[:required_keys] || []
+      end
+
+      def valid?(conditions)
+        @conditions = conditions
+
+        validate_required
+        validate_type
+        validate_required_keys
+        validate_options
+      end
+
+      protected
+
+      def validate_required
+        if required && @conditions[name.to_sym].blank?
+          raise RequiredPropertyError, "The property, #{name.to_s}, is required."
+        end
+      end
+
+      def validate_type
+        unless @conditions[name.to_sym].is_a?(type)
+          raise InvalidPropertyTypeError, "The type for #{name} should be an instance of #{type.to_s}."
+        end
+      end
+
+      def validate_required_keys
+        return if required_keys.blank?
+        params_sets = @conditions[name.to_sym]
+
+        if params_sets.present? && params_sets.is_a?(Array)
+          params_sets.each { |hsh| check_required_keys_missing(hsh.keys) }
+        elsif params_sets.present? && params_sets.is_a?(Hash)
+          check_required_keys_missing(params_sets.keys)
+        else
+          raise_required_keys_missing_error(required_keys)
+        end
+      end
+
+      def validate_options
+        value = @conditions[name.to_sym]
+        if options.present? && !options.include?(value)
+          raise InvalidOptionSpecifiedError, "The option, #{value}, is not valid.  Please use one of the following: #{options.join(', ')}"
+        end
+      end
+
+      def check_required_keys_missing(keys)
+        missing_keys = required_keys - keys
+        raise_required_keys_missing_error(missing_keys) if missing_keys.present?
+      end
+
+      def raise_required_keys_missing_error(missing_keys)
+        raise RequiredKeysMissingError, "Required keys (#{missing_keys.join(', ')}) are missing for one of the data points (also, they must be in an Array)."
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/query_utilities.rb

@@ -0,0 +1,16 @@
+module WeatherForecasts
+  class Client
+    module QueryUtilities
+      def build_coordinates(coordinates)
+        coordinates.map { |hsh| "#{hsh[:latitude]},#{hsh[:longitude]}" }.join(" ")
+      end
+
+      def transform_coordinate_list(document)
+        document.xpath("//latLonList").text.split.map do |coord|
+          latitude, longitude = coord.split(",").map(&:to_f)
+          { :latitude => latitude, :longitude => longitude }
+        end
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_by_days_query.rb

@@ -0,0 +1,35 @@
+module WeatherForecasts
+  class Client
+    class SelectByDaysQuery < Query
+      include QueryUtilities
+
+      property :coordinates, :type => Array, :required => true, :required_keys => [:latitude, :longitude]
+      property :days,        :type => Fixnum, :required => true
+
+      property :unit,        :type => String, :options => ["e", "m"], :default => "e"
+      property :format,      :type => String, :options => ["24 hourly", "12 hourly"], :default => "24 hourly"
+
+      property :start_date,  :type => ActiveSupport::TimeWithZone
+
+      def execute
+        validate
+
+        response = soap_client.call(:ndf_dgen_by_day_lat_lon_list, :message => build_message)
+        document = Nokogiri::XML(response.body[:ndf_dgen_by_day_lat_lon_list_response][:dwml_by_day_out])
+        DWML.new(document).process
+      end
+
+      protected
+
+      def build_message
+        {
+          :listLatLong => build_coordinates(conditions[:coordinates]),
+          :startDate   => conditions[:start_date].iso8601,
+          :numDay      => conditions[:days],
+          :Unit        => conditions[:unit],
+          :format      => conditions[:format]
+        }
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_coordinates_by_cities_query.rb

@@ -0,0 +1,47 @@
+module WeatherForecasts
+  class Client
+    class SelectCoordinatesByCitiesQuery < Query
+      CITY_OPTIONS = {
+        :all                    => 1234,
+        :primary                => 1,
+        :secondary              => 2,
+        :tertiary               => 3,
+        :quaternary             => 4,
+        :primary_and_secondary  => 12,
+        :tertiary_and_quaternar => 34
+      }
+
+      property :display, :type => Symbol, :options => CITY_OPTIONS.keys, :required => true
+
+      def execute
+        validate
+
+        response = soap_client.call(:lat_lon_list_city_names, :message => build_message)
+        document = parse_xml(response)
+        transform_document_to_mapped_list(document)
+      end
+
+      protected
+
+      def build_message
+        {
+          :displayLevel => CITY_OPTIONS[conditions[:display]]
+        }
+      end
+
+      def parse_xml(response)
+        Nokogiri::XML(response.body[:lat_lon_list_city_names_response][:list_lat_lon_out])
+      end
+
+      def transform_document_to_mapped_list(document)
+        cities = document.xpath("//cityNameList").text.split('|')
+        coords = document.xpath("//latLonList").text.split
+
+        results = [cities, coords].transpose.inject({}) do |memo, (city, coord)|
+          latitude, longitude = coord.split(",").map(&:to_f)
+          memo.merge(city => { :latitude => latitude, :longitude => longitude } )
+        end
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_coordinates_by_zip_query.rb

@@ -0,0 +1,34 @@
+module WeatherForecasts
+  class Client
+    class SelectCoordinatesByZipQuery < Query
+      property :zip, :type => Array, :required => true
+
+      def execute
+        validate
+
+        response = soap_client.call(:lat_lon_list_zip_code, :message => build_message)
+        document = parse_xml(response)
+        transform_document_to_mapped_list(document)
+      end
+
+      protected
+
+      def build_message
+        {
+          :zipCodeList => conditions[:zip].join(" ")
+        }
+      end
+
+      def parse_xml(response)
+        Nokogiri::XML(response.body[:lat_lon_list_zip_code_response][:list_lat_lon_out])
+      end
+
+      def transform_document_to_mapped_list(document)
+        document.xpath("//latLonList").text.split.each_with_index.inject({}) do |memo, (coord, i)|
+          latitude, longitude = coord.split(",").map(&:to_f)
+          memo.merge(conditions[:zip][i] => { :latitude => latitude, :longitude => longitude })
+        end
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_corner_coordinates_query.rb

@@ -0,0 +1,38 @@
+module WeatherForecasts
+  class Client
+    class SelectCornerCoordinatesQuery < Query
+      include QueryUtilities
+
+      SECTOR_GRID_OPTIONS = [
+        :conus,
+        :alaska,
+        :nhemi,
+        :guam,
+        :hawaii,
+        :puertori
+      ]
+
+      property :sector, :type => Symbol, :options => SECTOR_GRID_OPTIONS, :required => true
+
+      def execute
+        validate
+
+        response = soap_client.call(:corner_points, :message => build_message)
+        document = parse_xml(response)
+        transform_coordinate_list(document)
+      end
+
+      protected
+
+      def build_message
+        {
+          :sector   => conditions[:sector].to_s,
+        }
+      end
+
+      def parse_xml(response)
+        Nokogiri::XML(response.body[:corner_points_response][:list_lat_lon_out])
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_gridpoint_coordinates_query.rb

@@ -0,0 +1,35 @@
+module WeatherForecasts
+  class Client
+    class SelectGridpointCoordinatesQuery < Query
+      include QueryUtilities
+
+      property :lower_left_coordinate,  :type => Hash, :required => true, :required_keys => [:latitude, :longitude]
+      property :upper_right_coordinate, :type => Hash, :required => true, :required_keys => [:latitude, :longitude]
+      property :resolution,             :type => Numeric, :default => 5
+
+      def execute
+        validate
+
+        response = soap_client.call(:lat_lon_list_subgrid, :message => build_message)
+        document = parse_xml(response)
+        transform_coordinate_list(document)
+      end
+
+      protected
+
+      def build_message
+        {
+          :lowerLeftLatitude   => conditions[:lower_left_coordinate][:latitude],
+          :lowerLeftLongitude  => conditions[:lower_left_coordinate][:longitude],
+          :upperRightLatitude  => conditions[:upper_right_coordinate][:latitude],
+          :upperRightLongitude => conditions[:upper_right_coordinate][:longitude],
+          :resolution          => conditions[:resolution]
+        }
+      end
+
+      def parse_xml(response)
+        Nokogiri::XML(response.body[:lat_lon_list_subgrid_response][:list_lat_lon_out])
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_linepoint_coordinates_query.rb

@@ -0,0 +1,33 @@
+module WeatherForecasts
+  class Client
+    class SelectLinepointCoordinatesQuery < Query
+      include QueryUtilities
+
+      property :start_coordinate, :type => Hash, :required => true, :required_keys => [:latitude, :longitude]
+      property :stop_coordinate,  :type => Hash, :required => true, :required_keys => [:latitude, :longitude]
+
+      def execute
+        validate
+
+        response = soap_client.call(:lat_lon_list_line, :message => build_message)
+        document = parse_xml(response)
+        transform_coordinate_list(document)
+      end
+
+      protected
+
+      def build_message
+        {
+          :endPoint1Lat => conditions[:start_coordinate][:latitude],
+          :endPoint1Lon => conditions[:start_coordinate][:longitude],
+          :endPoint2Lat => conditions[:stop_coordinate][:latitude],
+          :endPoint2Lon => conditions[:stop_coordinate][:longitude]
+        }
+      end
+
+      def parse_xml(response)
+        Nokogiri::XML(response.body[:lat_lon_list_line_response][:list_lat_lon_out])
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_query.rb

@@ -0,0 +1,48 @@
+module WeatherForecasts
+  class Client
+    class SelectQuery < Query
+      include QueryUtilities
+
+      set_selection_attributes *FORECAST_ELEMENTS.keys
+
+      property :coordinates, :type => Array, :required => true, :required_keys => [:latitude, :longitude]
+      property :product,     :type => String, :options => ["time-series", "glance"], :required => true, :default => "time-series"
+      property :unit,        :type => String, :options => ["e", "m"], :default => "e"
+
+      property :start_time,  :type => ActiveSupport::TimeWithZone
+      property :end_time,    :type => ActiveSupport::TimeWithZone
+
+      def execute
+        validate
+
+        response = soap_client.call(:ndf_dgen_lat_lon_list, :message => build_message)
+        document = Nokogiri::XML(response.body[:ndf_dgen_lat_lon_list_response][:dwml_out])
+        transform_to_hash(document)
+      end
+
+      protected
+
+      def transform_to_hash(doc)
+        WeatherForecasts::DWML.new(doc).process
+      end
+
+      def build_message
+        {
+          :listLatLon        => build_coordinates(conditions[:coordinates]),
+          :product           => conditions[:product],
+          :startTime         => conditions[:start_time].iso8601,
+          :endTime           => conditions[:end_time].iso8601,
+          :Unit              => conditions[:unit],
+          :weatherParameters => build_weather_parameters
+        }
+      end
+
+      def build_weather_parameters
+        available_selections.attributes.inject({}) do |memo, attr|
+          is_requested = select_attributes.include?(attr) ? 1 : 0
+          memo.merge!(attr => is_requested)
+        end
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/select_square_coordinates_query.rb

@@ -0,0 +1,35 @@
+module WeatherForecasts
+  class Client
+    class SelectSquareCoordinatesQuery < Query
+      include QueryUtilities
+
+      property :center_point, :type => Hash, :required => true, :required_keys => [:latitude, :longitude]
+      property :distance,     :type => Hash, :required => true, :required_keys => [:latitude, :longitude]
+      property :resolution,   :type => Numeric, :default => 5
+
+      def execute
+        validate
+
+        response = soap_client.call(:lat_lon_list_square, :message => build_message)
+        document = parse_xml(response)
+        transform_coordinate_list(document)
+      end
+
+      protected
+
+      def build_message
+        {
+          :centerPointLat => conditions[:center_point][:latitude],
+          :centerPointLon => conditions[:center_point][:longitude],
+          :distanceLat    => conditions[:distance][:latitude],
+          :distanceLon    => conditions[:distance][:longitude],
+          :resolution     => conditions[:resolution]
+        }
+      end
+
+      def parse_xml(response)
+        Nokogiri::XML(response.body[:lat_lon_list_square_response][:list_lat_lon_out])
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/query/selection_attributes.rb

@@ -0,0 +1,19 @@
+require 'active_support/core_ext/array/wrap'
+
+module WeatherForecasts
+  class Client
+    class SelectionAttributes
+      attr_reader :attributes
+
+      def initialize(attributes)
+        @attributes = Array.wrap(attributes)
+      end
+
+      def valid?(attr)
+        unless attributes.include?(attr)
+          raise InvalidSelectionAttributeError, "The selection attribute, `#{attr}`, is not a valid attribute on this query."
+        end
+      end
+    end
+  end
+end

data/lib/weather_forecasts/client/version.rb

@@ -0,0 +1,5 @@
+module WeatherForecasts
+  class Client
+    VERSION = "1.1.1"
+  end
+end

data/lib/weather_forecasts/dwml.rb

@@ -0,0 +1,38 @@
+require 'multi_json'
+
+require 'weather_forecasts/dwml/head_extractor'
+require 'weather_forecasts/dwml/data_extractor'
+
+#
+# Note: See http://graphical.weather.gov/xml/mdl/XML/Design/MDL_XML_Design.pdf
+# for authoritative type definitions
+################################################################################
+
+module WeatherForecasts
+  class DWML
+    attr_reader :output, :xmldoc
+
+    def initialize(xmldoc)
+      @xmldoc = xmldoc
+      @output = {}
+    end
+
+    def process
+      build_head
+      build_data
+      output
+    end
+
+    protected
+
+    def build_head
+      extractor = HeadExtractor.new(xmldoc.xpath("//dwml/head").first)
+      @output.merge!(extractor.process)
+    end
+
+    def build_data
+      extractor = DataExtractor.new(xmldoc.xpath("//dwml/data").first)
+      @output.merge!(extractor.process)
+    end
+  end
+end