playlyfe_client 1.0.2

data/lib/playlyfe_client/v2/action.rb

@@ -0,0 +1,59 @@
+require_relative "../action.rb"
+
+module PlaylyfeClient
+  module V2
+    class Action < PlaylyfeClient::Action
+      attr_reader :id, :name, :description, :rewards, :variables, :times_played
+
+      private
+
+        def initialize(action_hash, game)
+          super(game)
+
+          @id=action_hash[:id] || action_hash["id"]
+          @name=action_hash[:name] || action_hash["name"]
+          @description=action_hash[:description] || action_hash["description"]
+          @variables=action_hash[:variables] || action_hash["variables"]
+          @times_played=action_hash[:count] || action_hash["count"] || action_hash[:times_played] || action_hash["times_played"]
+
+          fill_rewards(action_hash[:rewards] || action_hash["rewards"] || [])
+        end
+        
+        def fill_rewards(rewards)  
+          @rewards = []
+          rewards.each do |rwd_hash|
+            verb= rwd_hash[:verb] || rwd_hash["verb"]
+            probability= rwd_hash[:probability] || rwd_hash["probability"]
+
+            mtr=rwd_hash[:metric] || rwd_hash["metric"]
+            metric=game.metrics.find(mtr[:id] || mtr["id"])
+
+            value=rwd_hash[:value] || rwd_hash["value"]
+            if metric.kind_of?(PlaylyfeClient::V2::SetMetric)
+              value=get_rewards_array(value,metric)
+              id="#{metric.id}_#{(value.collect {|i| i[:name]}).join("_").underscore}"
+            else
+              value=value.to_i  
+              id="#{metric.id}_#{value}"
+            end  
+
+            @rewards << {id: id, metric: metric, value: value, verb: verb, probability: probability }
+          end  
+
+          @rewards
+        end  
+
+        def get_rewards_array(items_hash,metric)
+          items=[]
+          items_hash.each_pair do |key, val|
+             m_item= (metric.items.detect {|it| it[:name] == key})
+             items << {name: m_item[:name], count: val.to_i} unless m_item.nil?
+          end  
+          items
+        end
+
+    end  
+  end  
+end
+
+     

data/lib/playlyfe_client/v2/collection/action_collection.rb

@@ -0,0 +1,30 @@
+require_relative "../collection.rb"
+require_relative "../action.rb"
+
+module PlaylyfeClient
+  module V2
+    class ActionCollection < PlaylyfeClient::V2::Collection
+     
+      def find(str)
+        (@items.detect {|pl| pl.name == str || pl.id == str})
+      end  
+      
+      private
+
+        def initialize(game)  
+          super
+          @items=[]
+          fill_items(game.connection.get_full_all_actions_array)
+        end
+        
+        def fill_items(hash_array)  
+          hash_array.each do |action_hash|
+            @items << PlaylyfeClient::V2::Action.new(action_hash, @game)
+          end  
+        end  
+
+         
+    end  
+  end
+end    
+     

data/lib/playlyfe_client/v2/collection/leaderboard_collection.rb

@@ -0,0 +1,43 @@
+require_relative "../collection.rb"
+require_relative "../leaderboard/unknown_leaderboard.rb"
+require_relative "../leaderboard/teams_leaderboard.rb"
+require_relative "../leaderboard/players_leaderboard.rb"
+
+module PlaylyfeClient
+  module V2
+    class LeaderboardCollection < PlaylyfeClient::V2::Collection
+     
+      def find(str)
+        (@items.detect {|pl| pl.name == str || pl.id == str})
+      end  
+
+      def for_teams
+        @items.select {|lbd| lbd.kind_of?(PlaylyfeClient::V2::TeamsLeaderboard)}
+      end
+        
+      def for_players
+        @items.select {|lbd| lbd.kind_of?(PlaylyfeClient::V2::PlayersLeaderboard)}
+      end  
+         
+      
+      private
+
+        def initialize(game)  
+          super
+          @items=[]
+          fill_items(game.connection.get_full_leaderboards_array)
+        end
+        
+        def fill_items(hash_array)  
+          hash_array.each do |definition_hash|
+            data_hash=game.connection.get_full_leaderboard_hash(definition_hash["id"])
+            @items << PlaylyfeClient::V2::UnknownLeaderboard.create_from(definition_hash.merge(data_hash), @game)
+          end  
+        end  
+
+
+    end  
+  end
+end    
+     
+ 

data/lib/playlyfe_client/v2/collection/metric_collection.rb

@@ -0,0 +1,30 @@
+require_relative "../collection.rb"
+require_relative "../metric.rb"
+
+module PlaylyfeClient
+  module V2
+    class MetricCollection < PlaylyfeClient::V2::Collection
+     
+      def find(str)
+        (@items.detect {|pl| pl.name == str || pl.id == str})
+      end  
+      
+      private
+
+        def initialize(game)  
+          super
+          @items=[]
+          fill_items(game.connection.get_full_metrics_array)
+        end
+        
+        def fill_items(hash_array)  
+          hash_array.each do |action_hash|
+            @items << PlaylyfeClient::V2::Metric.create_from(action_hash, @game)
+          end  
+        end  
+
+         
+    end  
+  end
+end    
+     

data/lib/playlyfe_client/v2/collection/player_collection.rb

@@ -0,0 +1,30 @@
+require_relative "../collection.rb"
+require_relative "../player.rb"
+
+module PlaylyfeClient
+  module V2
+    class PlayerCollection < PlaylyfeClient::V2::Collection
+      def find(str)
+        (@items.detect {|pl| pl.alias.include?(str) || pl.id.include?(str)})
+      end  
+      
+      private
+
+        def initialize(game)  
+          super
+          @items=[]
+          fill_items(@game.connection.get_player_hash_array)
+        end
+        
+        def fill_items(player_hash_array)  
+          player_hash_array.each do |player_hash|
+            @items << PlaylyfeClient::V2::Player.new(player_hash, @game)
+          end  
+        end  
+
+         
+    end  
+  end
+end    
+     
+ 

data/lib/playlyfe_client/v2/collection/team_collection.rb

@@ -0,0 +1,31 @@
+require_relative "../collection.rb"
+require_relative "../team.rb"
+
+module PlaylyfeClient
+  module V2
+    class TeamCollection < PlaylyfeClient::V2::Collection
+     
+      def find(str)
+        (@items.detect {|pl| pl.name == str || pl.id == str})
+      end  
+      
+      private
+
+        def initialize(game)  
+          super
+          @items=[]
+          fill_items(@game.connection.get_team_hash_array)
+        end
+        
+        def fill_items(hash_array)  
+          hash_array.each do |item_hash|
+            @items << PlaylyfeClient::V2::Team.new(item_hash, @game)
+          end  
+        end  
+
+         
+    end  
+  end
+end    
+     
+ 

data/lib/playlyfe_client/v2/collection.rb

@@ -0,0 +1,60 @@
+module PlaylyfeClient
+  module V2
+    class Collection 
+      attr_reader :game
+        
+      def all
+        @items
+      end
+
+      def add(item)
+        @items << item
+      end  
+
+      def find(str)
+        (@items.detect {|item| item.id.include?(str)})
+      end  
+
+      def find_all(str_arr)
+        coll=[]
+        str_arr.each do |str|
+          coll << self.find(str)
+        end
+        coll.compact
+      end  
+
+      def first
+        @items.first
+      end
+        
+      def last
+        @items.last
+      end
+
+      def to_a
+        @items
+      end  
+
+      def size
+        @items.size
+      end  
+      
+      private
+
+        #shoudl be redefined in subclasses
+        def initialize(game)  
+          @game= game
+          @items=[]
+          fill_items([])
+        end
+        
+        def fill_items(hash_array)  
+          hash_array.each do |hash|
+            @items << hash
+          end  
+        end  
+
+         
+    end  
+  end
+end 

data/lib/playlyfe_client/v2/connection.rb

@@ -0,0 +1,109 @@
+
+require_relative "../connection.rb"
+
+module PlaylyfeClient
+  module V2
+    class Connection < PlaylyfeClient::Connection
+  
+      def game
+        @game ||= PlaylyfeClient::V2::Game.find_by_connection(self)
+      end
+
+      def reset_game!
+        @game=nil
+      end  
+
+      #for calls to "runtime" there MUST be a player_id, even for Metrics or Leaderboards. So we pick first one.
+      def dummy_player_id
+        @dummy_player_id||= get_full_players_hash["data"].first["id"]
+      end  
+
+      def dummy_player_id=(id)
+        @dummy_player_id= id
+      end 
+  
+      def get_full_game_hash
+        self.get('/admin')
+      end
+        
+      def get_game_hash
+        get_full_game_hash["game"]  
+      end  
+
+      def get_full_players_hash
+        get("/admin/players")
+      end   
+
+      def get_player_hash_array
+        get_full_players_hash["data"]
+      end   
+
+      def get_game_image_data(player_id=dummy_player_id)
+        get_raw("/runtime/assets/game", {size: style.to_s, player_id: player_id})
+      end
+        
+      def get_full_teams_hash
+        get("/admin/teams")
+      end  
+      
+      def get_team_hash_array
+        get_full_teams_hash["data"]
+      end  
+
+      def get_full_player_profile_hash(player_id)
+        get("/admin/players/#{player_id}")
+      end  
+
+      def get_full_team_members_hash(team_id)
+        get("/admin/teams/#{team_id}/members")
+      end  
+
+      def get_team_members_hash_array(team_id)
+        get_full_team_members_hash(team_id)["data"]
+      end  
+      
+      def get_full_leaderboards_array(player_id=dummy_player_id)
+        get("/runtime/leaderboards", {player_id: player_id})
+      end  
+
+      def get_full_leaderboard_hash(leaderboard_id, cycle="alltime", player_id=dummy_player_id)
+        get("/runtime/leaderboards/#{leaderboard_id}", {cycle: cycle, player_id: player_id})
+      end 
+
+      def get_full_all_actions_array(player_id=dummy_player_id)
+        get("/runtime/actions", {player_id: player_id})
+      end  
+
+      def post_play_action(action_id, player_id, body ={})
+        post("/runtime/actions/#{action_id}/play", {player_id: player_id}, body)
+      end  
+
+      def get_full_metrics_array(player_id=dummy_player_id)
+        get("/runtime/definitions/metrics", {player_id: player_id})
+      end  
+
+      def get_full_activity_feed_array(player_id, start_time=nil, end_time=nil)
+        start_str=start_time.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ") if start_time.kind_of?(Time)
+        end_str=end_time.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ") if start_time.kind_of?(Time)
+
+        #/admin/players/player2/activity?start=2016-05-01T00:00:00Z&end=2016-05-21T00:00:00Z
+        if start_time
+          #get specified period of time
+          get("/admin/players/#{player_id}/activity",{"start" => start_str, "end" => end_str})
+        else
+          #get last 24 hours
+          get("/admin/players/#{player_id}/activity")
+        end  
+      end  
+   
+      def post_create_player(player_h)
+        post("/admin/players", {}, player_h)
+      end  
+
+      def delete_player(player_id)
+        delete("/admin/players/#{player_id}")
+      end  
+
+    end  
+  end
+end

data/lib/playlyfe_client/v2/game.rb

@@ -0,0 +1,71 @@
+
+require_relative "./collection/player_collection.rb"
+require_relative "./collection/team_collection.rb"
+require_relative "./collection/leaderboard_collection.rb"
+require_relative "./collection/action_collection.rb"
+require_relative "./collection/metric_collection.rb"
+
+require_relative "../game.rb"
+
+module PlaylyfeClient
+  module V2
+    #Game is 1:1 to connection, so only one instance per connection
+    #finding is done by credentials
+    class Game < PlaylyfeClient::Game
+
+      attr_reader :game_hash, :description, :id, :type, :timezone, :created_at
+      attr_accessor :ignore_rate_limit_errors
+
+      def self.find_by_connection(conn)
+        PlaylyfeClient::V2::Game.new(conn)
+      end  
+         
+      def players
+        @players ||= PlaylyfeClient::V2::PlayerCollection.new(self)
+      end
+
+      def teams 
+        @teams ||= PlaylyfeClient::V2::TeamCollection.new(self)
+      end  
+
+      def metrics
+        @metrics ||= PlaylyfeClient::V2::MetricCollection.new(self)
+      end 
+     
+      def actions
+        @actions ||= PlaylyfeClient::V2::ActionCollection.new(self)
+      end
+
+      def available_actions
+        actions
+      end  
+
+      def leaderboards
+        @leaderboards ||= PlaylyfeClient::V2::LeaderboardCollection.new(self)
+      end
+
+      def image_data(style=:original)
+        data=connection.get_game_image_data
+        puts(data)
+      end  
+
+      private
+
+        def initialize(conn)    
+          super(conn)
+          @game_hash=connection.get_game_hash
+          #name is not name of Game but rather connection   @name= game_hash["name"]
+          @description=game_hash["description"]
+          @id=game_hash["id"]
+          @image=game_hash["image"]
+          @title=game_hash["title"]
+          @type=game_hash["type"]
+          @timezone=game_hash["timezone"] #TODO converion to TZInfo::Timezone ? http://www.rubydoc.info/gems/tzinfo/frames
+          @created_at=Time.parse(game_hash["created"])
+        end  
+
+     
+
+    end
+  end  
+end    

data/lib/playlyfe_client/v2/leaderboard/players_leaderboard.rb

@@ -0,0 +1,30 @@
+require_relative "../leaderboard.rb"
+
+module PlaylyfeClient
+  module V2
+    class PlayersLeaderboard < PlaylyfeClient::V2::Leaderboard
+
+      private 
+        
+        def fill_positions(data)  
+          data.each do |pos|
+            rank=(pos[:rank] || pos["rank"]).to_i - 1
+            score=pos[:score] || pos["score"] || 0
+            entity= pos[:player] || pos["player"]
+
+            player=game.players.find(entity[:id] || entity["id"])
+
+            #all players should be listed in game, so if nothing is found raise exception
+            if player.nil?
+              fail PlaylyfeClient::LeaderboardError.new("{\"error\": \"Player not found\", \"error_description\": \"Player '#{entity[:id] || entity["id"]}' from '#{self.name}'[#{self.id}] leaderboard was not found between game.players!\"}")
+            end 
+      
+            @positions[rank] = {entity: player, score: score}
+          end  
+
+          @positions
+        end  
+
+    end
+  end
+end  

data/lib/playlyfe_client/v2/leaderboard/teams_leaderboard.rb

@@ -0,0 +1,30 @@
+require_relative "../leaderboard.rb"
+
+module PlaylyfeClient
+  module V2
+    class TeamsLeaderboard < PlaylyfeClient::V2::Leaderboard
+
+      private 
+        
+        def fill_positions(data)  
+          data.each do |pos|
+            rank=(pos[:rank] || pos["rank"]).to_i - 1
+            score=pos[:score] || pos["score"] || 0
+            entity= pos[:team] || pos["team"]
+
+            team=game.teams.find(entity[:id] || entity["id"])
+
+            #all teams should be listed in game, so if nothing is found raise exception
+            if team.nil?
+              fail PlaylyfeClient::LeaderboardError.new("{\"error\": \"Team not found\", \"error_description\": \"Team '#{entity[:id] || entity["id"]}' from '#{self.name}'[#{self.id}] leaderboard was not found between game.teams!\"}")
+            end 
+
+            @positions[rank] = {entity: team, score: score}
+          end  
+
+          @positions
+        end  
+
+    end
+  end
+end  

data/lib/playlyfe_client/v2/leaderboard/unknown_leaderboard.rb

@@ -0,0 +1,23 @@
+require_relative "../leaderboard.rb"
+require_relative "./players_leaderboard.rb"
+require_relative "./teams_leaderboard.rb"
+
+module PlaylyfeClient
+  module V2
+    class UnknownLeaderboard < PlaylyfeClient::V2::Leaderboard
+
+      def self.create_from(lbd_hash, game)
+        entity=lbd_hash[:entity_type] || lbd_hash["entity_type"]
+        case entity
+        when "players"
+          return PlaylyfeClient::V2::PlayersLeaderboard.new(lbd_hash, game)
+        when "teams"  
+          return PlaylyfeClient::V2::TeamsLeaderboard.new(lbd_hash, game)
+        else
+          fail PlaylyfeClient::LeaderboardError.new("{\"error\": \"Unrecognized entity_type\", \"error_description\": \"Class for entity_type '#{entity}' from #{lbd_hash} is unrecognized!\"}")
+        end
+      end              
+
+    end
+  end
+end  

data/lib/playlyfe_client/v2/leaderboard.rb

@@ -0,0 +1,38 @@
+require_relative "../leaderboard.rb"
+
+module PlaylyfeClient
+  module V2
+    class Leaderboard < PlaylyfeClient::Leaderboard
+      
+      attr_reader :entity_type, :metric, :scope, :cycles
+
+      private 
+      
+        def initialize(lbd_hash, game)
+          super(game)
+
+          @id=lbd_hash[:id] || lbd_hash["id"]
+          @name=lbd_hash[:name] || lbd_hash["name"]
+          @entity_type=lbd_hash[:entity_type] || lbd_hash["entity_type"]
+          @metric=lbd_hash[:metric] || lbd_hash["metric"]
+          @scope=lbd_hash[:scope] || lbd_hash["scope"]
+          @cycles=lbd_hash[:cycles] || lbd_hash["cycles"]
+
+          fill_positions(lbd_hash[:data] || lbd_hash["data"] || [])
+        end
+        
+        def fill_positions(data)  
+          data.each do |pos|
+            rank=(pos[:rank] || pos["rank"]).to_i - 1
+            score=pos[:score] || pos["score"] || 0
+            entity= pos[:player] || pos["player"] || pos[:team] || pos["team"] || nil
+            
+            @positions[rank] = {entity: entity, score: score}
+          end  
+
+          @positions
+        end  
+
+    end
+  end
+end  

data/lib/playlyfe_client/v2/metric/compound_metric.rb

@@ -0,0 +1,31 @@
+require_relative "../metric.rb"
+
+module PlaylyfeClient
+  module V2
+    class CompoundMetric < PlaylyfeClient::V2::Metric
+      attr_reader :formula
+
+
+      def apply_reward(reward, scores)
+        metric_sym=self.id.to_sym
+        case reward[:verb]
+          when "add"
+           scores[:compounds][metric_sym]+=reward[:value].to_i
+          when "remove"
+           scores[:compounds][metric_sym]-=reward[:value].to_i
+          when "set"
+           scores[:compounds][metric_sym]=reward[:value].to_i
+        end
+      end
+
+      private 
+      
+        def initialize(metric_hash, game)
+          super(metric_hash, game)
+          
+          @formula=metric_hash[:formula] || metric_hash["formula"]
+        end  
+
+    end
+  end
+end  

data/lib/playlyfe_client/v2/metric/point_metric.rb

@@ -0,0 +1,27 @@
+require_relative "../metric.rb"
+
+module PlaylyfeClient
+  module V2
+    class PointMetric < PlaylyfeClient::V2::Metric
+
+      def apply_reward(reward, scores)
+        metric_sym=self.id.to_sym
+        case reward[:verb]
+          when "add"
+           scores[:points][metric_sym]+=reward[:value].to_i
+          when "remove"
+           scores[:points][metric_sym]-=reward[:value].to_i
+          when "set"
+           scores[:points][metric_sym]=reward[:value].to_i
+        end
+      end
+
+      private 
+      
+        def initialize(metric_hash, game)
+          super(metric_hash, game)
+        end  
+
+    end
+  end
+end  

data/lib/playlyfe_client/v2/metric/set_metric.rb

@@ -0,0 +1,41 @@
+require_relative "../metric.rb"
+
+module PlaylyfeClient
+  module V2
+    class SetMetric < PlaylyfeClient::V2::Metric
+      attr_reader :items
+
+      def apply_reward(reward, scores)
+        reward[:value].each do |rwd_item|
+          score_item=scores[:sets][self.id.to_sym].detect { |i| i[:name] == rwd_item[:name] }
+          case reward[:verb]
+            when "add"
+             score_item[:count]+=rwd_item[:count].to_i
+            when "remove"
+             score_item[:count]-=rwd_item[:count].to_i
+            when "set"
+             score_item[:count]=rwd_item[:count].to_i
+          end
+        end  
+      end 
+
+
+
+      private 
+      
+        def initialize(metric_hash, game)
+          super(metric_hash, game)
+
+          fill_items(metric_hash["items"] || [])
+        end  
+
+        def fill_items(items_hash)
+          @items=[]
+          items_hash.each_pair do |key, value|
+            @items << {name: key , description: value["description"]}
+          end
+          @items
+        end    
+    end
+  end
+end