alphaSDK 0.2.0 → 0.2.8

data/lib/gameball/models/player.rb

@@ -1,32 +1,41 @@
 module Gameball
-    class Player
-        # include Gameball::Request
-        def self.initialize_player (customerBody)
-            Gameball::Utils.validate(customerBody,['playerAttributes','playerUniqueId'],[])
-            begin
-            customerBody[:playerAttributes][:joinDate]=customerBody[:playerAttributes][:joinDate].iso8601
-            customerBody[:playerAttributes][:dateOfBirth]=customerBody[:playerAttributes][:dateOfBirth].iso8601    
-            rescue NoMethodError => exception
-                p exception
-                raise Gameball::GameballError.new("Invalid Date Format, Please use Time and Date objects")
-            end
-            
-            res=Gameball::Utils::request("post","/integrations/player",customerBody)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res) # use custom message
-            else 
-                return res
-            end
+  class Player
+    def self.initialize_player(body)
+      # Validating keys in incoming body
+      Gameball::Utils.validate(body, ["playerAttributes", "playerUniqueId"], [])
+      # .iso8601 Throws an exception if not invoked on a valid date object, so it is used to check if the dates are valid
+      begin
+        body[:playerAttributes][:joinDate] = body[:playerAttributes][:joinDate].iso8601
+        body[:playerAttributes][:dateOfBirth] = body[:playerAttributes][:dateOfBirth].iso8601
+      rescue NoMethodError => exception
+        raise Gameball::GameballError.new("Invalid Date Format, Please use Time and Date objects")
+      end
+      # Check for HTTP Success and throws error if not success
+      res = Gameball::Utils::request("post", "/integrations/player", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
-        def self.get_player_info(playerUniqueId)
-            body={playerUniqueId:playerUniqueId}
-            body["bodyHashed"]=Gameball::Utils::hashBody(playerUniqueId:playerUniqueId)
-            res=Gameball::Utils::request("post","/integrations/Player/Info",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res) # use custom message
-            else 
-                return res
-            end
+      else
+        return res
+      end
+    end
+    def self.get_player_info(playerUniqueId)
+      body = { playerUniqueId: playerUniqueId }
+      body["hash"] = Gameball::Utils::hashBody(playerUniqueId: playerUniqueId)
+      res = Gameball::Utils::request("post", "/integrations/Player/Info", body)
+      # Check for HTTP Success and throws error if not success
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
+      else
+        return res
+      end
     end
-end
+  end
+end

data/lib/gameball/models/referral.rb

@@ -1,23 +1,27 @@
 module Gameball
-    class Referral
-        def self.create_referral(body)
-            Gameball::Utils.validate(body,['playerUniqueId','playerCode'],['playerAttributes'])
-            if body.has_key?(:playerAttributes)
-            # Gameball::Utils.validate(body[:playerAttributes],['displayName','firstName','lastName','email','gender','mobileNumber','dateOfBirth','joinDate'],['custom'])
-            end
-            res=Gameball::Utils::request("post","/integrations/referral",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return true
-            end
-        end
-        def self.create_referral_async(body)
-            Gameball::Utils.validate(body,['playerUniqueId','playerCode'],['playerAttributes'])
-            if body.has_key?(:playerAttributes)
-            # Gameball::Utils.validate(body[:playerAttributes],['displayName','firstName','lastName','email','gender','mobileNumber','dateOfBirth','joinDate'],['custom'])
-            end
-            Gameball::Utils::request_async("post","/integrations/referral",body)
+  class Referral
+    def self.create_referral(body)
+      Gameball::Utils.validate(body, ["playerUniqueId", "playerCode"], ["playerAttributes"])
+      if body.has_key?(:playerAttributes)
+        # Gameball::Utils.validate(body[:playerAttributes],['displayName','firstName','lastName','email','gender','mobileNumber','dateOfBirth','joinDate'],['custom'])
+      end
+      res = Gameball::Utils::request("post", "/integrations/referral", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
+      else
+        return true
+      end
+    end
+    def self.create_referral_async(body)
+      Gameball::Utils.validate(body, ["playerUniqueId", "playerCode"], ["playerAttributes"])
+      if body.has_key?(:playerAttributes)
+        # Gameball::Utils.validate(body[:playerAttributes],['displayName','firstName','lastName','email','gender','mobileNumber','dateOfBirth','joinDate'],['custom'])
+      end
+      Gameball::Utils::request_async("post", "/integrations/referral", body)
     end
-end
+  end
+end

data/lib/gameball/models/transaction.rb

@@ -1,73 +1,99 @@
 module Gameball
-    class Transaction
-        # include Gameball::Utils
-        def self.get_player_balance (playerId)
-            hashedBody=Gameball::Utils::hashBody(playerUniqueId:playerId)
-            body={playerUniqueId:playerId,
-                bodyHashed:hashedBody
-            }
-            res=Gameball::Utils::request("post","/integrations/transaction/balance",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return res
-            end
-        end
-        def self.hold_points(body) 
-            puts body
-            # check if attributes are available
-            Gameball::Utils.validate(body,['playerUniqueId','amount','transactionTime'],['otp'])
+  class Transaction
+    # include Gameball::Utils
+    def self.get_player_balance(playerId)
+      hashedBody = Gameball::Utils::hashBody(playerUniqueId: playerId)
+      body = { playerUniqueId: playerId,
+               hash: hashedBody }
+      res = Gameball::Utils::request("post", "/integrations/transaction/balance", body)
+      unless res.kind_of? Net::HTTPSuccess
+        raise Gameball::GameballError.new(res.body) 
+      else
+        return res
+      end
+    end
+    def self.hold_points(body)
+      # puts body
+      # check if attributes are available
 
-            body=Gameball::Utils::extractAttributesToHash(body)
-            res=Gameball::Utils::request("post","/integrations/transaction/hold",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return res
-            end
+      Gameball::Utils.validate(body, ["playerUniqueId", "amount"], ["otp"])
+      body[:transactionTime] = Time.now.utc
+      body = Gameball::Utils::extractAttributesToHash(body)
+      res = Gameball::Utils::request("post", "/integrations/transaction/hold", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
-        def self.redeem_points(body) 
-            # check if attributes are available
-            Gameball::Utils.validate(body,['holdReference','playerUniqueId','amount','transactionOnClientSystemId','transactionTime'],[])
-            body=Gameball::Utils::extractAttributesToHash(body)
-            res=Gameball::Utils::request("post","/integrations/transaction/redeem",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return res
-            end
+      else
+        return res
+      end
+    end
+    def self.redeem_points(body)
+      # check if attributes are available
+      Gameball::Utils.validate(body, ["holdReference", "playerUniqueId", "transactionId"], [])
+      body[:transactionTime] = Time.now.utc
+      body = Gameball::Utils::extractAttributesToHash(body)
+      res = Gameball::Utils::request("post", "/integrations/transaction/redeem", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
-        def self.reverse_transaction(body)
-            Gameball::Utils.validate(body,['reversedTransactionOnClientSystemId','playerUniqueId','transactionOnClientSystemId','transactionTime'],[])
-            body=Gameball::Utils::extractAttributesToHash(body)
-            res=Gameball::Utils::request("post","/integrations/transaction/cancel",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return res
-            end
+      else
+        return res
+      end
+    end
+    def self.reverse_transaction(body)
+      Gameball::Utils.validate(body, ["reversedTransactionId", "playerUniqueId", "transactionId"], [])
+      body[:transactionTime] = Time.now.utc
+
+      body = Gameball::Utils::extractAttributesToHash(body)
+      res = Gameball::Utils::request("post", "/integrations/transaction/cancel", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
-         def self.reward_points(body)
-            Gameball::Utils.validate(body,['playerUniqueId','amount','transactionOnClientSystemId','transactionTime'],['playerAttributes'])
-            body=Gameball::Utils::extractAttributesToHash(body)
-            res=Gameball::Utils::request("post","/integrations/transaction/reward",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return true
-            end
+      else
+        return res
+      end
+    end
+    def self.reward_points(body)
+      Gameball::Utils.validate(body, ["playerUniqueId", "amount", "transactionId"], ["playerAttributes"])
+      body[:transactionTime] = Time.now.utc
+
+      body = Gameball::Utils::extractAttributesToHash(body)
+      res = Gameball::Utils::request("post", "/integrations/transaction/reward", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
-        def self.reverse_hold(body)
-            # check if holdReference is in body else throw error
-            Gameball::Utils.validate(body,['holdReference','playerUniqueId','transactionTime'],[])
+      else
+        return true
+      end
+    end
+    def self.reverse_hold(body)
+      # check if holdReference is in body else throw error
+      Gameball::Utils.validate(body, ["holdReference", "playerUniqueId"], [])
+      body[:transactionTime] = Time.now.utc
 
-            body=Gameball::Utils::extractAttributesToHash(body)
-            res=Gameball::Utils::request("post","/integrations/transaction/hold",body)
-            unless res.kind_of? Net::HTTPSuccess
-                raise Gameball::GameballError.new(res.body) # use custom message
-            else 
-                return res
-            end
+      body = Gameball::Utils::extractAttributesToHash(body)
+      res = Gameball::Utils::request("post", "/integrations/transaction/hold", body)
+      unless res.kind_of? Net::HTTPSuccess
+        if res.kind_of? Net::HTTPInternalServerError
+          raise Gameball::GameballError.new("An Internal Server Error has occurred")
+        else
+          raise Gameball::GameballError.new(res.body) 
         end
+      else
+        return res
+      end
     end
-end
+  end
+end

data/lib/gameball/utils/helper.rb

@@ -1,39 +1,35 @@
 module Gameball
-    module Utils
-        extend self
-        def hashBody(playerUniqueId:,transactionTime:"",amount:"")
-            # Check if transaction Key is provided else raise Exc
-            if !Gameball.transaction_key
-            raise Gameball::GameballError.new("Please provide transaction_key, try Gameball::transaction_key='your_key'") # Raise exception 
-            else
-                if transactionTime=="" 
-                    formatted_time=""
-                else
-                    # begin
-                      formatted_time=transactionTime.strftime("%y%m%d%H%M%S")
-                    # rescue  => exception
-                        
-                    # end
-                end
-            end
-            str=playerUniqueId+":"+formatted_time+":"+amount.to_s+":"+Gameball.transaction_key
-            puts str
-            return Digest::SHA1.hexdigest (str)
-        end
-        def extractAttributesToHash(body)
-            playerUniqueId=body[:playerUniqueId]
-            amount=body[:amount]
-            transactionTime=body[:transactionTime]
-            begin
-            body[:transactionTime]=transactionTime.iso8601
+  module Utils
+    extend self
 
-            rescue NoMethodError => exception
-                raise Gameball::GameballError.new("Invalid Date Formate, Please use Date and Time objects")
-            end
-            body["bodyHashed"]=Gameball::Utils::hashBody(playerUniqueId:playerUniqueId,amount:(amount||""),transactionTime:(transactionTime||""))
-            body
+    def hashBody(playerUniqueId:, transactionTime: "", amount: "") # Helper method that hashes the attributes that are sent using SHA1 algorithm
+      # Check if transaction Key is provided else raise Error
+      if !Gameball.transaction_key
+        raise Gameball::GameballError.new("Please provide transaction_key, try Gameball::transaction_key='your_key'") # Raise exception
+      else
+        if transactionTime == ""
+          formatted_time = ""
+        else
+          formatted_time = transactionTime.strftime("%y%m%d%H%M%S")
         end
-        
+      end
+
+      str = playerUniqueId + ":" + formatted_time + ":" + amount.to_s + ":" + Gameball.transaction_key
+      return Digest::SHA1.hexdigest (str)
+    end
+
+    def extractAttributesToHash(body) # Helper method that extracts the attributes from the body and pass it to hashing function
+      playerUniqueId = body[:playerUniqueId]
+      amount = body[:amount]
+      transactionTime = body[:transactionTime]
+      begin
+        body[:transactionTime] = transactionTime.iso8601
+      rescue NoMethodError => exception
+        raise Gameball::GameballError.new("Invalid Date Formate, Please use Date and Time objects")
+      end
 
+      body["hash"] = Gameball::Utils::hashBody(playerUniqueId: playerUniqueId, amount: (amount || ""), transactionTime: (transactionTime || ""))
+      body
     end
-end
+  end
+end

data/lib/gameball/utils/request.rb

@@ -1,99 +1,73 @@
 module Gameball
-    module Utils
-        extend self
-        def request(verb,path,body={})
-        #check for api_version and key and throw exceptions
-        if  !Gameball.api_key
-            raise Gameball::GameballError.new("Please provide the api_key before making a request, try Gameball::api_key='your_key'")
-        end
-        uri=URI(Gameball.api_base+'/api'+'/'+Gameball.api_version+path)
+  module Utils
+    extend self
 
-            https = Net::HTTP.new(uri.host,uri.port)
-            https.max_retries=Gameball.max_retries
-            https.read_timeout=Gameball.read_timeout
-            https.keep_alive_timeout=Gameball.keep_alive_timeout
-            https.use_ssl = true
-        
-              case verb.downcase
-            when "post"
-                req = Net::HTTP::Post.new(uri.path, initheader = {'Content-Type' =>'application/json'})
+    def request(verb, path, body = {})
+      # check for api_version and key and throw error if not included
+      if !Gameball.api_key
+        raise Gameball::GameballError.new("Please provide the api_key before making a request, try Gameball::api_key='your_key'")
+      end
+      uri = URI(Gameball.api_base + "/api" + "/" + Gameball.api_version + path)
 
-            when "get"
-                
-                req = Net::HTTP::Get.new(uri.path, initheader = {'Content-Type' =>'application/json'})
-            when "put"
-                
-                req = Net::HTTP::Put.new(uri.path, initheader = {'Content-Type' =>'application/json'})
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.max_retries = Gameball.max_retries
+      https.read_timeout = Gameball.read_timeout
+      https.keep_alive_timeout = Gameball.keep_alive_timeout
+      https.use_ssl = true
 
-            when "delete"
-                req = Net::HTTP::Delete.new(uri.path, initheader = {'Content-Type' =>'application/json'})
-            else 
-                puts "Please Provide a valid verb" # will later throw an exception
-            end
-            if body != {}
-                puts body
-                # begin
-                req.body=body.to_json 
-                p req.body   
-                # rescue JSON::ParserError => exception
-                    
-                # end
-                
-            end
-            req['APIKey']=Gameball.api_key
-            res=https.request(req)
-            return res
-            
-        end
-
-        def request_async(verb,path,body={})
-        #check for api_version and key and throw exceptions
-        if  !Gameball.api_key
-            raise Gameball::GameballError.new("Please provide the api_key before making a request, try Gameball::api_key='your_key'")
-        end
-        uri=URI(Gameball.api_base+'/api'+'/'+Gameball.api_version+path)
+      case verb.downcase
+      when "post"
+        req = Net::HTTP::Post.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      when "get"
+        req = Net::HTTP::Get.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      when "put"
+        req = Net::HTTP::Put.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      when "delete"
+        req = Net::HTTP::Delete.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      else
+        raise Gameball::GameballException.new("Please provide a valid HTTP Verb") # will later throw an exception
+      end
+      if body != {}
+        req.body = body.to_json
+      end
+      req["APIKey"] = Gameball.api_key
+      res = https.request(req)
+      return res
+    end
 
-            https = Net::HTTP.new(uri.host,uri.port)
-            https.max_retries=Gameball.max_retries
-            https.read_timeout=Gameball.read_timeout
-            https.keep_alive_timeout=Gameball.keep_alive_timeout
-            https.use_ssl = true
-        
-              case verb.downcase
-            when "post"
-                req = Net::HTTP::Post.new(uri.path, initheader = {'Content-Type' =>'application/json'})
+    def request_async(verb, path, body = {})
+      #check for api_version and key and throw exceptions
+      if !Gameball.api_key
+        raise Gameball::GameballError.new("Please provide the api_key before making a request, try Gameball::api_key='your_key'")
+      end
+      uri = URI(Gameball.api_base + "/api" + "/" + Gameball.api_version + path)
 
-            when "get"
-                
-                req = Net::HTTP::Get.new(uri.path, initheader = {'Content-Type' =>'application/json'})
-            when "put"
-                
-                req = Net::HTTP::Put.new(uri.path, initheader = {'Content-Type' =>'application/json'})
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.max_retries = Gameball.max_retries
+      https.read_timeout = Gameball.read_timeout
+      https.keep_alive_timeout = Gameball.keep_alive_timeout
+      https.use_ssl = true
 
-            when "delete"
-                req = Net::HTTP::Delete.new(uri.path, initheader = {'Content-Type' =>'application/json'})
-            else 
-                puts "Please Provide a valid verb" # will later throw an exception
-            end
-            if body != {}
-                puts body
-                # begin
-                req.body=body.to_json 
-                p req.body   
-                # rescue JSON::ParserError => exception
-                    
-                # end
-                
-            end
-            req['APIKey']=Gameball.api_key
-           Thread.new do
-            res=https.request(req)
-            return res
-            p "I am in thread"+res.body
-            end
-            # thread.join
-            # return res
-        end
+      case verb.downcase
+      when "post"
+        req = Net::HTTP::Post.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      when "get"
+        req = Net::HTTP::Get.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      when "put"
+        req = Net::HTTP::Put.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      when "delete"
+        req = Net::HTTP::Delete.new(uri.path, initheader = { "Content-Type" => "application/json" })
+      else
+        puts "Please Provide a valid verb" # will later throw an exception
+      end
+      if body != {}
+        req.body = body.to_json
+      end
+      req["APIKey"] = Gameball.api_key
+      Thread.new do
+        res = https.request(req)
+        return res
+      end
     end
-
-end
+  end
+end