Active 0.0.42 → 0.1.7

data/lib/services/reg_center.rb

@@ -1,270 +0,0 @@
-module Active
-  module Services
-
-    class RegCenterError < StandardError;  end
-
-    class RegCenter < IActivity
-      require 'nokogiri'
-      require 'open-uri'
-      require 'digest/sha1'
-      attr_accessor :asset_type_id
-      
-#      attr_reader :metadata_loaded
-      # EXAMPLE Data hash
-      # {:asset_id=>"A9EF9D79-F859-4443-A9BB-91E1833DF2D5", :substitution_url=>"1878023", :asset_type_name=>"Active.com Event Registration",
-      # :asset_name=>"Fitness, Pilates  Mat Class (16 Yrs. &amp; Up)", :url=>"http://www.active.com/page/Event_Details.htm?event_id=1878023",
-      # :asset_type_id=>"EA4E860A-9DCD-4DAA-A7CA-4A77AD194F65", :xmlns=>"http://api.asset.services.active.com"}
-
-      def initialize(data={})
-        @data = HashWithIndifferentAccess.new(data) || HashWithIndifferentAccess.new
-        @asset_type_id = "EA4E860A-9DCD-4DAA-A7CA-4A77AD194F65"
-      end
-
-      def source
-        :reg_center
-      end
-
-      def title
-        if @data.has_key?("event") && @data["event"].has_key?("eventName")
-          cleanup_reg_string(@data["event"]["eventName"])
-        end
-      end
-      
-      def event_image_url
-        if @data.has_key?("event") && @data["event"].has_key?("eventImageUrl")
-          @data["event"]["eventImageUrl"]
-        end
-      end
-
-      def url
-        if @data.has_key?("event") && @data["event"].has_key?("eventDetailsPageUrl")
-          @data["event"]["eventDetailsPageUrl"]
-        elsif @data.has_key?("event") && @data["event"].has_key?("registrationUrl")
-          @data["event"]["registrationUrl"]
-        elsif @data.has_key?("event") && @data["event"].has_key?("eventContactUrl")
-          @data["event"]["eventContactUrl"]
-        end
-      end
-      
-      def registration_url
-        if @data.has_key?("event") && @data["event"].has_key?("registrationUrl")
-          @data["event"]["registrationUrl"]
-        else
-          ""
-        end
-      end
-      
-      def event_url
-        @data[:event][:eventUrl]
-      end
-      
-      def categories
-        if @data.has_key?("event") && @data["event"].has_key?("channels") && @data["event"]["channels"]!=nil && @data["event"]["channels"].has_key?("channel") && @data["event"]["channels"]["channel"]!=nil
-          channels = @data["event"]["channels"]["channel"]
-          if channels.class==Array
-            @data["event"]["channels"]["channel"].collect {|e| e["channelName"]}          
-          else
-            #hash
-            [channels["channelName"]]
-          end
-        end
-      end
-      
-      def asset_id
-        if @data.has_key?("event") && @data["event"].has_key?("assetID")
-          @data["event"]["assetID"]
-        end
-      end
-      
-      def primary_category
-        if @data["event"]["channels"]["channel"]!=nil
-          channels = @data["event"]["channels"]["channel"]
-          if channels.class==Array
-            channels.each do |c|
-              return c["channelName"] if c.has_key?("primaryChannel") && c["primaryChannel"]=="true"
-            end
-            nil
-          else
-            #hash
-            return channels["channelName"] if channels.has_key?("primaryChannel") && channels["primaryChannel"]=="true"
-            return nil
-          end
-        end
-      end
-
-      def address
-        @address = validated_address({
-          :name    => @data["event"]["eventLocation"],
-          :address => @data["event"]["eventAddress"],
-          :city    => @data["event"]["eventCity"],
-          :state   => @data["event"]["eventState"],
-          :zip     => @data["event"]["eventZip"],
-          :lat     => @data["event"]["latitude"],
-          :lng     => @data["event"]["longitude"],
-          :country => @data["event"]["eventCountry"]
-        } )
-      end
-
-      def start_date
-        DateTime.parse @data["event"]["eventDate"] if @data.has_key?("event") && @data["event"].has_key?("eventDate")
-      end
-
-      def start_time
-        start_date
-      end
-
-      def end_time
-        nil
-      end
-
-      def end_date
-        nil
-      end
-      # The date and time that registration closes
-      def registration_close_date
-        DateTime.parse(@data["event"]["eventCloseDate"])
-      end
-
-      def category
-        primary_category
-      end
-      
-      def user
-        email        = contact_email
-        u            = User.new
-        u.email      = email if Validators.email(email)
-#        u.first_name = @data["meta"]["contactName"] || nil
-#        u.phone      = @data["meta"]["contactPhone"] || nil
-        u
-      end
-
-      def desc_old
-        if @data.has_key?("event") && @data["event"].has_key?("briefDescription")
-          ret = @data["event"]["briefDescription"]
-          if @data["event"].has_key?("eventDetails")  && @data["event"]["eventDetails"] != nil && @data["event"]["eventDetails"].has_key?("eventDetail")
-            eventDetail = @data["event"]["eventDetails"]["eventDetail"]
-            if eventDetail.class == Array
-              @data["event"]["eventDetails"]["eventDetail"].each do |detail|
-                ret +="<div><b>" + detail["eventDetailsName"] + ":</b> " + cleanup_reg_string(detail["eventDetailsValue"]) + "</div>"
-              end
-            else
-              #hash
-              ret +="<div><b>" + eventDetail["eventDetailsName"] + ":</b> " + cleanup_reg_string(eventDetail["eventDetailsValue"]) + "</div>"
-            end
-          end
-          return ret
-        elsif @data.has_key?("event") && @data["event"].has_key?("eventDescription")
-          return @data["event"]["eventDescription"]
-        end
-      end
-      
-      def desc(length = :full)
-        if length == :full
-          @data["event"]["eventDescription"]
-        else
-          @data["event"]["briefDescription"]
-        end
-      end
-      
-      # Content should be a array of hashes.
-      # [ {:title => "briefDescription", :type => "html", :content => "..." }]
-      #
-      # It should contain everything in briefDescription description and eventDetails.
-      # It should just be one big happy 
-      # 
-      # TODO: Need to order this by detail[:eventDetailsOrder]
-      # TODO: Add the other description blocks to this 
-      def content
-        if @data["event"] and @data["event"]["eventDetails"] 
-
-          if @data["event"]["eventDetails"]["eventDetail"].class == Array
-            return @data["event"]["eventDetails"]["eventDetail"].collect { |obj| {:title => obj[:eventDetailsName], :content => obj[:eventDetailsValue]} } 
-          else
-            return [{:title => @data["event"]["eventDetails"]["eventDetail"]["eventDetailsName"],:content => @data["event"]["eventDetails"]["eventDetail"]["eventDetailsValue"]}]
-          end
-          
-        else
-          return []
-        end
-      end
-      
-      def cleanup_reg_string(input)
-        input.gsub("\r","").gsub("\n","").gsub("\"","""").gsub("\342\200\234","""").gsub("\342\200\235","""")
-      end
-
-      def contact_email
-        if @data.has_key?("event") && @data["event"].has_key?("eventContactEmail")
-          return @data["event"]["eventContactEmail"]
-        end
-      end
-
-
-      # EXAMPLE
-      # lazy load the data for some_crazy_method
-      # def some_crazy
-      #   return @some_crazy unless @some_crazy.nil?
-      #   @some_crazy = @data[:some_crazy_method_from_ats].split replace twist bla bla bla
-      # end
-      # local id
-      def self.find_by_id(id) 
-        begin
-          doc  = Nokogiri::XML(open("http://apij.active.com/regcenter/event/#{id}"))
-          puts "////////<br/>"
-          puts doc.to_s
-          puts "////////<br/>"
-          reg  = RegCenter.new(Hash.from_xml(doc.to_s))
-        rescue Exception => e
-          raise RegCenterError, "Couldn't find Reg Center activity with the id of #{id} - #{e.inspect}"
-          return nil
-        end
-        reg
-      end
-
-
-      def self.get_asset_metadata(id)
-        c = Savon::Client.new("http://api.amp.active.com/asset-service/services/AssetService?wsdl")
-        c.request.headers["Api-Key"] = "6npky9t57235vps5cetm3s7k"
-        r = c.get_asset_metadata do |soap|
-          soap.namespace = "http://api.asset.services.active.com"
-          soap.body = "<context><userId></userId><applicationId></applicationId></context><assetId>#{id}</assetId>"
-        end
-        puts "==========="
-        puts r.to_hash[:get_asset_metadata_response][:out].inspect
-        return r
-      end
-
-
-      private
-      # def self.get_asset_by_id(id)
-      #   puts "loading ATS"
-      #   c = Savon::Client.new("http://api.amp.active.com/asset-service/services/AssetService")
-      #   c.request.headers["Api-Key"] = "6npky9t57235vps5cetm3s7k"
-      #   r = c.get_asset_by_id! do |soap|
-      #     soap.namespace = "http://api.asset.services.active.com"
-      #     soap.body = "<context><userId></userId><applicationId></applicationId></context><assetId>#{id}</assetId>"
-      #   end
-      #   return r
-      # end
-      # 
-      # def load_metadata
-      #   puts "loading ATS metadata"
-      #   metadata = ATS.get_asset_metadata(@asset_id)
-      #   @data.merge! Hash.from_xml(metadata.to_hash[:get_asset_metadata_response][:out])["importSource"]["asset"]
-      #   @metadata_loaded=true
-      # end
-      
-      # def get_app_api
-      #   puts "loading reg center api"
-      #   begin
-      #     doc = Nokogiri::XML(open("http://apij.active.com/regcenter/event/#{@data[:id]}"))
-      #     @data.merge! Hash.from_xml doc.to_s
-      #     @api_data_loaded=true
-      #   rescue
-      #     raise RegCenterError, "Couldn't find Reg Center activity with the id of #{id}"
-      #     return
-      #   end
-      # end
-
-    end # end ats
-  end
-end

data/lib/services/sanitize.rb

@@ -1,108 +0,0 @@
-# http://wonko.com/post/sanitize
-
-# $Id: sanitize.rb 3 2005-04-05 12:51:14Z dwight $
-#
-# Copyright (c) 2005 Dwight Shih
-# A derived work of the Perl version:
-# Copyright (c) 2002 Brad Choate, bradchoate.com
-# 
-# Permission is hereby granted, free of charge, to
-# any person obtaining a copy of this software and
-# associated documentation files (the "Software"), to
-# deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify,
-# merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to
-# whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission
-# notice shall be included in all copies or
-# substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY
-# OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
-# LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
-# OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-# OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-#
-
-def sanitize( html, okTags='a href, b, br, i, p' )
-  # no closing tag necessary for these
-  soloTags = ["br","hr"]
-
-  # Build hash of allowed tags with allowed attributes
-  tags = okTags.downcase().split(',').collect!{ |s| s.split(' ') }
-  allowed = Hash.new
-  tags.each do |s|
-    key = s.shift
-    allowed[key] = s
-  end
-
-  # Analyze all <> elements
-  stack = Array.new
-  result = html.gsub( /(<.*?>)/m ) do | element |
-    if element =~ /\A<\/(\w+)/ then
-      # </tag>
-      tag = $1.downcase
-      if allowed.include?(tag) && stack.include?(tag) then
-        # If allowed and on the stack
-        # Then pop down the stack
-        top = stack.pop
-        out = "</#{top}>"
-        until top == tag do
-          top = stack.pop
-          out << "</#{top}>"
-        end
-        out
-      end
-    elsif element =~ /\A<(\w+)\s*\/>/
-      # <tag />
-      tag = $1.downcase
-      if allowed.include?(tag) then
-        "<#{tag} />"
-      end
-    elsif element =~ /\A<(\w+)/ then
-      # <tag ...>
-      tag = $1.downcase
-      if allowed.include?(tag) then
-        if ! soloTags.include?(tag) then
-          stack.push(tag)
-        end
-        if allowed[tag].length == 0 then
-          # no allowed attributes
-          "<#{tag}>"
-        else
-          # allowed attributes?
-          out = "<#{tag}"
-          while ( $' =~ /(\w+)=("[^"]+")/ )
-            attr = $1.downcase
-            valu = $2
-            if allowed[tag].include?(attr) then
-              out << " #{attr}=#{valu}"
-            end
-          end
-          out << ">"
-        end
-      end
-    end
-  end
-  
-  # eat up unmatched leading >
-  while result.sub!(/\A([^<]*)>/m) { $1 } do end
-  
-  # eat up unmatched trailing <
-  while result.sub!(/<([^>]*)\Z/m) { $1 } do end
-  
-  # clean up the stack
-  if stack.length > 0 then
-    result << "</#{stack.reverse.join('></')}>"
-  end
-
-  result
-end

data/lib/services/search.rb

@@ -1,494 +0,0 @@
-require 'net/http'
-require 'json'
-require 'cgi'
-require 'mysql' 
-require 'active_record'
-require 'digest/md5'
-
-module Active
-  module Services
-    
-    # we should remove this class and just replace with symbols
-    class Sort
-      def self.DATE_ASC 
-        "date_asc"
-      end
-      def self.DATE_DESC
-        "date_desc"
-      end
-      def self.RELEVANCE
-        "relevance"
-      end
-    end
-
-    # we should remove this class and just replace with symbols    
-    class Facet
-      def self.ACTIVITIES
-        "activities"
-      end
-    end
-
-    class Search
-      attr_accessor :api_key, :start_date, :end_date, :location, :channels, :split_media_type, :keywords, :search, :radius, :limit, :sort, :page, :offset, :latitude, :longitude,
-                    :asset_type_id, :url,
-                    :view, :facet, :sort, :num_results, :asset_ids, :dma, :city, :state, :country, :bounding_box
-                    
-      attr_reader :results, :endIndex, :pageSize, :searchTime, :numberOfResults, :end_point, :meta
-       
-      SEARCH_URL      = "http://search.active.com"
-      DEFAULT_TIMEOUT = 60
-      
-      def initialize(data={})
-        self.asset_type_id    = data[:asset_type_id]
-        self.url              = data[:url]
-        self.api_key          = data[:api_key] || ""
-        self.location         = data[:location]
-        self.zips             = data[:zips] || []
-        self.channels         = data[:channels] || []
-        self.split_media_type = data[:split_media_type] || []
-        self.keywords         = data[:keywords] || []
-        self.radius           = data[:radius] || nil
-        self.limit            = data[:limit] || "10"
-        self.sort             = data[:sort] || Sort.DATE_ASC
-        self.page             = data[:page] || "1"
-        self.offset           = data[:offset] || "0"
-        self.view             = data[:view] || "json"
-        self.facet            = data[:facet] || Facet.ACTIVITIES       
-        self.num_results      = data[:num_results] || "10"
-        self.search           = data[:search] || ""
-        self.start_date       = data[:start_date] || "today"
-        self.end_date         = data[:end_date] || "+"        
-        self.asset_ids        = data[:asset_ids] || []
-        self.asset_id         = data[:asset_id] || ""
-        self.latitude         = data[:latitude]
-        self.longitude        = data[:longitude]
-        self.dma              = data[:dma]
-        self.city             = data[:city]
-        self.state            = data[:state]
-        self.country          = data[:country]
-        self.bounding_box     = data[:bounding_box]
-      end
-      
-      # Example
-      # Search.search( {:zips => "92121, 92078, 92114"} )
-      # or
-      # Search.new( {:zips => [92121, 92078, 92114]} )
-      def zips=(value)
-        if value.class == String
-          @zips = value.split(",").each { |k| k.strip! }
-        else
-          @zips = value
-        end        
-      end
-      
-      def zips
-        @zips
-      end
-      
-      def location=(value)
-        return if value.nil?
-        @location = CGI.escape(value)
-      end
-      
-      def keywords=(value)
-        if value.class == String
-          @keywords = value.gsub(",", " ").split(" ").each { |k| k.strip! }
-        else
-          @keywords = value
-        end
-      end     
-      
-      def channels=(value)
-        if value.class == String
-          @channels = value.split(",").each { |k| k.strip! }
-        else
-          @channels = value
-        end
-      end
-      
-      def asset_ids=(value)
-        @asset_ids = value
-      end
-      
-      def bounding_box=(value)
-        return if value==nil
-        value = HashWithIndifferentAccess.new(value)
-        if value.has_key?("sw") && value.has_key?("ne")
-          @bounding_box=value
-        else
-          raise "bounding_box must be hash with keys sw and ne"
-        end
-      end
-
-      def asset_id=(value)
-        return if value.empty?
-        @asset_ids<<value
-      end
-      
-      def end_point
-        meta_data = ""
-        loc_str   = ""
-        # CHANNELS
-        channel_keys = []
-        @channels.each do |c|
-          c = c.to_sym
-          if Categories.CHANNELS.include?(c)
-            channel_keys << Categories.CHANNELS[c]
-          else
-            puts "///////////  Channel key not found [#{c}]"
-          end
-        end
-        meta_data += channel_keys.collect { |channel| "meta:channel=#{Search.double_encode_channel(channel)}" }.join("+OR+")
-        # SPLIT MEDIA TYPE
-        if split_media_type
-          meta_data += "+AND+" unless meta_data == ""
-          meta_data += split_media_type.collect { |type| "meta:splitMediaType=#{Search.double_encode_channel(type)}" }.join("+OR+")           
-        end
-        # ASSET TYPE ID
-        if asset_type_id
-          meta_data += "+AND+" unless meta_data == ""
-          meta_data += "meta:assetTypeId=#{Search.double_encode_channel(asset_type_id)}" 
-        end
-        # url
-        if url
-          meta_data += "+AND+" unless meta_data == ""
-          # url.gsub!(/\-/,"%252D")
-          url.gsub!(/\//,"%2F")
-          # URI.escape(url, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-          meta_data += "site:#{url}"
-          # meta_data += "site:#{Search.double_encode_channel(url)}"
-        end
-        # ASSET IDS
-        unless asset_ids.empty?
-          meta_data += "+AND+" unless meta_data == ""
-          temp_ids = []
-          asset_ids.each do |id|
-            temp_ids << "meta:" + CGI.escape("assetId=#{id.gsub("-","%2d")}")
-          end        
-          meta_data += temp_ids.join("+OR+")          
-        end
-        # LOCATION
-        # 1 Look for :city, :state, :country
-        # 2 Look for zip codes
-        # 3 Look for lat lng
-        # 4 Look for a formatted string "San Diego, CA, US"
-        # 5 Look for a dma
-        if @city or @state or @country
-          if @city
-            meta_data += "+AND+" unless meta_data == ""
-            meta_data += "meta:city=#{Search.double_encode_channel(@city)}"
-          end
-          if @state
-            meta_data += "+AND+" unless meta_data == ""
-            meta_data += "meta:state=#{Search.double_encode_channel(@state)}"         
-          end
-        elsif !@zips.empty?
-          loc_str = @zips.join(",")          
-        elsif @latitude and @longitude
-          loc_str = "#{@latitude};#{@longitude}"
-        elsif @dma
-          meta_data += "+AND+" unless meta_data == ""
-          meta_data += "meta:dma=#{Search.double_encode_channel(@dma)}"
-        else
-          loc_str = @location
-        end
-        
-        # BOUNDING BOX
-        unless @bounding_box.nil?
-          #The values in the GSA metadata are shifted to  prevent negative values.  This was done b/c lat/long
-          # are searched as a number range and the GSA doesn't allow negative values in number ranges.  
-          # We shift latitude values by 90 and longitude values by 180.
-          if @bounding_box[:sw].class==String
-            #String :bounding_box => { :sw => "37.695141,-123.013657", :ne => "37.832371,-122.356979"}
-            latitude1 = @bounding_box[:sw].split(",").first.to_f+90
-            latitude2 = @bounding_box[:ne].split(",").first.to_f+90
-            longitude1 = @bounding_box[:sw].split(",").last.to_f+180
-            longitude2 = @bounding_box[:ne].split(",").last.to_f+180
-          else 
-            #hash query[:bounding_box] = { :sw => [123, 10], :ne => [222,10] }
-            latitude1 = @bounding_box[:sw].first.to_f+90
-            latitude2 = @bounding_box[:ne].first.to_f+90
-            longitude1 = @bounding_box[:sw].last.to_f+180
-            longitude2 = @bounding_box[:ne].last.to_f+180
-          end
-          meta_data += "+AND+" unless meta_data == ""
-          meta_data += "meta:latitudeShifted:#{latitude1}..#{latitude2}+AND+meta:longitudeShifted:#{longitude1}..#{longitude2}"
-        end        
-        
-        # AND DATE
-        if @start_date.class == Date
-          @start_date = URI.escape(@start_date.strftime("%m/%d/%Y")).gsub(/\//,"%2F")
-        end
-        if @end_date.class == Date
-          @end_date = URI.escape(@end_date.strftime("%m/%d/%Y")).gsub(/\//,"%2F")
-        end
-        meta_data += "+AND+" unless meta_data == ""
-        meta_data += "meta:startDate:daterange:#{@start_date}..#{@end_date}"
-                
-        # url = "#{SEARCH_URL}/search?api_key=#{@api_key}&num=#{@num_results}&page=#{@page}&l=#{loc_str}&f=#{@facet}&v=#{@view}&r=#{@radius}&s=#{@sort}&k=#{@keywords.join("+")}&m=#{meta_data}"
-        urla = ["#{SEARCH_URL}/search?api_key=#{@api_key}"]
-        urla << "num=#{@num_results}" if @num_results
-        urla << "page=#{@page}" if @page
-        urla << "l=#{loc_str}" unless loc_str.nil? or loc_str.empty?
-        urla << "f=#{@facet}" if @facet 
-        urla << "v=#{@view}" if @view
-        urla << "r=#{@radius}" if @radius
-        urla << "s=#{@sort}" if @sort
-        urla << "k=#{@keywords.join("+")}" if @keywords and !@keywords.empty? 
-        urla << "m=#{meta_data}" if meta_data
-
-        return urla.join("&")
-      end
-      
-      # TODO the seach method should not raise an error.
-      def search
-        searchurl         = URI.parse(end_point)
-        req               = Net::HTTP::Get.new(searchurl.path)
-        http              = Net::HTTP.new(searchurl.host, searchurl.port)
-        http.read_timeout = DEFAULT_TIMEOUT
-        
-        puts "Active Search [GET] #{"#{searchurl.path}?#{searchurl.query}"}"
-        res = http.start { |http|
-          http.get("#{searchurl.path}?#{searchurl.query}")
-        }
-        
-        if (200..307).include?(res.code.to_i)          
-          begin
-            parsed_json      = JSON.parse(res.body)
-            @endIndex        = parsed_json["endIndex"]
-            @pageSize        = parsed_json["pageSize"]
-            @searchTime      = parsed_json["searchTime"]
-            # GSA will only return 1000 events but will give us a number larger then 1000.
-            @numberOfResults = (parsed_json["numberOfResults"] <= 1000) ? parsed_json["numberOfResults"] : 1000
-            @results         = parsed_json['_results'].collect { |a| Activity.new(GSA.new(a)) }  
-
-            begin
-              Active.CACHE.set( Digest::MD5.hexdigest(end_point), self) if Active.CACHE
-            rescue Exception => e              
-            end
-
-          rescue JSON::ParserError => e
-            raise RuntimeError, "JSON::ParserError json=#{res.body}"
-            @endIndex        = 0
-            @pageSize        = 0
-            @searchTime      = 0
-            @numberOfResults = 0
-            @results         = []             
-          end
-          
-        else
-          raise RuntimeError, "Active Search responded with a #{res.code} for your query."
-        end
-      end
-      
-      # examples
-      #
-      #
-      # = Keywords = 
-      # Keywords can be set like this
-      # Search.new({:keywords => "Dog,Cat,Cow"})
-      # Search.new({:keywords => %w(Dog Cat Cow)})
-      # Search.new({:keywords => ["Dog","Cat","Cow"]})
-      #
-      # = Channels and MediaType =
-      # Search.new({:channels => [:running], :split_media_type => ["5k"]})
-      # for a list of channels and splitMediaTypes please see http://developer.active.com/docs/Activecom_Search_API_Reference
-      #
-      # = Location =
-      # The location will be set in this order and will override other values.  For example is you set a zip code and a location only the zip will be used. 
-      #
-      # 1 Look for zip codes
-      #      Search.search( {:zips => "92121, 92078, 92114"} )
-      #      Search.search( {:zips => %w(92121, 92078, 92114)} )
-      #      Search.search( {:zips => [92121, 92078, 92114]} )
-      #
-      # 2 Look for lat lng
-      #      Search.search( {:latitude=>"37.785895", :longitude=>"-122.40638"} )
-      #
-      # 3 Look for a formatted string "San Diego, CA, US"
-      #       Search.search( {:location = "San Diego, CA, US"} )
-      #
-      # 4 Look for a DMA
-      #       Search.new({:dma=>"San Francisco - Oakland - San Jose"})
-      #
-      # = How to look at the results =
-      #
-      #
-      # http://developer.active.com/docs/Activecom_Search_API_Reference
-      # returns an array of results and query info
-      def self.search(data=nil)
-        search      = Search.new(data)
-        search_hash = Digest::MD5.hexdigest(search.end_point)
-        puts "search_hash #{search_hash}"
-        cache = Search.return_cached(search_hash)
-        if cache != nil
-          return cache
-        else
-          search.search
-          return search  
-        end
-      end
-
-      def self.return_cached key
-        if Active.CACHE
-          begin
-            cached_version = Active.CACHE.get(key)
-          rescue Exception => e
-            return nil
-          end
-          
-          
-          
-          if cached_version
-            puts "Active Search [CACHE] #{key}"
-            return cached_version 
-          end
-        end
-        nil
-      end
-
-      
-      def []
-        @results
-      end
-      
-      private
-        def self.double_encode_channel str
-          str = URI.escape(str, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-          str = URI.escape(str, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-          str.gsub!(/\-/,"%252D")
-          str
-        end
-    end
-    
-    # TODO move to a reflection service
-    class Categories
-      def self.CHANNELS 
-        {
-          :active_lifestyle => '',
-          :fitness => 'Fitness',
-          :body_building => 'Fitness\Body Building',
-          :boxing => 'Fitness\Boxing',
-          :weight_lifting => 'Fitness\Weight Lifting',
-          :gear => 'Gear',
-          :lifestyle_vehicles => 'Lifestyle Vehicles',
-          :mind_mody => 'Mind & Body',
-          :meditation => 'Mind & Body\Meditation',
-          :pilates => 'Mind & Body\Pilates',
-          :yoga => 'Mind & Body\Yoga',
-          :nutrition => 'Nutrition',
-          :travel => 'Travel',
-          :women => 'Women',
-          :other => 'Other',
-          :corporate => 'Corporate',
-          :not_specified => 'Not Specified',
-          :unknown => 'Unknown',
-          :special_interest => 'Special+Interest',
-          :giving => 'Giving',
-          :parks_recreation => 'Parks & Recreation',
-          :gear => 'Parks & Recreation\Gear',
-          :mind_body => 'Parks & Recreation\Mind & Body',
-          :travel => 'Parks & Recreation\Travel',
-          :vehicles => 'Parks & Recreation\Vehicles',
-          :women => 'Parks & Recreation\Women',
-          :reunions => 'Reunions',
-          :sports => 'Sports',
-          :action_sports => 'Action Sports',
-          :auto_racing => 'Action Sports\Auto Racing',
-          :bmx => 'Action Sports\BMX',
-          :dirt_bike_racing => 'Action Sports\Dirt Bike Racing',
-          :motocross => 'Action Sports\Motocross',
-          :motorcycle_racing => 'Action Sports\Motorcycle Racing',
-          :skateboarding => 'Action Sports\Skateboarding',
-          :skydiving => 'Action Sports\Skydiving',
-          :surfing => 'Action Sports\Surfing',
-          :wake_kite_boarding => 'Action Sports\Wake/Kite Boarding',
-          :water_skiing => 'Action Sports\Water Skiing',
-          :wind_surfing => 'Action Sports\Wind Surfing',
-          :baseball => 'Baseball',
-          :little_league_baseball => 'Baseball\Little League Baseball',
-          :tee_ball => 'Baseball\Tee Ball',
-          :basketball => 'Basketball',
-          :cheerleading => 'Cheerleading',
-          :cycling => 'Cycling',
-          :field_hockey => 'Field Hockey',
-          :football => 'Football',
-          :flag_football => 'Football\Flag Football',
-          :football_au => 'Football\Football-AU',
-          :golf => 'Golf',
-          :ice_hockey => 'Ice Hockey',
-          :lacrosse => 'Lacrosse',
-          :more_sports => 'More Sports',
-          :adventure_racing => 'More Sports\Adventure Racing',
-          :archery => 'More Sports\Archery',
-          :badminton => 'More Sports\Badminton',
-          :billiards => 'More Sports\Billiards',
-          :bowling => 'More Sports\Bowling',
-          :cricket => 'More Sports\Cricket',
-          :croquet => 'More Sports\Croquet',
-          :curling => 'More Sports\Curling',
-          :dance => 'More Sports\Dance',
-          :disc_sports => 'More Sports\Disc Sports',
-          :dodgeball => 'More Sports\Dodgeball',
-          :duathlon => 'More Sports\Duathlon',
-          :equestrian => 'More Sports\Equestrian',
-          :fencing => 'More Sports\Fencing',
-          :figure_skating => 'More Sports\Figure Skating',
-          :gymnastics => 'More Sports\Gymnastics',
-          :inline_hockey => 'More Sports\Inline Hockey',
-          :inline_skating => 'More Sports\Inline Skating',
-          :kickball => 'More Sports\Kickball',
-          :martial_arts => 'More Sports\Martial Arts',
-          :paintball => 'More Sports\Paintball',
-          :polo => 'More Sports\Polo',
-          :racquetball => 'More Sports\Racquetball',
-          :rowing => 'More Sports\Rowing',
-          :rugby => 'More Sports\Rugby',
-          :scouting => 'More Sports\Scouting',
-          :scuba_diving => 'More Sports\Scuba Diving',
-          :skating => 'More Sports\Skating',
-          :squash => 'More Sports\Squash',
-          :ultimate_frisbee => 'More Sports\Ultimate Frisbee',
-          :water_polo => 'More Sports\Water Polo',
-          :mountain_biking => 'Mountain Biking',
-          :outdoors => 'Outdoors',
-          :canoeing => 'Outdoors\Canoeing',
-          :climbing => 'Outdoors\Climbing',
-          :hiking => 'Outdoors\Hiking',
-          :kayaking => 'Outdoors\Kayaking',
-          :orienteering => 'Outdoors\Orienteering',
-          :outrigging => 'Outdoors\Outrigging',
-          :rafting => 'Outdoors\Rafting',
-          :racquetball => 'Racquetball',
-          :rugby => 'Rugby',
-          :running => 'Running',
-          :cross_country => 'Running\Cross Country',
-          :marathon_running => 'Running\Marathon Running',
-          :track_field => 'Running\Track & Field',
-          :trail_running => 'Running\Trail Running',
-          :sailing => 'Sailing',
-          :snow_sports => 'Snow Sports',
-          :skiing => 'Snow Sports\Skiing',
-          :snowboarding => 'Snow Sports\Snowboarding',
-          :snowshoeing => 'Snow Sports\Snowshoeing',
-          :soccer => 'Soccer',
-          :softball => 'Softball',
-          :softball_dixie => 'Softball\Softball-Dixie',
-          :softball_fast_pitch => 'Softball\Softball-Fast Pitch',
-          :softball_slow_pitch => 'Softball\Softball-Slow Pitch',
-          :squash => 'Squash',
-          :swimming => 'Swimming',
-          :diving => 'Swimming\Diving',
-          :tennis => 'Tennis',
-          :other_tennis => 'Tennis\Other Tennis',
-          :usta => 'Tennis\USTA',
-          :triathlon => 'Triathlon',
-          :volleyball => 'Volleyball',
-          :walking => 'Walking',
-          :wrestling => 'Wrestling'
-        }
-      end
-    end
-  
-  end
-end