playlyfe_client 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d2a35f5b9c9682634b330792419663b08449c8e
+  data.tar.gz: 03e9ac4e72b4124a8beafddf2b55a1dbfda9c215
+SHA512:
+  metadata.gz: 96022c5547d3be058617ada499686c9485b778844cf901b0fb1d281a0d6bf5f7f3d88bb8b35655647444afbfbced744c8e09bfaaed2e55dc15bd298aecb22a06
+  data.tar.gz: 102dbdef6471321d301688694b12f9a7040383b983d46f8a04c16eb6aaa64dd9bd61392a2628c40ef0533bd85957a2f02587507d97874b6682ff84403b076d94

data/.gitignore

@@ -0,0 +1,27 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/bin/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+.tags
+.gemtags

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+#production dependecies
+gem 'rest_client'
+gem 'json'
+gem 'jwt'
+
+# Specify your gem's dependencies in playlyfe_client.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    playlyfe_client (1.0.2)
+      json
+      jwt
+      rest_client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.2)
+    coderay (1.1.1)
+    json (1.8.3)
+    jwt (1.5.0)
+    method_source (0.8.2)
+    minitest (5.8.4)
+    minitest-reporters (1.1.8)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    netrc (0.7.9)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rest_client (1.7.2)
+      netrc (~> 0.7.7)
+    ruby-progressbar (1.8.0)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  json
+  jwt
+  minitest
+  minitest-reporters
+  playlyfe_client!
+  pry
+  rake (~> 10.0)
+  rest_client
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 TODO: Write your name
+
+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.

data/README.md

@@ -0,0 +1,97 @@
+# PlaylyfeClient
+
+Model/Object oriented PlaylyfeClient client based on PlaylyfeClient SDK.
+It's focus is abstract direct calls with hand written routes into calling methods on `game`.
+All aspects of game is defined at PlaylyfeClient, this client serves only for sending actions and reading results and stats.
+
+## Base Classes
+* Game
+* Action
+* Player
+* Team
+* Leaderboard
+* Metric
+
+### Game 
+  base client class to interact with PlaylyfeClient game
+  * has many available actions
+  * has many players
+  * has many teams
+  * has many metrics
+  * has many leaderboards
+
+### Action
+  Equivalent to PlaylyfeClient action (or some complicated rule)
+
+### Player
+  Player of game , his profile and scores 
+
+### Leaderboard
+  Leaderboards of the Game
+ 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'playlyfe_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install playlyfe_client
+
+## Usage
+
+You have to setup a client at PlaylyfeClient which can access API (only paid plans) form your backend.
+Client shoul have 'Client Credential Flow' , all checks at config page should be on YES and should have all scopes with RW access.
+
+Then in your code initialize connection:
+  
+    $ conn= PlaylyfeClient::V2::Connection.new(
+        version: 'v2',
+        client_id: CLIENT_ID,
+        client_secret: CLIENT_SECRET,
+        type: 'client'
+      )
+    
+    game=connection.game
+
+With game in hand you can start to ask:
+    
+    pl1=game.player.first
+    pl1.scores
+    game.teams.all
+    game.metrics
+    a=game.actions.find("my_action_id")
+
+or play
+
+    pl1.play(a)
+    a.play_by(pl1) #equivalent to previous line
+
+or add players
+   
+    PlaylyfeClient::V2::Player.create({id: "batman", alias: "Bruce Wayne"}, game)
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/foton/playlyfe_client.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/playlyfe_client/action.rb

@@ -0,0 +1,32 @@
+require_relative "./errors.rb"
+
+module PlaylyfeClient
+  class Action
+
+    attr_reader :game
+
+    def self.all(game)
+      game.avaliable_actions
+    end  
+
+    def play_by(player)
+      player.play(self)
+    end  
+
+    def apply_rewards_on_scores(scores)
+      new_scores=scores.dup 
+      self.rewards.each do |reward|
+        reward[:metric].apply_reward(reward, new_scores)
+      end  
+      new_scores  
+    end
+      
+    private 
+    
+      def initialize(game)
+        @game=game
+      end  
+
+  end
+end    
+    

data/lib/playlyfe_client/connection.rb

@@ -0,0 +1,200 @@
+require 'uri'
+require 'json'
+require 'rest_client'
+require 'jwt'
+
+require_relative "./errors.rb"
+require_relative "./v2/game.rb"
+
+module PlaylyfeClient
+  #based on playlyfe-rub-sdk (https://github.com/playlyfe/playlyfe-ruby-sdk)
+  class Connection
+    attr_reader :sdk_version
+
+    def self.createJWT(options)
+      options[:scopes] ||= []
+      options[:expires] ||= 3600
+      expires = Time.now.to_i + options[:expires]
+      token = JWT.encode({:player_id => options[:player_id], :scopes => options[:scopes], :exp => expires}, options[:client_secret], 'HS256')
+      token = "#{options[:client_id]}:#{token}"
+      return token
+    end
+
+    def initialize(options = {})
+      if options[:type].nil?
+        err = PlaylyfeClient::ConnectionError.new("")
+        err.name = 'init_failed'
+        err.message = "You must pass in a type whether 'client' for client credentials flow or 'code' for auth code flow"
+        raise err
+      end
+      @version = options[:version] ||= 'v2'
+      @type = options[:type]
+      @id = options[:client_id]
+      @secret = options[:client_secret]
+      @store = options[:store]
+      @load = options[:load]
+      @redirect_uri = options[:redirect_uri]
+      if @store.nil?
+        @store = lambda { |token| puts 'Storing Token' }
+      end
+      if @type == 'client'
+        get_access_token()
+      else
+        if options[:redirect_uri].nil?
+          err = PlaylyfeClient::ConnectionError.new("")
+          err.name = 'init_failed'
+          err.message = 'You must pass in a redirect_uri for the auth code flow'
+          raise err
+        end
+      end
+    end
+
+    def api_version
+      @version
+    end
+
+    def game
+      fail PlaylyfeClient::GameError.new("{\"error\": \"unsupported version of API\", \"error_description\": \"'#{self.api_version}' of API is unsupported by playlyfe_client\"}")
+    end 
+      
+    def get_access_token
+      begin
+        if @type == 'client'
+          access_token = RestClient::Request.execute(:method => :post, :url => 'https://playlyfe.com/auth/token',
+            :payload => {
+              :client_id => @id,
+              :client_secret => @secret,
+              :grant_type => 'client_credentials'
+            }.to_json,
+            :headers => {
+              :content_type => :json,
+              :accepts => :json
+            },
+            :ssl_version => 'SSLv23'
+          )
+        else
+          access_token = RestClient::Request.execute(:method => :post, :url => "https://playlyfe.com/auth/token",
+            :payload => {
+              :client_id => @id,
+              :client_secret => @secret,
+              :grant_type => 'authorization_code',
+              :code => @code,
+              :redirect_uri => @redirect_uri
+            }.to_json,
+            :headers => {
+              :content_type => :json,
+              :accepts => :json
+            },
+            :ssl_version => 'SSLv23'
+          )
+        end
+        access_token = JSON.parse(access_token)
+        expires_at ||= Time.now.to_i + access_token['expires_in']
+        access_token.delete('expires_in')
+        access_token['expires_at'] = expires_at
+        @store.call access_token
+        if @load.nil?
+          @load = lambda { return access_token }
+        else
+          old_token = @load.call
+          if access_token != old_token
+            @load = lambda { return access_token }
+          end
+        end
+      rescue => e
+        raise PlaylyfeClient::ConnectionError.new(e.response)
+      end
+    end
+
+    def check_token(query)
+      access_token = @load.call
+      if access_token['expires_at'] < Time.now.to_i
+        puts 'Access Token Expired'
+        get_access_token()
+        access_token = @load.call
+      end
+      query[:access_token] = access_token['access_token']
+      query = hash_to_query(query)
+    end
+
+    def api(method, route, query = {}, body = {}, raw = false)
+      query = check_token(query)
+      begin
+        uri="https://api.playlyfe.com/#{@version}#{route}?#{query}"
+        puts "doing real query to api.uri : #{uri} with body #{body.to_json}" 
+        response = RestClient::Request.execute(
+          :method => method,
+          :url => uri,
+          :headers => {
+            :content_type => :json,
+            :accepts => :json
+          },
+          :payload => body.to_json,
+          :ssl_version => 'SSLv23'
+        )
+
+        if raw == true
+          return response.body
+        else
+          if response.body == 'null'
+            return nil
+          else
+            return JSON.parse(response.body)
+          end
+        end
+      rescue => e
+        raise PlaylyfeClient::Error.build(e.response, "#{method} #{uri}")
+      end
+    end
+
+    def get(route, query = {})
+      api(:get, route, query, {}, false)
+    end
+
+    def get_raw(route, query = {})
+      api(:get, route, query, {}, true)
+    end
+
+    def post(route, query = {}, body = {})
+      api(:post, route, query, body, false)
+    end
+
+    def put(route, query = {}, body = {})
+      api(:put, route, query, body, false)
+    end
+
+    def patch(route, query = {}, body = {})
+      api(:patch, route, query, body, false)
+    end
+
+    def delete(route, query = {})
+      api(:delete, route, query, {}, false)
+    end
+
+    def hash_to_query(hash)
+      return URI.encode(hash.map{|k,v| "#{k}=#{v}"}.join("&"))
+    end
+
+    def get_login_url
+      query = { response_type: 'code', redirect_uri: @redirect_uri, client_id: @id }
+      "https://playlyfe.com/auth?#{hash_to_query(query)}"
+    end
+
+    def get_logout_url
+      ""
+    end
+
+    def exchange_code(code)
+      if code.nil?
+        err = PlaylyfeClient::ConnectionError.new("")
+        err.name = 'init_failed'
+        err.message = 'You must pass in a code in exchange_code for the auth code flow'
+        raise err
+      else
+        @code = code
+        get_access_token()
+      end
+    end
+  end
+
+end

data/lib/playlyfe_client/errors.rb

@@ -0,0 +1,42 @@
+require 'json'
+
+module PlaylyfeClient
+  #grabbed from playlyfe-rub-sdk
+  class Error < StandardError; end
+  class ConnectionError < PlaylyfeClient::Error; end
+  class GameError < PlaylyfeClient::Error; end
+  class PlayerError < PlaylyfeClient::Error; end
+  class LeaderboardError < PlaylyfeClient::Error; end
+  class ActionError < PlaylyfeClient::Error; end
+  class MetricError < PlaylyfeClient::Error; end
+  class PlaylyfeClient::ActionRateLimitExceededError < PlaylyfeClient::ActionError; end
+  class PlaylyfeClient::PlayerExistsError < PlaylyfeClient::PlayerError; end
+
+  class Error < StandardError
+    attr_accessor :name, :message
+    def initialize(res=nil,uri=nil)
+      @raw = res
+      unless res.nil? || res == ""
+        res = JSON.parse(res)
+        @name = res['error']
+        @message = res['error_description']
+        @message+=" [request: #{uri}]" unless uri.nil?
+      end  
+    end
+    
+    def self.build(res=nil,uri=nil)
+      err_class= PlaylyfeClient::ConnectionError
+      unless res.nil? || res == ""
+        res_h = JSON.parse(res)
+        if res_h['error'] == "rate_limit_exceeded"
+          err_class= PlaylyfeClient::ActionRateLimitExceededError
+        elsif res_h['error'] == "player_exists"
+          err_class= PlaylyfeClient::PlayerExistsError
+              
+        end  
+      end  
+      err_class.new(res, uri)
+    end
+  end
+
+end

data/lib/playlyfe_client/game.rb

@@ -0,0 +1,33 @@
+
+require_relative "./errors.rb"
+
+module PlaylyfeClient
+  #Game is 1:1 to connection, so only one instance per connection
+  class Game
+    
+    attr_reader :title, :connection
+
+    
+    def to_hash
+      @game_hash || {}
+    end 
+
+    def players
+      []
+    end
+    
+    def actions
+      []
+    end
+
+    def leaderboards
+      []
+    end
+
+    private
+
+      def initialize(conn)
+        @connection=conn
+      end  
+  end
+end    

data/lib/playlyfe_client/leaderboard.rb

@@ -0,0 +1,27 @@
+require_relative "./errors.rb"
+
+module PlaylyfeClient
+  class Leaderboard
+    
+    attr_reader :id, :name, :game, :positions
+    
+    def self.all(game)
+      game.leaderboards
+    end  
+    
+    def table
+      positions
+    end
+
+    def results
+      positions
+    end
+
+    private
+
+      def initialize(game)
+        @game =game
+        @positions=[]
+      end  
+  end
+end    

data/lib/playlyfe_client/metric.rb

@@ -0,0 +1,14 @@
+require_relative "./errors.rb"
+
+module PlaylyfeClient
+ class Metric
+   attr_reader :game
+
+   private
+
+    def initialize(game)
+      @game=game
+    end  
+
+ end
+end   

data/lib/playlyfe_client/player.rb

@@ -0,0 +1,80 @@
+require_relative "./errors.rb"
+
+module PlaylyfeClient
+  class Player 
+    
+    attr_reader :game
+
+    def self.create(player_hash, game)
+      nil
+    end  
+
+    def self.all(game)
+      game.players
+    end  
+
+    def play(action)
+      false
+    end
+    
+    def scores
+      {points: {} ,sets: {}, states: {}, compound: {}}
+    end
+
+    def items_from_sets
+      items=[]
+      self.scores[:sets].each_pair do | key, value |
+        value.each do |item_h|
+          items << item_h.merge({metric_id: key.to_s}) if item_h[:count] > 0
+        end  
+      end  
+      items.sort! {|a,b| a[:name] <=> b[:name]}
+      items
+    end      
+
+    def badges
+      self.items_from_sets
+    end
+
+    def points
+      points=[]
+      self.scores[:points].each_pair do | key, value |
+        points << {count: value, metric_id: key.to_s}
+      end
+      points 
+    end 
+
+    def states
+      states=[]
+      self.scores[:states].each_pair do | key, value |
+        states << {name: value, metric_id: key.to_s}
+      end
+      states 
+    end  
+
+    def levels
+      self.states
+    end 
+
+    def teams
+      []
+    end
+
+    def players_leaderboards
+      []
+    end
+    
+    def teams_leaderboards  
+      []
+    end  
+
+    def activities(start_time=nil,end_time=nil)
+      []
+    end
+
+    private 
+      def initialize(game)
+        @game=game
+      end  
+  end
+end  

data/lib/playlyfe_client/team.rb

@@ -0,0 +1,26 @@
+require_relative "./errors.rb"
+
+module PlaylyfeClient
+  class Team
+    
+    attr_reader :id, :name, :created_at, :game, :connection
+
+    def template
+      definition
+    end
+    
+    def members
+      []
+    end
+
+    def leaderboards
+      []
+    end
+
+    private
+
+      def initialize(game)
+        @game =game
+      end  
+  end
+end