Class: PAS

Inherits:
Object
  • Object
show all
Defined in:
lib/pas.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(api_key, api_token, api_site = "publisher.pokeraffiliatesolutions.com") ⇒ PAS

Returns a new instance of PAS.



19
20
21
22
23
 
# File 'lib/pas.rb', line 19

def initialize(api_key, api_token, api_site = "publisher.pokeraffiliatesolutions.com")
  self.api_site      = api_site
  self.api_key       = api_key
  self.api_token     = api_token
end

Instance Attribute Details

#api_key ⇒ Object

Your api key



11
12
13
 
# File 'lib/pas.rb', line 11

def api_key
  @api_key
end

#api_token ⇒ Object

api token for querying, set it if you know it or let it be auto-requested



14
15
16
 
# File 'lib/pas.rb', line 14

def api_token
  @api_token
end

Instance Method Details

#api_site ⇒ Object

Site that is using the PAS api



26
27
28
 
# File 'lib/pas.rb', line 26

def api_site
  @api_site
end

#api_site=(value) ⇒ Object 



30
31
32
 
# File 'lib/pas.rb', line 30

def api_site=(value)
  @api_site = value =~ /^https:\/\// ? value : "https://#{value}"
end

#build_query_string(params) ⇒ Object

Basically the same as the Mechanize::Util.build_query_string but without urlencode (would have urlencoded it twice otherwise)



207
208
209
210
211
 
# File 'lib/pas.rb', line 207

def build_query_string(params)
  params.map { |k,v|
    [k.to_s, v.to_s].join("=") if k
  }.compact.join('&')
end

#create_member_tracker(member_id, identifier, website_offer_id) ⇒ Object

Creates a member for given website offer



134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pas.rb', line 134

def create_member_tracker(member_id, identifier, website_offer_id)
  new_member_tracker = {"member_tracker" => {"identifier" => identifier, "website_offer_id" => website_offer_id}}
  response = make_request("/publisher_members/#{member_id}/publisher_member_trackers.xml", "POST", hash_to_xml(new_member_tracker))
  response = xml_to_hash(response)["member_tracker"]
  result = {}
  result[:affiliate_id]         = response["affiliate_id"]["content"].to_i
  result[:id]                   = response["id"]["content"].to_i
  result[:identifier]           = response["identifier"]
  result[:member_rakeback_rate] = response["member_rakeback_rate"]
  result[:poker_room_id]        = response["poker_room_id"]
  result
rescue
  nil
end

#get_member_tracker_stats(member_id, tracker_id, start_date, end_date) ⇒ Object 



125
126
127
128
129
130
 
# File 'lib/pas.rb', line 125

def get_member_tracker_stats(member_id, tracker_id, start_date, end_date)
  trackers = get_member_trackers_stats(member_id, start_date, end_date)
  trackers ? trackers.detect {|t| t[:identifier] == tracker_id || t[:id] == tracker_id } : nil
rescue
  nil
end

#get_member_trackers(member_id) ⇒ Object

Gets a list of all member trackers



90
91
92
93
94
95
 
# File 'lib/pas.rb', line 90

def get_member_trackers(member_id)
  result = xml_to_hash(make_request("/publisher_members/#{member_id}/stats.xml", "GET"))
  [result["statistics"]["member_trackers"]["member_tracker"]].flatten.map {|t| symbolize_keys(t) }.map {|t| t[:id] = t[:id].to_i; t }
rescue
  []
end

#get_member_trackers_stats(member_id, start_date, end_date) ⇒ Object

Gather stats for specific member for specific period of time Warning: probably not page aware: didn’t check that one



99
100
101
102
103
104
 
# File 'lib/pas.rb', line 99

def get_member_trackers_stats(member_id, start_date, end_date)
  @member_tracker_stats ||= {}
  @member_tracker_stats[member_id] ||= {}
  @member_tracker_stats[member_id][start_date] ||= {}
  @member_tracker_stats[member_id][start_date][end_date] ||= get_member_trackers_stats!(member_id, start_date, end_date)
end

#get_member_trackers_stats!(member_id, start_date, end_date) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/pas.rb', line 106

def get_member_trackers_stats!(member_id, start_date, end_date)
  start_date = start_date.strftime("%Y-%m-%d")
  end_date   = end_date.strftime("%Y-%m-%d")
  response = xml_to_hash(make_request("/publisher_members/#{member_id}/stats.xml", "GET", {:start_date => start_date, :end_date => end_date}))
  trackers = [response["statistics"]["member_trackers"]["member_tracker"]].flatten
  trackers.inject([]) do |result, tracker|
    result << {
      :id            => tracker["id"].to_i,
      :identifier    => tracker["identifier"],
      :poker_room_id => tracker["poker_room_id"].to_i,
      :poker_room    => tracker["poker_room"],
      :mgr           => tracker["mgr"].to_f,
      :rakeback      => tracker["rakeback"].to_f
    }
  end
rescue
  nil
end

#hash_to_xml(hash) ⇒ Object 



168
169
170
171
172
 
# File 'lib/pas.rb', line 168

def hash_to_xml(hash)
  XmlSimple.xml_out(hash,
    'keeproot' => true
  )
end

#list_all_members ⇒ Object Also known as: all_members

List all members That is a very request-heavy method, be afraid, be very afraid



52
53
54
 
# File 'lib/pas.rb', line 52

def list_all_members
  @all_members ||= list_all_members!
end

#list_all_members! ⇒ Object 



57
58
59
60
61
 
# File 'lib/pas.rb', line 57

def list_all_members!
  (1..member_page_count).inject([]) {|result, page| result + member_page(page) }    
rescue
  []
end

#make_request(uri, method, payload = {}, signed = true) ⇒ Object 



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/pas.rb', line 178

def make_request(uri, method, payload = {}, signed = true)
  request = new_request

  query_params = if signed
    timestamp = Time.now.to_i
    {
      :timestamp => timestamp,        
      :api_token => api_token,
      :signature => request_signature(uri, method, timestamp)
    }
  else
    {}
  end

  case method
  when "GET"
    request.get(api_site + uri + "?" + build_query_string(query_params.merge(payload))).body
  when "POST"
    request.post(api_site + uri + "?" + build_query_string(query_params), payload, "Content-Type" => "application/xml").body
  else
    nil
  end
end

#member_page(page) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Gets a single members page



79
80
81
82
83
84
85
 
# File 'lib/pas.rb', line 79

def member_page(page)
  result = xml_to_hash(make_request("/publisher_members.xml", "GET", {:page => page}))
  members = [result["members"]["member"]].flatten    
  symbolize_keys(members).map {|m| m[:id] = m[:id].to_i; m}
rescue
  []
end

#member_page_count ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns member page count



65
66
67
 
# File 'lib/pas.rb', line 65

def member_page_count
  @member_page_count ||= member_page_count!
end

#member_page_count! ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



70
71
72
73
74
75
 
# File 'lib/pas.rb', line 70

def member_page_count!
  result = xml_to_hash(make_request("/publisher_members.xml", "GET"))
  result["members"]["total_pages"].to_i
rescue
  0
end

#new_request ⇒ Object 



174
175
176
 
# File 'lib/pas.rb', line 174

def new_request
  Mechanize.new
end

#request_signature(uri, method = "GET", timestamp = Time.now.to_i) ⇒ Object 



35
36
37
38
39
 
# File 'lib/pas.rb', line 35

def request_signature(uri, method = "GET", timestamp = Time.now.to_i)
  payload = api_token.to_s + method + uri + timestamp.to_s
  signature = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, api_key, payload)
  CGI::escape(Base64.encode64(signature).chomp)
end

#symbolize_keys(arg) ⇒ Object

recursive key symbolization



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/pas.rb', line 214

def symbolize_keys(arg)
  case arg
  when Array
    arg.map { |elem| symbolize_keys elem }
  when Hash      
      arg.inject({}) { |result, kv|
        k = kv[0].is_a?(String) ? kv[0].to_sym : kv[0]
        v = symbolize_keys kv[1]
        result[k] = v
        result
      }
  else
    arg
  end
end

#website_offers(website_id) ⇒ Object Also known as: get_website_offers

Returns array of website offers for given website id



150
151
152
153
154
155
156
 
# File 'lib/pas.rb', line 150

def website_offers(website_id)
  response = make_request("/website_offers.xml", "GET", {:website_id => website_id})
  response = [xml_to_hash(response)["offers"]["offer"]].flatten
  symbolize_keys(response).map {|o| o[:id] = o[:id].to_i; o }
rescue
  []
end

#websites ⇒ Object

TOP LEVEL



42
43
44
45
46
47
 
# File 'lib/pas.rb', line 42

def websites
  websites = symbolize_keys [xml_to_hash(make_request("/websites.xml", "GET"))["websites"]["website"]].flatten
  websites.map {|w| w[:id] = w[:id].to_i; w }
rescue
  nil
end

#xml_to_hash(xml) ⇒ Object

protected



160
161
162
163
164
165
166
 
# File 'lib/pas.rb', line 160

def xml_to_hash(xml)
  XmlSimple.xml_in(xml, 
    'forcearray'   => false, 
    'forcecontent' => false, 
    'keeproot'     => true
  )
end