geocaching 0.6.1 → 0.7.0

data/lib/geocaching/parsers/log.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require "nokogiri"
+require "time"
+
+module Geocaching
+  module Parsers
+    class Log
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def parse
+        logs = []
+
+        @doc.xpath("//xmlns:CacheLogDataSet/xmlns:CacheLog").each do |cache_log_node|
+          log = Geocaching::Log.new
+
+          private_methods.each do |method|
+            if method.to_s =~ /^parse_([a-z_]+)$/
+              value = send(method, cache_log_node)
+              log.send("#{$1}=", value) unless value.nil?
+            end
+          end
+
+          logs << log
+        end
+
+        logs
+      end
+
+    private
+
+      def parse_logged_at(cache_log_node)
+        if node = cache_log_node.xpath("./xmlns:DateLogged").first
+          begin
+            time = Time.parse(node.text)
+            Time.mktime(time.year, time.month, time.day)
+          rescue ArgumentError
+            raise ParseError, "Got an invalid log date from API"
+          end
+        else
+          raise ParseError, "Could not parse log date from XML"
+        end
+      end
+
+      def parse_created_at(cache_log_node)
+        if node = cache_log_node.xpath("./xmlns:Created").first
+          begin
+            time = Time.parse(node.text)
+            Time.mktime(time.year, time.month, time.day)
+          rescue ArgumentError
+            raise ParseError, "Got an invalid creation date from API"
+          end
+        else
+          raise ParseError, "Could not parse creation date from XML"
+        end
+      end
+
+      def parse_type(cache_log_node)
+        if node = cache_log_node.xpath("./xmlns:LogTypeName").first
+          if log_type = LogType.from_name(node.text)
+            log_type
+          else
+            raise ParseError, "Got an unknown log type from API"
+          end
+        else
+          raise ParseError, "Could not parse log type from XML"
+        end
+      end
+
+      def parse_user(cache_log_node)
+        user_guid_node = cache_log_node.xpath("./xmlns:UserGUID").first
+        user_name_node = cache_log_node.xpath("./xmlns:UserName").first
+
+        if user_guid_node and user_name_node
+          User.new(:guid => user_guid_node.text, :name => user_name_node.text)
+        else
+          raise ParseError, "Could not parse user from XML"
+        end
+      end
+
+      def parse_guid(cache_log_node)
+        if node = cache_log_node.xpath("./xmlns:GUID").first
+          node.text
+        else
+          raise ParseError, "Could not parse GUID from XML"
+        end
+      end
+
+      def parse_message(cache_log_node)
+        if node = cache_log_node.xpath("./xmlns:Note").first
+          node.text
+        else
+          raise ParseError, "Could not parse message from XML"
+        end
+      end
+    end
+  end
+end

data/lib/geocaching/parsers/trackable.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require "nokogiri"
+require "time"
+
+module Geocaching
+  module Parsers
+    class Trackable
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def parse
+        trackables = []
+
+        @doc.xpath("//xmlns:TravelBugDataSet/xmlns:TravelBug").each do |travel_bug_node|
+          trackable = Geocaching::Trackable.new
+
+          private_methods.each do |method|
+            if method.to_s =~ /^parse_([a-z_]+)$/
+              value = send(method, travel_bug_node)
+              trackable.send("#{$1}=", value) unless value.nil?
+            end
+          end
+
+          trackables << trackable
+        end
+
+        trackables
+      end
+
+    private
+
+      def parse_code(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:TrackingCode").first
+          node.text
+        else
+          raise ParseError, "Could not parse trackable code from XML"
+        end
+      end
+
+      def parse_guid(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:GUID").first
+          node.text
+        else
+          raise ParseError, "Could not parse trackable GUID from XML"
+        end
+      end
+
+      def parse_name(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:Name").first
+          node.text
+        else
+          raise ParseError, "Could not parse trackable name from XML"
+        end
+      end
+
+      def parse_goal(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:Goal").first
+          node.text
+        else
+          raise ParseError, "Could not parse trackable goal from XML"
+        end
+      end
+
+      def parse_description(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:Description").first
+          node.text
+        else
+          raise ParseError, "Could not parse trackable description from XML"
+        end
+      end
+
+      def parse_current_cache(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:CurrentCacheCode").first
+          Cache.new(:code => node.text) unless node.text.empty?
+        else
+          raise ParseError, "Could not parse trackable's current cache from XML"
+        end
+      end
+
+      def parse_current_user(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:CurrentHolderUserName").first
+          User.new(:name => node.text) unless node.text.empty?
+        else
+          raise ParseError, "Could not parse trackable's current user from XML"
+        end
+      end
+
+      def parse_owner(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:OwnerUserName").first
+          User.new(:name => node.text)
+        else
+          raise ParseError, "Could not parse trackable owner from XML"
+        end
+      end
+
+      def parse_type(travel_bug_node)
+        if node = travel_bug_node.xpath("./xmlns:TravelBugTypeName").first
+          TrackableType.new(node.text)
+        else
+          raise ParseError, "Could not parse trackable type from XML"
+        end
+      end
+    end
+  end
+end

data/lib/geocaching/session.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+require "cgi"
+require "net/http"
+
+require "geocaching/session/caches"
+require "geocaching/session/logs"
+require "geocaching/session/trackables"
+
+module Geocaching
+  class Session
+    class Response
+      attr_reader :data, :doc
+
+      def initialize(data)
+        @data = data
+        @doc = Nokogiri::XML.parse(@data, nil, "utf-8")
+      rescue
+        raise ParseError, "Could not parse response XML"
+      end
+
+      def status
+        @status ||= begin
+          if status_code_node = @doc.xpath("//xmlns:StatusDataSet/xmlns:Status/xmlns:StatusCode").first
+            status_code_node.text
+          end
+        end
+      end
+    end
+
+    attr_reader :username, :password, :license_key, :session_token
+    attr_accessor :timeout
+
+    API_HOST = "api.groundspeak.com"
+    API_BASE_PATH = "/mango/Services.asmx"
+
+    STATUS_SET_SESSION_TOKEN_XPATH = "//xmlns:StatusDataSet/xmlns:Status/xmlns:SessionGUID"
+    SESSION_TOKEN_XPATH = "//xmlns:SessionDataSet2/xmlns:Session2/xmlns:SessionGuid"
+
+    def self.open(username, password, license_key = nil)
+      session = new(username, password, license_key)
+      session.open
+      session
+    end
+
+    def initialize(username, password, license_key = nil)
+      @username    = username
+      @password    = password
+      @license_key = license_key || "e0dc6788-c880-4d3c-8903-3e2230650281"
+      @timeout     = 15
+    end
+
+    def open
+      @http ||= Net::HTTP.new(API_HOST, 443)
+      @http.use_ssl = true
+
+      response = request("OpenSession", {
+        "userName"   => @username,
+        "password"   => @password,
+        "licenseKey" => @license_key
+      })
+
+      if token_node = response.doc.xpath(STATUS_SET_SESSION_TOKEN_XPATH).first
+        @session_token = token_node.text
+      elsif token_node = response.doc.xpath(SESSION_TOKEN_XPATH).first
+        @session_token = token_node.text
+      else
+        raise ParseError, "Could not parse response from OpenSession"
+      end
+    end
+
+    def open?
+      @session_token != nil
+    end
+
+    def close
+      response = request("CloseSession", {
+        "sessionToken" => @session_token,
+        "licenseKey"   => @license_key
+      })
+
+      if response.status and response.status == "Ok"
+        @session_token = nil
+      end
+
+      !open?
+    end
+
+    def request(action, params = {})
+      resp, data = nil, nil
+
+      query_string = params.map { |(k, v)|
+        "#{CGI::escape(k.to_s)}=#{CGI::escape(v.to_s)}"
+      }.join("&")
+
+      path = "#{API_BASE_PATH}/#{action}?#{query_string}"
+
+      begin
+        Timeout::timeout(@timeout) do
+          resp, data = @http.get(path)
+        end
+      rescue Timeout::Error
+        raise TimeoutError, "Timeout hit for action #{action}"
+      rescue => e
+        raise HTTPError, e.message
+      end
+
+      unless resp.kind_of?(Net::HTTPSuccess)
+        raise HTTPError, "Got a non-successful HTTP response for action #{action}"
+      end
+
+      Response.new(data)
+    end
+
+    include Geocaching::Session::Caches
+    include Geocaching::Session::Logs
+    include Geocaching::Session::Trackables
+  end
+end

data/lib/geocaching/session/caches.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Geocaching
+  class Session
+    module Caches
+      def get_cache_by_code(code, options = {})
+        schema = case options[:format]
+        when :simple
+          "CacheSimpleDataSet.xsd"
+        when :gpx
+          "CacheGPXDataSet.xsd"
+        else
+          "CacheSimpleDataSet.xsd"
+        end
+
+        response = request("GetCacheByCacheCode", {
+          "sessionToken" => session_token,
+          "schemaName"   => schema,
+          "cacheCode"    => code
+        })
+
+        case schema
+        when "CacheSimpleDataSet.xsd"
+          caches = Cache.from_xml(response.doc)
+          caches.first if caches.size == 1
+        when "CacheGPXDataSet.xsd"
+          Cache.from_gpx(response.doc)
+        end
+      end
+
+      def get_caches_by_point(latitude, longitude, options = {})
+        response = request("GetCachesByPoint", {
+          "sessionToken"       => session_token,
+          "schemaName"         => "CacheSimpleDataSet.xsd",
+          "cacheTypeNamesList" => nil,
+          "latitude"           => latitude,
+          "longitude"          => longitude,
+          "radiusMiles"        => (options[:radius] || 10) * 0.621371192,
+          "startPos"           => options[:start_pos] || 0,
+          "endPos"             => options[:end_pos] || 500
+        })
+
+        Cache.from_xml(response.doc)
+      end
+
+      def get_caches_by_postal_code(postal_code, options = {})
+        response = request("GetCachesByPostalCode", {
+          "sessionToken"       => session_token,
+          "schemaName"         => "CacheSimpleDataSet.xsd",
+          "cacheTypeNamesList" => nil,
+          "postalCode"         => postal_code,
+          "radiusMiles"        => (options[:radius] || 10) * 0.621371192,
+          "startPos"           => options[:start_pos] || 0,
+          "endPos"             => options[:end_pos] || 500
+        })
+
+        Cache.from_xml(response.doc)
+      end
+    end
+  end
+end

data/lib/geocaching/session/logs.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Geocaching
+  class Session
+    module Logs
+      def get_logs_for_cache_by_cache_code(cache_code)
+        response = request("GetCacheLogsByCacheCode", {
+          "sessionToken"      => session_token,
+          "cacheCode"         => cache_code,
+          "cacheLogTypeNames" => nil
+        })
+
+        Log.from_xml(response.doc)
+      end
+    end
+  end
+end

data/lib/geocaching/session/trackables.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Geocaching
+  class Session
+    module Trackables
+      def get_trackable_by_code(trackable_code)
+        response = request("GetTravelBugByTrackingNumber", {
+          "sessionToken"   => session_token,
+          "trackingNumber" => trackable_code
+        })
+
+        trackables = Trackable.from_xml(response.doc)
+        trackables.first if trackables.size == 1
+      end
+
+      def get_trackables_in_cache_by_cache_code(cache_code)
+        response = request("GetTravelBugsByCacheCode", {
+          "sessionToken" => session_token,
+          "cacheCode"    => cache_code
+        })
+
+        Trackable.from_xml(response.doc)
+      end
+    end
+  end
+end

data/lib/geocaching/trackable.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require "geocaching/parsers/trackable"
+
+module Geocaching
+  class Trackable
+    attr_accessor :code
+    attr_accessor :guid
+    attr_accessor :name
+    attr_accessor :goal
+    attr_accessor :description
+    attr_reader   :type
+    attr_reader   :owner
+    attr_reader   :current_cache
+    attr_reader   :current_user
+
+    def self.from_xml(doc)
+      Parsers::Trackable.new(doc).parse
+    end
+
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        if respond_to?("#{key}=")
+          send("#{key}=", value)
+        else
+          raise ArgumentError, "Unknown attribute `#{key}'"
+        end
+      end
+    end
+
+    def type=(trackable_type)
+      if trackable_type.kind_of?(Geocaching::TrackableType)
+        @type = trackable_type
+      else
+        raise TypeError, "`type' must be an instance of Geocaching::TrackableType"
+      end
+    end
+
+    def owner=(user)
+      if user.kind_of?(Geocaching::User)
+        @owner = user
+      else
+        raise TypeError, "`owner' must be an instance of Geocaching::User"
+      end
+    end
+
+    def current_cache=(cache)
+      if cache.kind_of?(Geocaching::Cache)
+        @current_cache = cache
+      else
+        raise TypeError, "`current_cache' must be an instance of Geocaching::Cache"
+      end
+    end
+
+    def current_user=(user)
+      if user.kind_of?(Geocaching::User)
+        @current_user = user
+      else
+        raise TypeError, "`current_user' must be an instance of Geocaching::User"
+      end
+    end
+
+    def to_hash
+      {
+        :code          => code,
+        :guid          => guid,
+        :name          => name,
+        :type          => type,
+        :goal          => goal,
+        :description   => description,
+        :owner         => owner,
+        :current_cache => current_cache,
+        :current_user  => current_user
+      }
+    end
+  end
+end