eme_services_client 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d2cc3fdf5fc14a7e25ee4744f916260a4a7a011
+  data.tar.gz: 7192366bb021bb78d12e55605b56a7714a2b700f
+SHA512:
+  metadata.gz: b042ea84d0fcf96f92663e071728c2a709e01cc2219e224cf11a431a2007dbda676fdc685372a8c65599c7e365fc5f926a717608ef75ae491dc9b68a362dcd86
+  data.tar.gz: 931b955f67ffaecf09f663c8a2e78e2788cd93537400e0e5984ed2b3b357a3e29f365df4b62fb9f30a8872b3683b02c23764f9f0268cd010616a02c83dbf38ba

data/lib/eme/admin_user.rb

@@ -0,0 +1,132 @@
+require 'api_consumer'
+
+module EME
+  class AdminUser < APIConsumer
+    # if successful username/password combo, it should return a unique 16 digit hex session id for the user.
+    #     {"admin_session_key": "432423h13h341ab2", "error": false}
+    # if failed it should return error true, and error message.
+    #     {"error": true, "message": "Incorrect email/password combination."}
+    # NOTE: This is the only call that does not require an admin_session_key in the headers/cookies, still requires the API_KEY.
+    def self.login(email, password, conn = connection, opts = {})
+      opts[:method] = :post
+      opts[:body] = {:email => email, :password => password}.to_json
+      return do_request("/users/login", conn, opts_work(opts))
+    end
+
+    # a get or delete call.  It only requires the first 8 digits of the admin_session_key, but will accept all 16 digits.
+    def self.logout(admin_session_key, conn = connection, opts = {})
+      opts[:method] = :delete
+      return do_request("/users/logout", conn, opts_work(opts, admin_session_key))
+    end
+
+    # returns all users if they are still logged in, and have permissions to see all users, user data only includes, id, name, last_login, roles, and current_logged_in_status
+    def self.all_users(admin_session_key, conn = connection, opts={})
+      return do_request("/users", conn, opts_work(opts, admin_session_key))
+    end
+
+    # returns specific users data, DO NOT include session_key_id, or password/hashed_password. Requires permission check.
+    def self.user(user_id, admin_session_key, conn = connection, opts={})
+      return do_request("/users/#{user_id}", conn, opts_work(opts, admin_session_key))
+    end
+
+    # takes a hash of user info, and posts it to the service to edit the user record, if they have permissions.
+    # if there is a password change it requires the fields password, and confirmed password.
+    def self.update_user(user_data, admin_session_key, conn = connection, opts={})
+      opts[:method] = :post
+      opts[:body] = user_data.to_json
+      return do_request("/users/#{user_id}", conn, opts_work(opts, admin_session_key))
+    end
+
+    # requires admin_session_key.  Just returns true or false if you are still logged in or not.
+    # if still logged in: returns json {"logged_in": true, "permissions_updated": false}
+    # Most likely to be used via AJAX on the front end.
+    def self.heartbeat(admin_session_key, conn = connection, opts={})
+      return do_request("/users/heartbeat", conn, opts_work(opts, admin_session_key))
+    end
+
+    # This is the call that returns the current user data, including permissions and roles, this will be converted to a Session object that will be used by the app to get your logged in status, and permissions, etc.
+    def self.me(admin_session_key, conn = connection, opts={})
+      tmp = do_request("/users/me", conn, opts_work(opts, admin_session_key))
+    end
+
+### ROLES
+
+    # returns all roles if they are still logged in, and have permissions to see all roles, role data only includes, id, name
+    def self.all_roles(admin_session_key, conn = connection, opts={})
+      return do_request("/roles", conn, opts_work(opts, admin_session_key))
+    end
+
+    # returns specific a role's data; id, name, permissions, users with role.
+    def self.role(role_id, admin_session_key, conn = connection, opts={})
+      return do_request("/roles/#{role_id}", conn, opts_work(opts, admin_session_key))
+    end
+
+    # takes a hash of role info(name, and permissions), and posts it to the service to edit the role, if they have permissions.
+    def self.update_role(role_data, admin_session_key, conn = connection, opts={})
+      opts[:method] = :post
+      opts[:body] = role_data.to_json
+      return do_request("/roles/#{user_id}", conn, opts_work(opts, admin_session_key))
+    end
+
+### PERMISSIONS
+
+    # returns all permissions if they are still logged in, and have permissions to see all permissions, permission data only includes, id, controller, action, method
+    def self.all_permissions(admin_session_key, conn = connection, opts={})
+      return do_request("/permissions", conn, opts_work(opts, admin_session_key))
+    end
+
+### SESSION COOKIES
+
+    def self.decode_admin_key_cookie(val, ip)
+      check_salts
+      ((val.to_s.hex ^ self.settings[:pepper].hex) - self.settings[:salt].hex - ipaddress_factor(ip)).to_s(16)
+    end
+    
+    def self.encode_admin_key_cookie(val, ip)
+      check_salts
+      return ((self.settings[:salt].hex + val.to_s.hex + ipaddress_factor(ip)) ^ self.settings[:pepper].hex).to_s(16)
+    end
+    
+    def self.check_salts
+      if(self.settings[:salt].nil? || self.settings[:pepper].nil? || self.settings[:salt].length < 15 || self.settings[:pepper].length < 15)
+        raise RuntimeError, "Requires settings salt and pepper, min length 15."
+      end
+    end
+
+    def self.ipaddress_factor(ip)
+      ip.gsub(/\./, "d").to_i(17) * 93
+    end
+
+    private
+    @@auth_opts = { "Authorization" => "Token token=#{settings[:api_key]}" }
+
+    def self.opts_work(opts, admin_session_key = nil)
+      if opts[:headers].nil?
+        opts[:headers] = @@auth_opts
+      else
+        opts[:headers].merge(@@auth_opts)
+      end
+      opts[:headers]["Authorization"] = "#{opts[:headers]["Authorization"]}|#{admin_session_key}" unless admin_session_key.nil?
+      #opts[:headers]["Authorization"] += "|"+admin_session_key unless admin_session_key.nil?
+      return opts
+    end
+
+    class SessionInfo
+      attr_reader :user, :roles
+      BITS = []
+      
+      def initialize(data)
+        @permissions = data["permissions"]
+        @user = data["user"]
+        @roles = data["roles"]
+      end
+
+      def has_permission?(app, component, action)
+        return @permissions[controller.to_s][action.to_s][method.to_s] if @permissions[controller.to_s] && @permissions[controller.to_s][action.to_s]
+      end
+    end
+  end
+end
+
+require_relative "admin_user/required_login"
+

data/lib/eme/admin_user/required_login.rb

@@ -0,0 +1,44 @@
+class EME::AdminUser::RequiredLogin
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    req = Rack::Request.new(env)
+    
+    # whitelist check/assets
+    if(["/assets/", "/images/"].include?(req.path[0..7]) || (EME::AdminUser.settings[:white_list_paths] && EME::AdminUser.settings[:white_list_paths].include?(req.path)))
+      return @app.call(env)
+    end
+    
+    cookies = req.cookies
+    session = req.session
+    good = false
+    ip = req.ip
+    if session[:admin_session_key]
+      heartbeat = EME::AdminUser.heartbeat(session[:admin_session_key])
+      if heartbeat["logged_in"] == true
+        data = EME::AdminUser.me(session[:admin_session_key])
+        data_permissions = data.delete(:permissions)
+        puts "PERMISSIONS + #{data_permissions}"
+        permissions = EME::AdminUser.all_permissions(session[:admin_session_key])
+
+        if session[:admin_user_info].nil? || heartbeat["permissions"] != "uptodate"
+          session[:admin_user_info] = EME::AdminUser.me(session[:admin_session_key])
+        end
+        good = true
+      end
+    end
+
+    if !good && (req.path != EME::AdminUser.settings[:login_path])
+      return [302, {"Location" => req.base_url + EME::AdminUser.settings[:login_path] }, []]
+    end
+
+    @status, @headers, @response = @app.call(env)
+    if req.cookies["admin_session_key"].nil? && !session[:admin_session_key].nil?
+      Rack::Utils.set_cookie_header!(@headers, "admin_session_key", {:value => EME::AdminUser.encode_admin_key_cookie(session[:admin_session_key], ip), :path => "/", :domain => ".enmasse.com", :expires => Time.now+86400})
+    end
+    return [@status, @headers, @response]
+  end
+end

data/lib/eme/ams.rb

@@ -0,0 +1,29 @@
+require 'api_consumer'
+
+class EME::AMS < APIConsumer
+  
+  def self.game_account(game_account_id, conn = connection)
+    do_request("/api/v1/game_accounts/#{game_account_id}", conn)
+  end
+  
+  def self.game_accounts(master_account_id, conn = connection)
+    do_request("/api/v1/game_accounts/all/#{master_account_id}", conn)
+  end
+  
+  def self.vip_exp()
+    do_request("/api/v1/game-accounts/#{game-account_id}/get_vip_exp")
+  end
+  
+  def self.vip_crystals()
+    do_request("/api/v1/vip/")
+  end
+  
+  def self.add_vip_crystals()
+    
+  end
+  
+  def self.add_vip_exp()
+    # POST
+    #do_request("/api/v1/game-accounts/#{game-account_id}/get_vip_exp")
+  end
+end

data/lib/eme/auth.rb

@@ -0,0 +1,24 @@
+require 'api_consumer'
+
+class EME::Auth < APIConsumer
+  
+  def self.make_ticket(game_account_id, conn = connection)
+    do_request("/ticket/#{game_account_id}", conn)
+  end
+  
+  #http://auth.service.edge.enmasse.com:4567/ticket/TGmMuniGyatDoTnythxyoT-pvad3gTRmRmmiwxv4ozsHK-tgd-/verify_simple
+  def self.verify_simple_ticket(ticket, conn = connection)
+    path = URI.encode("/ticket/#{ticket}/verify_simple")
+    do_request(path, conn, {:method => :post, :errors => {'404' => 'Ticket not found or already used.'}})
+  end
+  
+  def self.verify_ticket(ticket, conn = connection)
+    path = URI.encode("/ticket/#{ticket}/verify")
+    do_request(path, conn, {:method => :post, :errors => {'404' => 'Ticket not found or already used.'}})
+  end
+
+  def self.generate_authentication_token(game_account_id, conn = connection)
+    do_request("/api/v1/generate_authentication_token?game_account_id=#{game_account_id}", conn)
+  end
+
+end

data/lib/eme/billing.rb

@@ -0,0 +1,496 @@
+require 'api_consumer'
+require 'sucker_punch'
+require_relative 'billing/workers/refresh_wallet_worker'
+#require_relative 'billing/store_item'
+
+class EME::Billing < APIConsumer
+  # Fetch the balance of user with external id equal to *external_id*.  Will cache the results for 5 minutes if settings[:use_memcache] is true
+  #
+  # ==== Attributes
+  #
+  # * external_id - master_account_id of the player
+  # * external_account_id - Game id of the game account you are connecting too (required if multiple game accounts)
+  #
+  # ==== Options
+  #
+  # none
+  #
+  # ==== Examples
+  #
+  # EME::Billing.get_wallet(609)
+  def self.reload_wallet(external_id, currency = "EMP", opts = {}, conn = connection)
+    return get_wallet(external_id, currency, opts, conn, true)
+  end
+  
+  def self.get_wallet(external_id, currency = "EMP", opts = {}, conn = connection, reload=false)
+    if settings[:use_memcache] && !reload
+      cached = cache.read("wallet-balance-#{external_id}-#{currency}")
+      return cached if cached
+      backup_cache = cache.read("wallet-balance-#{external_id}-#{currency}-bkup")
+      if backup_cache  # Start ASYNC refresh here
+        RefreshWalletWorker.new.async.perform(external_id, currency, opts)
+        return backup_cache
+      end
+    end
+    gamecode = opts[:game_code] || "TERA"
+    wallet = nil
+    request_path = "/Payment/rest/services/balance/v1/get/#{external_id}/#{gamecode}/#{currency}/"
+  
+    obj_hash = do_request(request_path, conn)
+  
+    if obj_hash["RESPONSE"]
+      wallet = EME::Billing::Wallet.new(obj_hash["RESPONSE"])
+    else
+      wallet = EME::Billing::Wallet.new({"TOTREMAINAMT" => 0})
+    end
+  
+    # save to memcache
+    if settings[:use_memcache]
+      cache.write("wallet-balance-#{external_id}-#{currency}", wallet, {:ttl => 300})
+      cache.write("wallet-balance-#{external_id}-#{currency}-bkup", wallet, {:ttl => 3600})
+    end
+    wallet
+  end
+  
+  def self.currencies(gamecode, types = [], reload = false, conn = connection)
+    fetch_currencies(gamecode, "EMP", types, reload, conn)
+  end
+  
+  def self.subscriptions(gamecode, types = [], invisible = false, reload = false, conn = connection)
+    fetch_currencies(gamecode, "SUB", types, invisible, reload, conn)
+  end
+  
+  def self.fetch_currencies(gamecode, kind="EMP", types = [], invisible = false, reload = false, conn = connection)
+    cache_key = "currency-list-#{gamecode}-kind#{kind}-#{types.sort.join('-')}-#{'invs' if invisible}".downcase
+    if settings[:use_memcache] && !reload
+      cached = cache.obj_read(cache_key)
+      return cached if cached
+    end
+  
+    currs = nil
+    request_path = URI.encode("/Payment/rest/services/virtualcurrency/v1/list/#{gamecode}/#{kind}/^/^#{'/^' if invisible}")
+    obj_hash = do_request(request_path, conn)
+    
+    currs = CurrencyCollection.new(obj_hash["LIST"], types)
+    # save to memcache
+    if settings[:use_memcache]
+      cache.obj_write(cache_key, currs, {:ttl => 300})
+    end
+    currs
+  end
+  
+  def self.currency_by_id(gamecode, id)
+    currs = currencies(gamecode)
+    return currs.currencies.select{|x| x.id == id }[0]
+  end
+  
+  def self.subscription_by_id(gamecode, id, reload = false, conn = connection)
+    subs = subscriptions(gamecode, [], true)
+    return subs.currencies.select{|x| x.id == id }[0]
+  end
+  
+  def self.cash_payment_types(gamecode, reload = false, conn = connection)
+    if settings[:use_memcache] && !reload
+      cached = cache.obj_read("payment-type-list-#{gamecode}")
+      return cached if cached
+    end
+  
+    pay_types = []
+    request_path = URI.encode("/Payment/rest/services/virtualcurrency/v1/list/#{gamecode}/USD/^/^")
+    obj_hash = do_request(request_path, conn)
+    obj_hash["LIST"].each do |pt_hash|
+      pay_types.push(PaymentType.new(pt_hash))
+    end
+    pay_types.sort!{|a,b| a.sortno <=> b.sortno }
+  
+    if settings[:use_memcache]
+      cache.obj_write("payment-type-list-#{gamecode}", pay_types, {:ttl => 300})
+    end
+    return pay_types
+  end
+  # Fetch the array of all offers.  Will cache the results for 5 minutes if settings[:use_memcache] is true
+  #
+  # ==== Attributes
+  #
+  # none
+  #
+  # ==== Options
+  #
+  # none
+  #
+  # ==== Examples
+  #
+  # EME::Billing.offers()
+  def self.offers(game=nil, lang = nil, reset_cache = false, conn = connection)
+    custom_offers("all", game, lang, reset_cache, conn)
+  end
+  
+  def self.find_item(item_id, game=nil, reset_cache = false)
+    game = game || settings[:game]
+    request_url = URI.encode("/Item/rest/services/#{game}/gameitem/v1/get/#{item_id}")
+    return do_request(request_url, connection(:normal), {:key => "#{game}-single-item-#{item_id}", :ttl => 60})
+  end
+  
+  def self.custom_offers(tag = "all", game = nil, lang = nil, reset_cache = false, conn = connection)
+  raise RuntimeError, "game required" unless game
+  if !reset_cache && settings[:use_memcache]
+     cached = cache.obj_read("#{game.downcase}-all-#{tag}-#{lang}")
+     return cached if cached
+   end
+  
+   local_offers = []
+   cur_page = 1
+   offers_per_req = 100  #250 when that is release
+  
+   tag_data = tag == "all" ? "^" : "&attributes=#{tag}"
+  
+   tag_data = URI.escape(tag_data)
+   cur_offers = []
+   while(cur_page == 1 || cur_offers.length == offers_per_req)
+     base_offer_api_request = URI.encode("/Item/rest/services/#{game}/gameitem/v1/page/#{offers_per_req}/#{cur_page}/^/true")
+     #puts base_offer_api_request
+  
+     cur_offers = []
+  
+     begin
+       obj_array = do_request(base_offer_api_request, conn)
+       obj_array["LIST"] = [] if obj_array["LIST"].nil?
+       obj_array["LIST"].each do |obj|
+         cur_offers << Offer.new(obj)
+       end
+     rescue RuntimeError => exception
+       puts exception.backtrace
+       obj_array = {"message" => "Error contacting store."}
+       return [] # No offer found
+     end
+  
+     cur_page += 1
+     local_offers += cur_offers
+   end
+  
+   # save to memcache
+   if settings[:use_memcache]
+     cache.obj_write("#{game.downcase}-all-#{tag}-#{lang}", local_offers, {:ttl => 3600})
+   end
+  
+   local_offers
+  end
+  
+  def self.campaigns(game = nil, lang = 'en', reset_cache = false, conn = connection)
+    return custom_campaigns("all", game, lang, reset_cache, conn)
+  end
+  
+  def self.custom_campaigns(tag = "all", game = nil, lang = 'en', reset_cache = false, conn = connection)
+    raise RuntimeError, "game required" unless game
+    if !reset_cache && settings[:use_memcache]
+      cached = cache.read("#{game.downcase}-campaigns-#{tag}-#{lang}")
+      return cached if cached
+    end
+  
+    local_campaigns = []
+    cur_page = 1
+    camps_per_request = 100
+  
+    cur_camps = []
+    while(cur_page == 1 || cur_camps.length == camps_per_request)
+      base_campaign_api_request = URI.encode("/Item/rest/services/#{game}/promotion/v1/page/#{camps_per_request}/#{cur_page}/true")
+      cur_camps = []
+  
+      # store in memcache here
+      obj_array = do_request(base_campaign_api_request, conn)
+      obj_array["LIST"] = [] if obj_array["LIST"].nil?
+      obj_array["LIST"].each do |obj|
+        cur_camps << Campaign.new(campaign_hash_map(obj))
+      end
+  
+      cur_page += 1
+      local_campaigns += cur_camps
+    end
+    elite_campaigns = local_campaigns.select{|x| x.tags.include?("promo_tag:elite") }
+    sale_campaigns = local_campaigns.select{|x| x.tags.include?("promo_tag:sale") }
+  
+    # save to memcache
+    if settings[:use_memcache]
+      cache.write("#{game.downcase}-campaigns-#{tag}-#{lang}", [elite_campaigns, sale_campaigns], {:ttl => 3600})
+    end
+  
+    return [elite_campaigns, sale_campaigns]
+  end
+  
+  def self.campaign_hash_map(camp)
+    {
+      :tags => (camp["TAGS"] || []).uniq,
+      :images => camp["IMAGES"],
+      :name => camp["EVENTNAME"],
+      :id => camp["EVENTID"],
+      :longDescription => camp["HTMLLONGDESCRIPTION"],
+      :discount_rate => camp["TOTDISCOUNTRATE"],
+      :discount_amount => camp["TOTDISCOUNTAMOUNT"],
+      :items => camp["ITEMS"],
+      :start_at => camp["STARTDATE"],
+      :end_at => camp["ENDDATE"]
+    }
+  end
+  
+  def self.purchase(external_id, item, currency = "EMP", opts = {}, conn = connection)
+    purchase_body = {}
+    # We need accountID, and gameAccountId!!!
+    purchase_body = {
+      "USERNO" => external_id,
+      "USERID" => opts[:email],
+      "GAMEUSERNO" => opts[:game_account_id],
+      "QUANTITY" => opts[:quantity ] || 1,
+      "GAMECODE" => opts[:game_code],
+      "USERSUBSET" => opts[:elite] ? "elite" : "normal",
+      "PRICEID" => opts[:price_point_id],
+      "COUNTRYCODE" => "SGS", #"USA"  # hard-coded due to bug in FFG system with ip addresses  We are using SGS (South Geargian, and the Sandwich Islands) to denote Web Sales.
+      "CHARGEAMT" => opts[:amount],
+      "LOCATION" => opts[:location] || "web",
+      "ORDERTRANSACTIONID" => "#{external_id}-#{opts[:game_account_id]}-#{Time.now.strftime('%Y%m%d%H%M%S%L')}"
+    }
+    purchase_body["EVENTID"] = opts[:campaign_id] if opts[:campaign_id]
+    purchase_body["CHECKSUM"] = checksum "#{external_id}|#{opts[:email]}|#{opts[:game_account_id]}|#{purchase_body['GAMECODE']}|#{opts[:price_point_id]}|SGS|#{purchase_body['ORDERTRANSACTIONID']}"
+  
+    raise RuntimeError, "Account required." if purchase_body["USERNO"].nil?
+    raise RuntimeError, "Game Account required." if purchase_body["GAMEUSERNO"].nil?
+    raise RuntimeError, "Price required." if purchase_body["PRICEID"].nil? || purchase_body["CHARGEAMT"].nil?
+    #raise RuntimeError, "IP Address required." if purchase_body["ipAddress"].nil?
+    raise RuntimeError, "Quantity required." if purchase_body["QUANTITY"].nil?
+  
+    json = JSON.generate(purchase_body)
+  
+    purchase_path = "/Payment/rest/services/purchase/v1/item"
+  
+    obj_hash = do_request(purchase_path, conn, {:method => :post, :body => json})
+    # PUTS NOT CHECKING CORRECT ERROR MESSAGES YET!!! -CR-
+    if(obj_hash["RETCODE"] == 9998)
+      puts obj_hash.inspect
+      return {"message" => "Server failed to remove your EMP.  Sorry no item for you right now.", "error" => true}
+      #return {"message" => "You do not have enough EMP for this purchase.  Please buy EMP and try again.", "error" => true}
+    elsif(obj_hash["RETCODE"] == 0)
+      return {"transaction_id" => obj_hash["RESPONSE"]["TRANSACTIONID"], "error" => false, "price" => opts[:amount] || item.price }
+    else
+      puts obj_hash.inspect
+      return {"message" => obj_hash["ERRMSG"], "error" => true}
+    end
+  end
+  
+  def self.billing_info(external_id, conn = connection)
+    res = do_request("/Payment/rest/services/billinginfo/v1/get/#{external_id}", conn)
+    return res["RESPONSE"] if res["RESPONSE"]
+    return res
+  end
+  # StoreAPI.do_request("/Payment/rest/services/billinginfo/v1/get/100001")
+  
+  def self.subscription_billing_info(external_id, conn = connection)
+    res = do_request("/Payment/rest/services/get/v1/Subscription/#{external_id}", conn)
+    return res["RESPONSE"] if res["RESPONSE"]
+    return res
+  end
+  # StoreAPI.do_request("/Payment/rest/services/get/v1/Subscription/100001")
+  
+  # requires publisher as AMAZON or STEAM.
+  def self.add_offsite_emp(external_id, emp_amount, opts, conn = connection )
+    emp_body = {  "USERNO" => external_id,
+                  "USERID" => opts[:user_email],
+                  "PGCODE" => opts[:publisher],
+                  "PAYAMT" => opts[:pay_amount],
+                  "TAXAMT" => opts[:tax_amount],
+                  "CURRENCYCODE" => "USD",
+                  "CASHAMT" => emp_amount,
+                  "ORDERTRANSACTIONID" => "#{opts[:publisher]}#{opts[:order_id]}",
+                  "GAMECODE" => opts[:game_code],
+                  "COUNTRYCODE" => "USA",
+                  "IPADDR" => opts[:ip_address],
+                  "PUBLISHER" => opts[:publisher],
+                  "DESCRIPTION" => "#{opts[:publisher]} offsite transaction"
+    }
+    emp_body["CHECKSUM"] = checksum "#{external_id}|#{opts[:user_email]}|#{opts[:publisher]}|USD|#{opts[:pay_amount]}|#{emp_amount}|#{emp_body['GAMECODE']}|#{emp_body['COUNTRYCODE']}|#{emp_body['ORDERTRANSACTIONID']}"
+    
+    log.debug "EMP_BODY: #{emp_body}"
+    res = do_request("/Payment/rest/services/create/v1/EMP", conn, {:method => :post, :body => emp_body.to_json})
+    log.debug "RES: #{res}"
+    return res["RESPONSE"] if res["RESPONSE"]
+    return res
+  end
+  
+  def self.secret_hash(user_id, game_account_id = 0)
+    return Digest::SHA1.hexdigest "#{settings[:mystery_key]}#{user_id}#{game_account_id}"
+  end
+  
+  def self.checksum(data_string)
+    return Digest::SHA1.hexdigest "#{data_string}|#{settings[:api_key]}"
+  end
+  
+  class PaymentType
+    #{"CURRENCYID"=>0, "SORTNO"=>1, "VIRTUALNAME"=>"Paypal Cedit Card Direct", "PGCODE"=>"CREDITCARD_DIRECT", "CURRENCY"=>"USD", "PAYAMT"=>0, "CASHAMT"=>0, "CASHIDENTIFIER"=>"USD", "REALCASHAMT"=>0, "BONUSCASHAMT"=>0, "PROMOTIONS"=>nil}
+    attr_accessor :pg_code, :name, :sortno
+    def initialize(data_array)
+      @pg_code = data_array["PGCODE"]
+      @name = data_array["VIRTUALNAME"]
+      @sortno = data_array["SORTNO"]
+    end
+  end
+  
+  class CurrencyCollection
+    attr_accessor :payment_types, :currencies
+    # [{"SORTNO"=>1, "VIRTUALNAME"=>"1100 EMP", "PGCODE"=>"PAYPAL", "CURRENCY"=>"USD", "PAYAMT"=>10, "CASHAMT"=>1100, "CASHIDENTIFIER"=>"EMP", "REALCASHAMT"=>1100, "BONUSCASHAMT"=>0}]
+    def initialize(data_array, allowed_types = [])
+      @payment_types = []
+      @currencies = []
+      data_array.each do |cur|
+        currency = Currency.new(cur)
+        if allowed_types.empty? || allowed_types.include?(currency.payment_type)
+          @currencies << currency
+          @payment_types << currency.payment_type
+        end
+      end
+      @payment_types.uniq!
+      @currencies.sort!{|a,b| a.position <=> b.position }
+    end
+  
+    def currencies_by_payment_type(type)
+      @currencies.select{|c| c.payment_type == type}
+    end
+  
+    def to_s
+      <<-CURR
+      CurrencyCollection #{self.object_id}
+      payment_types: #{@payment_types.inspect}
+      currencies (@currencies.length): #{@currencies.collect{|x| x.to_s}.inspect}
+      CURR
+    end
+  end
+  
+  class Currency
+    attr_accessor :id, :name, :payment_type, :position, :cost, :cost_currency, :purchase_amount_total, :purchase_amount_bonus, :purchase_currency, :purchase_amount
+    # {"SORTNO"=>1, "VIRTUALNAME"=>"1100 EMP", "PGCODE"=>"PAYPAL", "CURRENCY"=>"USD", "PAYAMT"=>10, "CASHAMT"=>1100, "CASHIDENTIFIER"=>"EMP", "REALCASHAMT"=>1100, "BONUSCASHAMT"=>0}
+    def initialize(curr)
+      @id = curr["CURRENCYID"]
+      @name = curr["VIRTUALNAME"]
+      @payment_type = curr["PGCODE"]
+      @position = curr["SORTNO"]
+      @cost = curr["PAYAMT"]
+      @cost_currency = curr["CURRENCY"]
+      @purchase_amount_total = curr["CASHAMT"]
+      @purchase_amount = curr["REALCASHAMT"]
+      @purchase_amount_bonus = curr["BONUSCASHAMT"]
+      @purchase_currency = curr["CASHIDENTIFIER"]
+    end
+  
+    def to_s
+      <<-CURR
+      Currency #{self.object_id}
+      \tid: #{@id}
+      \tname: #{@name}
+      \tpayment_type: #{@payment_type}
+      \tposition: #{@position}
+      \tcost: #{@cost}
+      \tcost_currency: #{@cost_currency}
+      \tpurchase_amount: #{@purchase_amount}
+      \tpurchase_amount_total: #{@purchase_amount_total}
+      \tpurchase_amount_bonus: #{@purchase_amount_bonus}
+      \tpurchase_currency: #{@purchase_currency}
+      \tbonus: #{bonus}
+      CURR
+    end
+  
+    def bonus
+      return 0 if @purchase_amount_total == 0 || @purchase_amount == 0
+      (@purchase_amount_bonus.to_f * 100.0 / @purchase_amount).to_i
+    end
+  end
+  
+  class ObjectHash < Hash
+    def method_missing(method)
+      return self[method] if self[method]
+    end
+  end
+  
+  class Wallet < ObjectHash
+    attr_accessor :currencies
+  
+    def initialize(wallet_hash)
+      @currencies = []
+      self[:error] = false
+      @currencies << "EMP"
+      self[:EMP] = ObjectHash.new
+      self[:EMP][:amount] = wallet_hash["TOTREMAINAMT"]
+      theDefault = ObjectHash.new
+      theDefault[:amount] = 0
+      self.default = theDefault
+    end
+  end
+  
+  class Offer < ObjectHash
+    def initialize(key_values)
+      key_values.each do |k,v|
+        self[k.to_sym] = v
+      end
+      if self[:items]
+        local_items = []
+        self[:items].each {|item| local_items << Item.new(item)}
+        self[:items] = local_items
+      end
+    end
+  
+    def price(currency = "USD")
+      prod = self.prices.select{|p| p["currency"] == currency}.first
+      return prod["price"].to_f
+    end
+  
+  end
+  
+  class Item < ObjectHash
+    def initialize(key_values)
+      key_values.each do |k,v|
+        self[k.to_sym] = v
+      end
+      if self[:images]
+        local_images = []
+        self[:images].each {|image| local_images << Image.new(image)}
+        self[:images] = local_images
+      end
+      EME::Billing.items[self[:id]] = self
+    end
+  end
+  
+  class Campaign < ObjectHash
+    def initialize(key_values)
+      key_values.each do |k,v|
+        self[k.to_sym] = v
+      end
+      if self[:images]
+        local_images = []
+        self[:images].each {|image| local_images << Image.new(image)}
+        self[:images] = local_images
+      end
+      self[:items] = [] if self[:items] == nil
+    end
+  end
+  
+  class Image < ObjectHash
+    def initialize(key_values)
+      key_values.each do |k,v|
+        self[k.to_sym] = v
+      end
+    end
+  end
+  
+  class Transaction < ObjectHash
+    def initialize(key_values)
+      key_values.each do |k,v|
+        self[k.to_sym] = v
+      end
+    end
+  
+    def date
+      Time.at(self[:walletTrxTime].to_i/1000).strftime("%m/%d/%Y")
+    end
+  end
+  
+  @@items = {}
+  def self.items
+    @@items
+  end
+end