ige_isb_api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eedefc82170ca579c704dfdf1e57c7ee9c26f678
+  data.tar.gz: 2613b9f124480ec526c9bff89d767c2ac1a95bb8
+SHA512:
+  metadata.gz: 3f272430acbef313ecf54b19121161f2d5af937477aece73f6dfa9e9111f627b53e469db6f74dc19ebc2e195e11b4b0582803b16b3f7bb40ff327e5761e2b46b
+  data.tar.gz: f3f7ad6149cdd39b2d584f2dc78d2213ada3c4a9c0b6b376beee0c271011a64682142c3cc422429b0d8ecd7414b45ddab58c0d05fb6930297dcec596e69f3bf9

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ige_isb_api.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    ige_isb_api (1.0.0)
+      nokogiri
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    dotenv (0.9.0)
+    mini_portile (0.5.2)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  dotenv
+  ige_isb_api!
+  rake
+  rspec (~> 2.6)

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Interactive-Gaming-Entertainment
+
+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,237 @@
+IGE's Wrapper for ISB APIs
+==========================
+
+Ruby Wrapper for ISB's `User API Version 2.1`, as well as the documents
+`Integrating ISB HTML5 Games_v1.3` and `Integrating ISB Flash Games_v1.4` (available from ISB), and ISB Bonus API version 1.5.
+
+## Usage
+
+1. Add `gem 'ige_isb_api'` to your `Gemfile` and `require 'ige_isb_api`
+2. Ensure the environment variables (see below) have been configured, and your IP has been whitelisted by the people at [ISB](http://www.isoftbet.com).
+3. do something like this:
+
+```Ruby
+  api = IGE_ISB_API::UserAPI.new username: 'player-username', password: "notwhattheplayerusesforyourcasino"
+  txid = 12345 # must be unique
+  response = api.register "some label", txid, email: "username@test.tes",
+                                            name: "Surname",
+                                            firstname: "Firstname",
+                                            zip: "123456",
+                                            city: "Somewhere",
+                                            phone: "000000000",
+                                            dob: "2011-11-21",
+                                            country: "gb",
+                                            ip: '172.0.0.1'
+  response = api.login label, txid + 1
+  response = api.deposit label, txid + 2, wallet: 'test', amount: 5000, reference: 'test deposit'
+  response = api.withdrawal label, txid + 3, wallet: 'test', amount: 5000, reference: 'test withdrawal'
+  response = api.ban label, txid + 4
+  response = api.deactivate label, txid + 5
+  response = api.activate label, txid + 6
+  response = api.get_vip_points label, txid + 7
+  response = api.save_friend_email label, txid + 8, invitedname: "Bob Brown", invitedemail: 'bob@bro.wn'
+  response = api.limits label, txid + 9, limitationtype: "deposit", amount: 5000, frequency: 'weekly', until: "2015-11-21"
+
+```
+
+See the ISB User API docs (supplied by ISB) for details of the API commands and parameters.
+
+### Loading Games
+
+You can use this API to parse the games list XML file and associated Game Info XML files.
+
+```Ruby
+games_list = IGE_ISB_API::Games.new
+games_list.load_from_xml("http://someserver/some_games_list.xml", some_language_code) # language will default to 'en'
+games_list.categories.each do |category|
+  category.games.each do |game|
+    game.load_info(game.game_info_url)
+    if errors.size == error_count
+      # do whatever you wish to do with the game data
+    end
+  end
+end
+```
+
+### Data Integrity
+
+The data that comes from ISB can be inconsistent at times. The `load_info` method will return an array of errors if there are any. Games that return errors should be skipped on load.
+
+You can also call the `game`'s `warnings` method to get a list of any specific non-fatal warnings about the data.
+
+Expand upon the code above as follows to parse for errors and warnings. 
+
+```Ruby
+games_list = IGE_ISB_API::Games.new
+games_list.load_from_xml("http://someserver/some_games_list.xml", some_language_code) # language will default to 'en'
+errors = []
+warnings = []
+games_list.categories.each do |category|
+  category.games.each do |game|
+    error_count = errors.size
+    errors = errors | game.load_info(game.game_info_url)
+    if errors.size == error_count
+      warnings = warnings | game.warnings
+      # do whatever else you wish to do with the game data
+    end
+  end
+end
+if !errors.empty?
+  errors.each {|e| puts "#{e[:game].name}: #{e[:message]}"}
+end
+if !warnings.empty?
+  warnings.each {|w| puts "#{w[:game].name}: #{w[:message]}"}
+end
+```
+
+Your games loader code must loop through all of the langaues specified in `IGE_ISB_API::Cosntants::LANGUAGES` and
+load game data for each language.  Different language game data will have the same `identifier` and `skin_id` so your games database will need to know to save language specific versions of each game's name and description.
+
+### Embedding a Flash game in 'fun' mode
+
+```Ruby
+embed = IGE_ISB_API::Game.embed_game_html host: g.get_info(:fun).host, currency: 'EUR',
+                                          colour: '#000000', name: g.name, game_swf_path: g.game_swf_path(:fun),
+                                          fun: true, coin_min: g.coin_min, casino: g.casino,
+                                          main_category: g.main_category, language: g.language, identifier: g.identifier,
+                                          game_swf_url: g.game_swf_url(:fun), wmode: g.wmode, gm_api: 0
+```
+
+### Embedding a Flash game in 'real' mode
+
+```Ruby
+embed = IGE_ISB_API::Game.embed_game_html host: g.get_info(:real).host, player_id: 'player_id', currency: 'EUR',
+                                          colour: '#000000', name: g.name, game_swf_path: g.game_swf_path(:real),
+                                          fun: false, coin_min: g.coin_min, casino: g.casino,
+                                          main_category: g.main_category, language: g.language, identifier: g.identifier,
+                                          game_swf_url: g.game_swf_url(:real), wmode: g.wmode, idrequest: 'somethingunique', gm_api: 0
+```
+
+### Using Google's [swfobject](http://code.google.com/p/swfobject/) Flash Embedder in 'fun' mode
+
+```Ruby
+embed = IGE_ISB_API::Game.embed_swfobject host: g.get_info(:fun).host, currency: 'EUR',
+                                          colour: '#000000', name: g.name, game_swf_path: g.game_swf_path(:fun),
+                                          fun: true, coin_min: g.coin_min, casino: g.casino,
+                                          main_category: g.main_category, language: g.language, identifier: g.identifier,
+                                          game_swf_url: g.game_swf_url(:fun), wmode: g.wmode, container: 'some-div-id', gm_api: 0
+```
+
+### Using Google's [swfobject](http://code.google.com/p/swfobject/) Flash Embedder in 'real' mode
+
+```Ruby
+embed = IGE_ISB_API::Game.embed_swfobject host: g.get_info(:real).host, player_id: 'player_id', currency: 'EUR',
+                                          colour: '#000000', name: g.name, game_swf_path: g.game_swf_path(:real),
+                                          fun: false, coin_min: g.coin_min, casino: g.casino,
+                                          main_category: g.main_category, language: g.language, identifier: g.identifier,
+                                          game_swf_url: g.game_swf_url(:real), wmode: g.wmode, container: 'some-div-id',
+                                          idrequest: 'somethingunique', gm_api: 0
+```
+
+### Launching an HTML5 game in 'fun' mode
+
+```Ruby
+url = IGE_ISB_API::Game.game_launcher_url currency: 'EUR', fun: true,
+                                          language: g.language, game_html5_url: g.game_html5_url(:fun)
+```
+
+### Launching an HTML5 game in 'real' mode
+
+```Ruby
+url = IGE_ISB_API::Game.game_launcher_url player_id: 'player_id', currency: 'EUR', fun: false,
+                                          language: g.language, game_html5_url: g.game_html5_url(:real),
+                                          idrequest: 'somethingunique'
+```
+
+## Parsing Callback Data
+
+Once a player has finished their gameplay session, ISB will post session details back
+to the casino server in the form of a JSON serialized blob of data.
+You can easily parse that data into a standard Ruby Hash for your application to use as needed.
+
+```Ruby
+data = IGE_ISB_API::Callback.parse raw_data
+player = data[:player]                # player login as passed in via IGE_ISB_API.register
+requestid = data[:requestid]          # the request id passed in when the game is launched.
+session_start = data[:session_start]  # a Time object in UTC timezone
+session_start = data[:session_end]    # a Time object in UTC timezone
+actions = data[:actions]              # an array of actions
+skinid = data[:skinid]                # the unique 'skin' number of the game.
+currency = data[:currency]            # an ISO code
+hostid = data[:hostid]                # an Integer (see notes on hostID in environnent variables below)
+data[:actions].each do |act|
+  action = act[:action]               # :bet or :win
+  amount = act[:amount]               # float
+end
+```
+
+It will throw an `IGE_ISB_API::ValidationException` if the incoming data is bad.
+
+## The Bonus API
+
+```Ruby
+b = IGE_ISB_API::BonusAPI.new
+response = b.get_trigger_bonus login: 'someplayer', trigger: 'deposit'
+```
+
+See the ISB Bonus API document (version 1.4) for appropriate options:
+
+* `get_trigger_bonus`
+* `get_client_bonuses`
+* `count_client_bonuses`
+* `has_pending_offers`
+* `accept_bonus`
+* `decline_bonus`
+* `get_remaining_playthrough`
+* `remove_bonus_and_winnings_on_withdraw`
+* `issue_bonus`
+* `cancel_bonus`
+* `reset_bonus`
+* `update_active_balance_current_value`
+* `assign_certificate_to_player`
+* `bonus_vip_points`
+* `generate_certificate`
+* `generate_player_assigned_certificate`
+* `get_template_id_by_name`
+* `count_promo_codes`
+* `sum_bonuses`
+* `is_transaction_used`
+* `get_player_assigned_certificates`
+* `delete_player_assigned_certificate`
+* `delete_generated_certificate`
+* `certificate_exists`
+
+## Building and Testing
+
+### Installing Nokogiri
+
+This GEM uses [Nokogiri](http://nokogiri.org) to parse XML files.
+See [these instructions](http://nokogiri.org/tutorials/installing_nokogiri.html) for how best to install it on your local system.
+
+### Environment Variables
+
+You must set the following environment variables (provided by ISB) for this code to work.
+
+You can put them into a `.env` file if you wish.
+
+* `ISB_API_SERVER`
+* `ISB_BONUS_API_SERVER`
+* `ISB_FUN_URL` which must end in a `/`
+* `ISB_LIVE_URL` which must end in a `/`
+* `ISB_SECRET_KEY`
+* `ISB_BONUS_API_KEY`
+* `ISB_BONUS_SECRET_KEY`
+* `ISB_LICENSEE_ID`
+* `ISB_CASINO_ID`
+* `ISB_CALLBACK_ID`
+
+The `ISB_CALLBACK_ID` is an integer that relates to a specific callback URL registered with ISB. For ISB's server to be able to send callbacks to your system you must register your URLs with them, and use appropriate integer as provided by them.  This allows you to develop and test your system, including callbacks, without compromising your live production system.
+
+### To Test
+
+To run the tests you must ensure that an appropriate environment variables have been configured
+(in a `.env` file, or otherwise) and that the IP number you are testing from has been whitelisted
+by ISB's people.  Then simply run:
+
+    bundle exec rake
+

data/ige_isb_api.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ige_isb_api/version'
+require 'ige_isb_api/constants'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ige_isb_api"
+  spec.version       = IGE_ISB_API::VERSION
+  spec.authors       = ["Dave Sag"]
+  spec.email         = ["davesag@gmail.com"]
+  spec.description   = "Implements all of the features of the ISB API version #{IGE_ISB_API::Constants::API_VERSION}."
+  spec.summary       = "A Ruby Wrapper for the ISB API version #{IGE_ISB_API::Constants::API_VERSION}"
+  spec.homepage      = "https://github.com/Interactive-Gaming-Entertainment/IGE_ISB_API"
+  spec.license       = "MIT"
+  spec.date          = Time.now.utc.strftime("%Y-%m-%d")
+
+  spec.files         = `git ls-files`.split($/) - %w(.rspec .gitignore Rakefile) - `git ls-files test_data`.split($/) - `git ls-files spec`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features|test_data)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "nokogiri"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.6"
+  spec.add_development_dependency "dotenv"
+end

data/lib/ige_isb_api.rb

@@ -0,0 +1,49 @@
+#!/user/bin/env ruby
+#coding: utf-8
+
+require "ige_isb_api/user_api"
+require "ige_isb_api/bonus_api"
+require "ige_isb_api/bonus"
+require "ige_isb_api/callback"
+require "ige_isb_api/constants"
+require "ige_isb_api/games"
+require "ige_isb_api/request"
+require "ige_isb_api/validation"
+require "ige_isb_api/version"
+
+module IGE_ISB_API
+
+  # define errors and exceptions.
+  class IGE_ISB_API_Error < RuntimeError
+  end
+  class InternalException < IGE_ISB_API_Error
+  end
+  class ValidationException < IGE_ISB_API_Error
+  end
+
+  # module level method to get the redirection URL given some params.
+  def self.request(params = {})
+    result = nil
+
+    begin
+      request = IGE_ISB_API::Request.new(params)
+      return request
+
+    rescue InternalException => e
+      puts "Caught Internal Exception: #{e.message}"
+      puts e.backtrace
+      raise RuntimeError, "Internal server error. Please try again later."
+
+    rescue ValidationException => e
+      puts "Caught Validation Exception: #{e.message}"
+      puts e.backtrace
+      raise RuntimeError, "Validation error: #{e.message} Fix your data and retry."
+
+    rescue IGE_ISB_API_Error => e
+      puts "Caught General IGE_ISB_API Error: #{e.message}"
+      puts e.backtrace
+      raise RuntimeError, "Undocumented Internal error: #{e.message}"
+    end
+  end
+
+end

data/lib/ige_isb_api/api.rb

@@ -0,0 +1,251 @@
+#!/user/bin/env ruby
+#coding: utf-8
+
+module IGE_ISB_API
+  class API
+
+    # the following options *must* be passed in.
+    #     username: "some_username specific to iSoftBet",
+    #     password: "should be specific to iSoftBet",
+    # The following options may be passed in and are presented here with their defaults.
+    #     cur: IGE_ISB_API::Constants::DEFAULT_CURRENCY_CODE,
+    #     carte: IGE_ISB_API::Constants::CASINO,
+    #     lang: IGE_ISB_API::Constants::DEFAULT_LANGUAGE,
+    def initialize(player_status = IGE_ISB_API::Constants::TEST, opts = {})
+      raise ArgumentError, "Missing options." if opts.empty?
+      @options = {
+        cur: IGE_ISB_API::Constants::DEFAULT_CURRENCY_CODE,
+        carte: IGE_ISB_API::Constants::CASINO,
+        lang: IGE_ISB_API::Constants::DEFAULT_LANGUAGE,
+        status: player_status
+      }.merge(opts)
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # the following options *must* be passed in.
+    #     email: "the user's email address",
+    #     name: "the user's surname",
+    #     firstname: "the user's first name",,
+    #     zip: "the user's postcode",
+    #     city: "the user's city",
+    #     phone: "the user's phone number",
+    #     dob: "in 2011-11-21 format",
+    #     country: "the ISO country code for the user",
+    #     ip: request.ip
+    #
+    # The following may be passed in and are presented here with their defaults.
+    #     cur: IGE_ISB_API::Constants::DEFAULT_CURRENCY_CODE,
+    #     status: IGE_ISB_API::Constants::TEST,
+    #     carte: IGE_ISB_API::Constants::CASINO,
+    #     lang: 'en',
+    #     gender: IGE_ISB_API::Constants::MALE,
+    def register(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      raise ArgumentError, "Missing options." if opts.empty?
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  status: @options[:status],
+                  cur: @options[:cur],
+                  lang: @options[:lang],
+                  carte: @options[:carte],
+                  gender: IGE_ISB_API::Constants::MALE,
+                  txid: txid}.merge(opts).merge({ command: 'registration', idaffiliation: IGE_ISB_API::Constants::LICENSEE_ID })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # The following may be passed in and is presented here with its default.
+    #     carte: defaults to IGE_ISB_API::Constants::CASINO can can be overridden if user is logging in from
+    #            a different casino under the control of the same licensee.
+    def login(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  carte: @options[:carte],
+                  txid: txid}.merge(opts).merge({ command: 'login' })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # the following options *must* be passed in.
+    #     wallet: "the name of the payment processor being used",
+    #     amount: a positive floating point number,
+    #     reference: "for logging purposes",
+    #
+    # The following may be passed in and are presented here with their defaults.
+    #     cur: defaults to IGE_ISB_API::Constants::DEFAULT_CURRENCY_CODE
+    def deposit(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      raise ArgumentError, "Missing options." if opts.empty?
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  cur: @options[:cur],
+                  txid: txid}.merge(opts).merge({ command: 'deposit' })
+      reference = "#{@params[:wallet]}:#{@params[:reference]}#{@params[:cur]}"
+      @params.merge!(reference: reference)
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # the following options *must* be passed in.
+    #     wallet: "the name of the payment processor being used",
+    #     amount: a positive floating point number,
+    #     reference: "for logging purposes",
+    #
+    # The following may be passed in and are presented here with their defaults.
+    #     cur: defaults to IGE_ISB_API::Constants::DEFAULT_CURRENCY_CODE
+    def withdrawal(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      raise ArgumentError, "Missing options." if opts.empty?
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  cur: @options[:cur],
+                  txid: txid}.merge(opts).merge({ command: 'withdrawal' })
+      reference = "#{@params[:reference]}#{@params[:cur]}"
+      @params.merge!(reference: reference)
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # the following options *must* be passed in.
+    #     limitationtype: 'DEPOSIT', 'DEPOSIT_EXTRA', 'BET', 'LOSS', 'TIME', 'EXCLUSION'
+    #     amount: a positive floating point number,
+    #     frequency: "WEEKLY", DAILY, MONTHLY, 1..n days - for exclusion
+    #     until: "YYYY-MM-DD" or -1 for unlimited.
+    #
+    # The following may be passed in and are presented here with their defaults.
+    #     cur: defaults to IGE_ISB_API::Constants::DEFAULT_CURRENCY_CODE
+    def limits(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      raise ArgumentError, "Missing options." if opts.empty?
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge(opts).merge({ command: 'limits' })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    def deactivate(label = '', txid = 0)
+      validate_params!(label, txid)
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge({ command: 'userstatus', flag: IGE_ISB_API::Constants::USER_INACTIVE })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    def activate(label = '', txid = 0)
+      validate_params!(label, txid)
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge({ command: 'userstatus', flag: IGE_ISB_API::Constants::USER_ACTIVE })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    def ban(label = '', txid = 0)
+      validate_params!(label, txid)
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge({ command: 'userstatus', flag: IGE_ISB_API::Constants::USER_BANNED })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # the following option *must* be passed in.
+    #     newpassword: 'some new password',
+    def change_password(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      raise ArgumentError, "Missing options." if opts.empty?
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge(opts).merge({ command: 'pass'})
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    def get_vip_points(label = '', txid = 0)
+      validate_params!(label, txid)
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge({ command: 'get_vip_points' })
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    # Each command has a label which is used by the casino to tag a group of interactions with ISB
+    # Additionally each transaction must include a unique transaction ID.
+    # the following options *must* be passed in.
+    #     invitedname: 'some new password',
+    #     invitedemail: 'some new password',
+    def save_friend_email(label = '', txid = 0, opts = {})
+      validate_params!(label, txid)
+      raise ArgumentError, "Missing options." if opts.empty?
+      @params = { idrequest: label,
+                  username: @options[:username],
+                  password: @options[:password],
+                  txid: txid}.merge(opts).merge({ command: 'save_friend_email'})
+      request = IGE_ISB_API.request(@params)
+      resp = request.send
+      response = JSON.parse(resp.body)
+      return response
+    end
+
+    private
+    
+    def validate_params!(label, txid)
+      raise ArgumentError, "Missing a valid label." if label.empty?
+      raise ArgumentError, "Missing a valid transaction ID." if txid <= 0
+    end
+
+  end
+end