riaction 0.0.1

data/lib/riaction/iactionable/error.rb

@@ -0,0 +1,17 @@
+module IActionable
+  module Error
+    class Error < StandardError
+      attr_accessor :response
+      
+      def initialize(response)
+        @response = response
+        super
+      end
+    end
+  
+    # http://iactionable.com/api/response-codes/
+    class BadRequest < Error; end
+    class Unauthorized < Error; end
+    class Internal < Error; end
+  end
+end

data/lib/riaction/iactionable/objects.rb

@@ -0,0 +1,6 @@
+module IActionable
+  module Objects
+  end
+end
+
+Dir.glob(File.dirname(__FILE__) + '/objects/*') {|file| require file}

data/lib/riaction/iactionable/objects/achievement.rb

@@ -0,0 +1,19 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class Achievement < IActionableObject
+      attr_accessor :key
+      attr_accessor :description
+      attr_accessor :image_url
+      attr_accessor :name
+      
+      def initialize(key_values={})
+        initialize_awardable(key_values)
+        super(key_values)
+      end
+      
+      awardable
+    end
+  end
+end

data/lib/riaction/iactionable/objects/awardable.rb

@@ -0,0 +1,44 @@
+require 'riaction/iactionable/objects/progress.rb'
+
+module IActionable
+  module Objects
+    module Awardable
+      def self.included(base)
+        base.extend(ClassMethods)  
+      end
+    
+      module ClassMethods
+        def awardable
+          attr_accessor :award_date
+          attr_accessor :progress
+          include IActionable::Objects::Awardable::InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+        def initialize_awardable(key_values={})
+          @progress = extract_many_as(key_values, "Progress", IActionable::Objects::Progress)
+          # convert the miliseconds within the date string to seconds (per ruby)
+          # "/Date(1275706032317-0600)/" => "1275706032-0600"
+          @award_date = key_values.delete("AwardDate")
+          @award_date = IActionableObject.timestamp_to_seconds(@award_date) unless @award_date.blank?
+        end
+      
+        def complete?
+          @progress.any? && @progress.all?
+        end
+      
+        def percent_complete
+          Integer(Float(@progress.select{|p| p.complete?}.size) / @progress.size * 100)
+        rescue TypeError => e
+          0
+        end
+      
+        def awarded_on
+          # bug in ruby 1.9.2 where Time.strptime does not support seconds-since-epoch format, but Date.strptime does, so we'll use that for now
+          Date.strptime(@award_date, "%s%z").to_time unless @award_date.blank?
+        end
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/challenge.rb

@@ -0,0 +1,18 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class Challenge < IActionableObject
+      awardable
+      
+      attr_accessor :key
+      attr_accessor :description
+      attr_accessor :name
+      
+      def initialize(key_values={})
+        initialize_awardable(key_values)
+        super(key_values)
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/goal.rb

@@ -0,0 +1,19 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class Goal < IActionableObject
+      awardable
+      
+      attr_accessor :key
+      attr_accessor :description
+      attr_accessor :name
+      attr_accessor :interval
+      
+      def initialize(key_values={})
+        initialize_awardable(key_values)
+        super(key_values)
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/i_actionable_object.rb

@@ -0,0 +1,40 @@
+module IActionable
+  module Objects
+    class IActionableObject
+      def initialize(key_values={})
+        key_values.each_pair do |key, value|
+          instance_variable_set "@#{key.camelize.underscore}".to_sym, value
+        end
+      end
+      
+      def self.timestamp_regexp
+        /\/Date\((\d+)((\-|\+)\d{4})\)\//
+      end
+      
+      def self.timestamp_to_seconds(timestamp)
+        milliseconds = timestamp[timestamp_regexp, 1]
+        tz = timestamp[timestamp_regexp, 2]
+        "#{Integer(milliseconds)/1000}#{tz}"
+      end
+      
+      private
+      
+      def extract_many_as(key_values, field, klass)
+        if key_values.fetch(field).respond_to?(:inject)
+          loaded = []
+          content = key_values.delete(field)
+          content.each do |c|
+            loaded << klass.new(c)
+          end
+          loaded
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+require "riaction/iactionable/objects/awardable.rb"
+
+IActionable::Objects::IActionableObject.send(:include, IActionable::Objects::Awardable)

data/lib/riaction/iactionable/objects/identifier.rb

@@ -0,0 +1,11 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class Identifier < IActionableObject
+      attr_accessor :id
+      attr_accessor :id_hash
+      attr_accessor :id_type
+    end
+  end
+end

data/lib/riaction/iactionable/objects/leaderboard.rb

@@ -0,0 +1,10 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class Leaderboard < IActionableObject
+      attr_accessor :key
+      attr_accessor :name
+    end
+  end
+end

data/lib/riaction/iactionable/objects/leaderboard_report.rb

@@ -0,0 +1,23 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+require 'riaction/iactionable/objects/leaderboard.rb'
+
+
+module IActionable
+  module Objects
+    class LeaderboardReport < IActionableObject
+      attr_accessor :page_count
+      attr_accessor :page_number
+      attr_accessor :total_count
+      attr_accessor :leaderboard
+      attr_accessor :point_type
+      attr_accessor :profiles
+      
+      def initialize(key_values={})
+        @leaderboard = IActionable::Objects::PointType.new(key_values.delete("Leaderboard"))
+        @point_type = IActionable::Objects::PointType.new(key_values.delete("PointType"))
+        @profiles = extract_many_as(key_values, "Profiles", IActionable::Objects::ProfileSummary)
+        super(key_values)
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/level.rb

@@ -0,0 +1,18 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+require 'riaction/iactionable/objects/level_type.rb'
+
+module IActionable
+  module Objects
+    class Level < IActionableObject
+      attr_accessor :name
+      attr_accessor :number
+      attr_accessor :required_points
+      attr_accessor :level_type
+      
+      def initialize(key_values={})
+        @level_type = IActionable::Objects::LevelType.new(key_values.delete("LevelType"))
+        super(key_values)
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/level_type.rb

@@ -0,0 +1,10 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class LevelType < IActionableObject
+      attr_accessor :key
+      attr_accessor :name
+    end
+  end
+end

data/lib/riaction/iactionable/objects/point_type.rb

@@ -0,0 +1,10 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class PointType < IActionableObject
+      attr_accessor :key
+      attr_accessor :name
+    end
+  end
+end

data/lib/riaction/iactionable/objects/profile_level.rb

@@ -0,0 +1,16 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+require 'riaction/iactionable/objects/level.rb'
+
+module IActionable
+  module Objects
+    class ProfileLevel < IActionableObject
+      attr_accessor :current
+      attr_accessor :next
+      
+      def initialize(key_values={})
+        @current = IActionable::Objects::Level.new(key_values.delete("Current")) unless key_values["Current"].blank?
+        @next = IActionable::Objects::Level.new(key_values.delete("Next")) unless key_values["Next"].blank?
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/profile_points.rb

@@ -0,0 +1,21 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+require 'riaction/iactionable/objects/profile_level.rb'
+require 'riaction/iactionable/objects/point_type.rb'
+
+module IActionable
+  module Objects
+    class ProfilePoints < IActionableObject
+      attr_accessor :level # not always present
+      attr_accessor :point_type
+      attr_accessor :points
+      attr_accessor :reason # not always present
+      
+      def initialize(key_values={})
+        levels = key_values.delete("Level")
+        @level = IActionable::Objects::ProfileLevel.new(levels) unless levels.nil?
+        @point_type = IActionable::Objects::PointType.new(key_values.delete("PointType"))
+        super(key_values)
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/objects/profile_summary.rb

@@ -0,0 +1,24 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+require 'riaction/iactionable/objects/identifier.rb'
+require 'riaction/iactionable/objects/profile_points.rb'
+require 'riaction/iactionable/objects/achievement.rb'
+
+module IActionable
+  module Objects
+    class ProfileSummary < IActionableObject
+      attr_accessor :display_name
+      attr_accessor :identifiers
+      attr_accessor :points
+      attr_accessor :recent_achievements
+      attr_accessor :rank
+      
+      def initialize(key_values={})
+        @identifiers = extract_many_as(key_values, "Identifiers", IActionable::Objects::Identifier)
+        @points = extract_many_as(key_values, "Points", IActionable::Objects::ProfilePoints)
+        @recent_achievements = extract_many_as(key_values, "RecentAchievements", IActionable::Objects::Achievement)
+        
+        super(key_values)
+      end      
+    end
+  end
+end

data/lib/riaction/iactionable/objects/progress.rb

@@ -0,0 +1,37 @@
+require 'riaction/iactionable/objects/i_actionable_object.rb'
+
+module IActionable
+  module Objects
+    class Progress < IActionableObject
+      attr_accessor :description
+      attr_accessor :condition_met_date
+      attr_accessor :current_value
+      attr_accessor :required_value
+      attr :complete
+      
+      def initialize(key_values={})
+        super(key_values)
+        # convert the miliseconds within the date string to seconds (per ruby)
+        # "/Date(1275706032317-0600)/" => "1275706032-0600"
+        @condition_met_date = IActionableObject.timestamp_to_seconds(@condition_met_date) unless @condition_met_date.blank?
+      end
+      
+      def complete?
+        Integer(@current_value) >= Integer(@required_value)
+      rescue TypeError => e
+        false
+      end
+      
+      def percent_complete
+        Integer(Float(@current_value) / Integer(@required_value) * 100)
+      rescue TypeError => e
+        0
+      end
+      
+      def condition_met_date
+        # bug in ruby 1.9.2 where Time.strptime does not support seconds-since-epoch format, but Date.strptime does, so we'll use that for now
+        Date.strptime(@condition_met_date, "%s%z").to_time unless @condition_met_date.blank?
+      end
+    end
+  end
+end

data/lib/riaction/iactionable/settings.rb

@@ -0,0 +1,30 @@
+module IActionable
+  class ConfigError < StandardError
+  end
+  
+  class Settings
+    attr :settings
+    
+    def initialize(values)
+      @settings = {
+        :app_key => values.fetch(:app_key),
+        :api_key => values.fetch(:api_key),
+        :version => values.fetch(:version)
+      }
+    rescue NoMethodError, KeyError => e
+      raise ConfigError.new("IAction::Settings being initialized with invalid arguments")
+    end
+    
+    def app_key
+      @settings.fetch(:app_key)
+    end
+    
+    def api_key
+      @settings.fetch(:api_key)
+    end
+    
+    def version
+      @settings.fetch(:version)
+    end
+  end
+end

data/lib/riaction/riaction.rb

@@ -0,0 +1,368 @@
+require 'riaction/iactionable/api.rb'
+
+require "active_support"
+require "active_record"
+require "resque"
+
+module Riaction
+  PROFILE_CLASSES = []
+  EVENT_LOGGING_CLASSES = []
+  
+  class NoEventDefined < StandardError; end
+  class NoProfileDefined < StandardError; end
+  
+  def self.included(base)
+    base.extend(ClassMethods)  
+  end
+  
+  def self.crud_actions
+    Set.new [:create, :update, :destroy]
+  end
+  
+  class ProfileCreator
+    @queue = :riaction_profile_creator
+    
+    def self.perform(klass_name, id)
+      if klass_name.constantize.riaction_profile?      
+        iactionable_api = IActionable::Api.new
+        profile_object = klass_name.constantize.find_by_id!(id)
+        profile_keys = profile_object.riaction_profile_keys
+        iactionable_api.create_profile(profile_keys[:profile_type], profile_keys[:id_type], profile_keys[:id])
+      else
+        raise NoProfileDefined.new
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      # event_object no longer exists; no means to recover
+    rescue IActionable::Error::BadRequest => e
+      # This should only be thrown if the profile type names specified in the model don't match what's on IActionable's dashboard 
+      raise e
+    end
+  end
+  
+  class EventPerformer
+    @queue = :riaction_event_logger
+    
+    def self.perform(event_name, klass_name, id)
+      iactionable_api = IActionable::Api.new
+      
+      event_object = klass_name.constantize.find_by_id!(id)
+      event_details = event_object.riaction_event(event_name)
+      profile_keys = event_details[:profile].riaction_profile_keys
+      
+      # assert the profile exists, and if not, create it
+      unless  begin
+                !!iactionable_api.get_profile_summary(profile_keys[:profile_type], profile_keys[:id_type], profile_keys[:id])
+              rescue IActionable::Error::BadRequest => e
+                false
+              end
+        iactionable_api.create_profile(profile_keys[:profile_type], profile_keys[:id_type], profile_keys[:id])
+      end
+      
+      # Log the event
+      iactionable_api.log_event(profile_keys[:profile_type], profile_keys[:id_type], profile_keys[:id], event_details[:key], event_details[:params])
+    rescue ActiveRecord::RecordNotFound => e
+      # event_object no longer exists; no means to recover
+    rescue IActionable::Error::BadRequest => e
+      # Log event should never throw this as of IActionable API v3
+    rescue NoMethodError => e
+      raise NoEventDefined.new
+    end
+  end
+  
+  class CrudEventCallback
+    def initialize(event_name)
+      @event_name = event_name
+    end
+    
+    def after_create(record)
+      if record.riaction_log_event?(@event_name)
+        Resque.enqueue(Riaction::EventPerformer, @event_name, record.class.base_class.to_s, record.id)
+      end
+    end                                 
+                                        
+    def after_update(record)            
+      if record.riaction_log_event?(@event_name)
+        Resque.enqueue(Riaction::EventPerformer, @event_name, record.class.base_class.to_s, record.id)
+      end
+    end
+    
+    def after_destroy(record)
+      if record.riaction_log_event?(@event_name)
+        Resque.enqueue(Riaction::EventPerformer, @event_name, record.class.base_class.to_s, record.id)
+      end
+    end
+  end
+  
+  class ProfileCreationCallback
+    def after_create(record)
+      Resque.enqueue(Riaction::ProfileCreator, record.class.base_class.to_s, record.id)
+    end                                 
+  end
+  
+  module ClassMethods
+    def riaction(object_type, opts)
+      if object_type == :profile
+        (PROFILE_CLASSES << self).uniq!
+        define_profile(opts.delete(:type), opts)
+        include Riaction::ProfileInstanceMethods unless instance_methods.include? :riaction_profile
+        send "after_create".to_sym, Riaction::ProfileCreationCallback.new
+      elsif object_type == :event
+        (EVENT_LOGGING_CLASSES << self).uniq!
+        define_event(opts[:name], opts[:trigger], opts[:profile], opts[:params], opts[:if])
+        include Riaction::EventInstanceMethods unless instance_methods.include? :riaction_event
+      end
+    end
+    
+    def define_event(name, trigger, profile, params = {}, guard = nil)
+      class << self
+        def riaction_events
+          class_variable_defined?(:@@riaction_events) ? class_variable_get(:@@riaction_events) : class_variable_set(:@@riaction_events, {})
+        end
+      end
+      
+      events = riaction_events
+      trigger = name unless trigger
+      
+      # store the event
+      events[name] = {:trigger => trigger, :profile => profile, :params => params, :guard => guard}
+      class_variable_set(:@@riaction_events, events)
+      
+      # Create the callback or the means to trigger it
+      if Riaction.crud_actions.include? trigger
+        send "after_#{trigger}".to_sym, Riaction::CrudEventCallback.new(name)
+        
+        define_method("trigger_#{name}!") do
+          if self.riaction_log_event?(name)
+            Resque.enqueue(Riaction::EventPerformer, name, self.class.base_class.to_s, self.id)
+          end
+        end
+      else
+        define_method("trigger_#{trigger}!") do
+          if self.riaction_log_event?(name)
+            Resque.enqueue(Riaction::EventPerformer, name, self.class.base_class.to_s, self.id)
+          end
+        end
+      end
+    end
+    
+    def define_profile(type, fields)
+      class << self
+        def riaction_profiles
+          class_variable_defined?(:@@riaction_profiles) ? class_variable_get(:@@riaction_profiles) : class_variable_set(:@@riaction_profiles, {})
+        end
+      end
+      
+      profiles = riaction_profiles
+      
+      # store the profile
+      profiles[type] = fields
+      class_variable_set(:@@riaction_profiles, profiles)
+      
+      class << self
+        def riaction_profile?
+          true
+        end
+      end
+    end
+    
+    def riaction_profile?
+      false
+    end
+  end
+
+  module EventInstanceMethods
+    def riaction_event(event_name)
+      events = self.class.class_variable_defined?(:@@riaction_events) ? self.class.class_variable_get(:@@riaction_events) : {}
+      event = events.fetch(event_name.to_sym)
+      
+      profile = riaction_event_profile(event[:profile])
+      unless profile.class.respond_to?(:riaction_profile?) && profile.class.riaction_profile?
+        raise TypeError.new("Object defined for #{self.class} on event #{event_name} as a profile must itself declare riaction(:profile ...)")
+      end
+      params = riaction_event_params(event[:params])
+      raise TypeError.new("Params defined for #{self.class} on event #{event_name} must be a hash") unless params.kind_of? Hash
+      
+      {
+        :key => event_name.to_sym,
+        :profile => profile,
+        :params => params
+      }
+    rescue KeyError => e
+      raise NoEventDefined.new("no such event #{event_name} defined on #{self.class}")
+    end
+    
+    def riaction_log_event?(event_name)
+      events = self.class.class_variable_defined?(:@@riaction_events) ? self.class.class_variable_get(:@@riaction_events) : {}
+      event = events.fetch(event_name.to_sym)
+      guard = event[:guard]
+      
+      case guard
+      when NilClass
+        true
+      when Symbol
+        self.send guard
+      when Proc
+        guard.call self
+      else 
+        true
+      end
+    rescue KeyError => e
+      raise NoEventDefined.new("no such event #{event_name} defined on #{self.class}")
+    end
+    
+    private
+    
+    def riaction_event_profile(profile)
+      if profile == :self
+        self
+      elsif profile.kind_of? Symbol
+        self.send(profile)
+      elsif profile.kind_of? Proc
+        profile.call
+      else
+        nil
+      end
+    rescue Exception => e
+      raise
+    end
+    
+    def riaction_event_params(params)
+      if params.kind_of? Symbol
+        self.send(params)
+      elsif params.kind_of? Proc
+        params.call
+      elsif params.kind_of? Hash
+        resolved_params = {}
+        params.each_pair do |key, value|
+          resolved_params[key] = self.respond_to?(value) ? self.send(value) : value
+        end
+        resolved_params
+      else
+        {}
+      end
+    rescue Exception => e
+      raise
+    end
+  end
+
+  module ProfileInstanceMethods
+    def riaction_profile_keys(profile_type=nil, id_type=nil)
+      profiles = self.class.class_variable_defined?(:@@riaction_profiles) ? self.class.class_variable_get(:@@riaction_profiles) : {}
+      
+      if profiles.size > 0
+        if profile_type && profiles.has_key?(profile_type)
+          ids = profiles.fetch(profile_type)
+        else
+          profile_type = profiles.first[0]
+          ids = profiles.first[1]
+        end
+      
+        if id_type && ids.has_key?(id_type)
+          {:profile_type => profile_type.to_s, :id_type => id_type.to_s, :id => self.send(ids.fetch(id_type)).to_s}
+        else
+          {:profile_type => profile_type.to_s, :id_type => ids.first[0].to_s, :id => self.send(ids.first[1]).to_s}
+        end
+      else
+        {}
+      end
+    rescue KeyError, NoMethodError => e
+      {}
+    end
+    
+    #################
+    #  API wrappers #
+    #################
+    
+    def riaction_profile_summary(achievement_count=nil)
+      keys = riaction_profile_keys
+      unless keys.empty?
+        @iactionable_api ||= IActionable::Api.new
+        @iactionable_api.get_profile_summary(keys[:profile_type], keys[:id_type], keys[:id], achievement_count)
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    rescue IActionable::Error::BadRequest => e
+      nil
+    end
+    
+    def riaction_create_profile
+      keys = riaction_profile_keys
+      unless keys.empty?
+        existing = riaction_profile_summary
+        unless existing
+          @iactionable_api ||= IActionable::Api.new
+          @iactionable_api.create_profile(keys[:profile_type], keys[:id_type], keys[:id])
+        else
+          existing
+        end
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    end
+    
+    def riaction_update_profile(new_id_type)
+      old_keys = riaction_profile_keys
+      new_keys = riaction_profile_keys(old_keys[:profile_type], new_id_type)
+      unless old_keys.empty? || new_keys.empty?
+        @iactionable_api ||= IActionable::Api.new
+        @iactionable_api.add_profile_identifier(old_keys[:profile_type], old_keys[:id_type], old_keys[:id], new_keys[:id_type], new_keys[:id])
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    end
+    
+    def riaction_profile_achievements(filter_type=nil)
+      keys = riaction_profile_keys
+      unless keys.empty?
+        @iactionable_api ||= IActionable::Api.new
+        @iactionable_api.get_profile_achievements(keys[:profile_type], keys[:id_type], keys[:id], filter_type)
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    rescue IActionable::Error::BadRequest => e
+      nil
+    end
+    
+    def riaction_profile_challenges(filter_type=nil)
+      keys = riaction_profile_keys
+      unless keys.empty?
+        @iactionable_api ||= IActionable::Api.new
+        @iactionable_api.get_profile_challenges(keys[:profile_type], keys[:id_type], keys[:id], filter_type)
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    rescue IActionable::Error::BadRequest => e
+      nil
+    end
+    
+    def riaction_profile_goals(filter_type=nil)
+      keys = riaction_profile_keys
+      unless keys.empty?
+        @iactionable_api ||= IActionable::Api.new
+        @iactionable_api.get_profile_goals(keys[:profile_type], keys[:id_type], keys[:id], filter_type)
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    rescue IActionable::Error::BadRequest => e
+      nil
+    end
+    
+    def riaction_profile_notifications
+      keys = riaction_profile_keys
+      unless keys.empty?
+        @iactionable_api ||= IActionable::Api.new
+        @iactionable_api.get_profile_notifications(keys[:profile_type], keys[:id_type], keys[:id])
+      else
+        raise NoProfileDefined.new("Class #{self.class} does not adequately define itself as an IActionable profile")
+      end
+    rescue IActionable::Error::BadRequest => e
+      nil
+    end
+  end
+end
+
+begin
+  ActiveRecord::Base.send(:include, Riaction)
+rescue NameError => e
+  # 
+end