tinypass 0.0.1

data/lib/tinypass/token/access_token_list.rb

@@ -0,0 +1,71 @@
+module Tinypass
+  class AccessTokenList
+    include Enumerable
+
+    MAX = 20
+
+    def initialize(input_tokens = nil)
+      @tokens_hash = {}
+      input_tokens = Array(input_tokens)
+
+      input_tokens.each { |token| self << token }
+    end
+
+    def tokens
+      @tokens_hash.values
+    end
+    alias_method :access_tokens, :tokens
+
+    def [](rid)
+      @tokens_hash[rid.to_s]
+    end
+
+    def <<(token)
+      key = token.token_data.rid
+
+      @tokens_hash[key] = token
+      shift until size <= MAX
+
+      self[key]
+    end
+    alias_method :add, :<<
+
+    def push(*args)
+      args.each do |token|
+        self << token
+      end
+    end
+
+    def add_all(tokens)
+      self.push(*tokens)
+    end
+
+    def include?(rid)
+      rid = rid.to_s
+      @tokens_hash.has_key?(rid)
+    end
+    alias_method :contains?, :include?
+
+    def each(*args, &block)
+      tokens.each(*args, &block)
+    end
+
+    def length
+      tokens.size
+    end
+    alias_method :size, :length
+
+    def empty?
+      @tokens_hash.empty?
+    end
+
+    def delete(rid)
+      @tokens_hash.delete(rid)
+    end
+    alias_method :remove, :delete
+
+    def shift
+      delete(@tokens_hash.keys.first)
+    end
+  end
+end

data/lib/tinypass/token/access_token_store.rb

@@ -0,0 +1,59 @@
+require 'uri'
+
+require 'tinypass/token/access_token.rb'
+require 'tinypass/token/token_data.rb'
+
+module Tinypass
+  class AccessTokenStore
+    attr_reader :tokens, :raw_cookie
+
+    def initialize(config = nil)
+      @config = config
+      @tokens = AccessTokenList.new
+    end
+
+    def load_tokens_from_cookie(cookies, name = nil)
+      name ||= Config.token_cookie_name(Tinypass.aid)
+      @raw_cookie = cookies.respond_to?(:to_str) ? cookies : cookies[name]
+
+      if @raw_cookie
+        @tokens = ClientParser.new.parse_access_tokens(URI.unescape(raw_cookie))
+      end
+    end
+
+    def get_access_token(rid)
+      rid = rid.to_s
+      return tokens[rid] if tokens[rid]
+
+      token = AccessToken.new(rid, -1)
+
+      if tokens.size == 0
+        token.access_state = AccessState::NO_TOKENS_FOUND
+      else
+        token.access_state = AccessState::RID_NOT_FOUND
+      end
+
+      return token
+    end
+
+    def has_token?(rid)
+      tokens.contains?(rid.to_s)
+    end
+
+    def find_active_token(regexp)
+      tokens.each do |token|
+        return token if token.rid =~ regexp && !token.expired?
+      end
+
+      nil
+    end
+
+    protected
+
+    def clean_expired_tokens
+      @tokens.dup.each do |token|
+        @tokens.delete(token.rid) if token.expired? || (token.metered? && token.trial_dead?)
+      end
+    end
+  end
+end

data/lib/tinypass/token/meter.rb

@@ -0,0 +1,76 @@
+module Tinypass
+  class Meter
+    def initialize(access_token)
+      @access_token = access_token
+    end
+
+    def self.create_view_based(rid, max_views, trial_period)
+      access_token = AccessToken.new(rid)
+      end_time = Utils.parse_loose_period_in_secs(trial_period) + Time.now.to_i
+
+      access_token.token_data[TokenData::METER_TYPE] = TokenData::METER_REMINDER
+      access_token.token_data[TokenData::METER_TRIAL_MAX_ACCESS_ATTEMPTS] = max_views
+      access_token.token_data[TokenData::METER_TRIAL_ACCESS_ATTEMPTS] = 0
+      access_token.token_data[TokenData::METER_TRIAL_ENDTIME] = end_time
+      access_token.token_data[TokenData::METER_LOCKOUT_ENDTIME] = end_time
+
+      new(access_token)
+    end
+
+    def self.create_time_based(rid, trial_period, lockout_period)
+      access_token = AccessToken.new(rid)
+      trial_end_time = Utils::parse_loose_period_in_secs(trial_period) + Time.now.to_i
+      lockout_end_time = trial_end_time + Utils::parse_loose_period_in_secs(lockout_period)
+
+      access_token.token_data[TokenData::METER_TYPE] = TokenData::METER_REMINDER
+      access_token.token_data[TokenData::METER_TRIAL_ENDTIME] = trial_end_time
+      access_token.token_data[TokenData::METER_LOCKOUT_ENDTIME] = lockout_end_time
+
+      new(access_token)
+    end
+
+    def increment
+      data[TokenData::METER_TRIAL_ACCESS_ATTEMPTS] = trial_view_count + 1
+    end
+
+    def trial_period_active?
+      @access_token.trial_period_active?
+    end
+
+    def lockout_period_active?
+      @access_token.lockout_period_active?
+    end
+
+    def data
+      @access_token.token_data
+    end
+
+    def view_based?
+      @access_token.meter_view_based?
+    end
+
+    def trial_view_count
+      @access_token.trial_view_count
+    end
+
+    def trial_view_limit
+      @access_token.trial_view_limit
+    end
+
+    def trial_dead?
+      @access_token.trial_dead?
+    end
+
+    def meter_type
+      @access_token.meter_type
+    end
+
+    def trial_end_time_secs
+      @access_token.trial_end_time_secs
+    end
+
+    def lockout_end_time_secs
+      @access_token.lockout_end_time_secs
+    end
+  end
+end

data/lib/tinypass/token/meter_helper.rb

@@ -0,0 +1,82 @@
+module Tinypass
+  module MeterHelper
+    extend self
+
+    def create_view_based(name, max_views, within_period)
+      Meter.create_view_based(name, max_views, within_period)
+    end
+
+    def create_time_based(name, trial_period, lockout_period)
+      Meter.create_time_based(name, trial_period, lockout_period)
+    end
+
+    def load_meter_from_cookie(meter_name, cookies)
+      # NOTE: This method expects `meter_name` to be both the cookie name and the meter name
+      #   aka rid.
+
+      store = AccessTokenStore.new
+      store.load_tokens_from_cookie(cookies, meter_name)
+
+      return unless store.has_token?(meter_name)
+
+      token = store.get_access_token(meter_name)
+      meter = Meter.new(token)
+
+      return if meter.trial_dead?
+      meter
+    end
+
+    def load_meter_from_serialized_data(string)
+      store = AccessTokenStore.new
+      store.load_tokens_from_cookie(string)
+      token = store.tokens.first
+
+      return if token.nil?
+
+      meter = Meter.new(token)
+
+      return if meter.trial_dead?
+      meter
+    end
+
+    def serialize(meter, builder_config = '')
+      token = AccessToken.new(meter.data)
+      builder = ClientBuilder.new(builder_config)
+      builder.build_access_tokens(token)
+    end
+
+    def serialize_to_json(meter)
+      serialize(meter, ClientBuilder::OPEN_ENC)
+    end
+
+    def deserialize(string)
+      parser = ClientParser.new
+      list = parser.parse_access_tokens(string)
+      token = list.first
+
+      return if token.nil?
+
+      Meter.new(token)
+    end
+
+    def generate_cookie_embed_script(name, meter)
+      if meter.lockout_period_active?
+        expires = meter.lockout_end_time_secs + 60
+      else
+        expires = Time.now.to_i + 60 * 60 * 24 * 90
+      end
+      expires_string = Time.at(expires).utc
+
+      "<script>
+        document.cookie='#{ generate_local_cookie(name, meter) }; path=/; expires=#{ expires_string };';
+      </script>"
+    end
+
+    private
+
+    def generate_local_cookie(name, meter)
+      cookie_value = URI::escape(serialize(meter))
+      "#{ name }=#{ cookie_value }"
+    end
+  end
+end

data/lib/tinypass/token/token_data.rb

@@ -0,0 +1,72 @@
+module Tinypass
+  class TokenData
+    MARK_YEAR_MILLIS = 1293858000000
+
+    METER_REMINDER = 10
+    METER_STRICT = 20
+
+    METER_TRIAL_ENDTIME = 'mtet'
+    METER_TRIAL_ACCESS_PERIOD = 'mtap'
+
+    METER_LOCKOUT_ENDTIME = 'mlet'
+    METER_LOCKOUT_PERIOD = 'mlp'
+
+    METER_TRIAL_MAX_ACCESS_ATTEMPTS = 'mtma'
+    METER_TRIAL_ACCESS_ATTEMPTS = 'mtaa'
+    METER_TYPE = 'mt'
+
+    ACCESS_ID = 'id'
+
+    RID = 'rid'
+    UID = 'uid'
+    EX = 'ex'
+    EARLY_EX = 'eex'
+    IPS = 'ips'
+
+    def initialize(data = {})
+      @data = data
+    end
+
+    def rid
+      @data[RID]
+    end
+
+    def [](key)
+      key = key.to_s
+      @data[key]
+    end
+
+    def []=(key, value)
+      key = key.to_s
+      @data[key] = value
+    end
+
+    def values
+      @data
+    end
+
+    def fetch(*args)
+      args[0] = args[0].to_s
+      @data.fetch(*args)
+    end
+
+    def merge(hash)
+      stringified_hash = {}
+      hash.keys.each do |key|
+        stringified_hash[key.to_s] = hash[key]
+      end
+
+      @data.merge!(stringified_hash)
+    end
+    alias_method :add_fields, :merge
+
+    def size
+      @data.size
+    end
+
+    def self.convert_to_epoch_seconds(seconds_from_now)
+      seconds_from_now /= 1000 if seconds_from_now > MARK_YEAR_MILLIS
+      seconds_from_now
+    end
+  end
+end

data/lib/tinypass/ui.rb

@@ -0,0 +1,2 @@
+require 'tinypass/ui/html_widget'
+require 'tinypass/ui/purchase_request'

data/lib/tinypass/ui/html_widget.rb

@@ -0,0 +1,29 @@
+module Tinypass
+  class HtmlWidget
+    def create_button_html(request)
+      options = request.options.dup || {}
+      rid = request.primary_offer.resource.rid
+      builder = ClientBuilder.new
+      rdata = builder.build_purchase_request(request).gsub('"', '\"')
+
+      html = "<tp:request type=\"purchase\" rid=\"#{ rid }\"" <<
+        " url=\"#{ Config.endpoint + Config::CONTEXT }\"" <<
+        " rdata=\"#{ rdata }\" aid=\"#{ Tinypass.aid }\"" <<
+        " cn=\"#{ Config.token_cookie_name }\" v=\"#{ Config::VERSION }\""
+
+      html << " oncheckaccess=\"#{ request.callback }\"" if request.callback
+
+      if options['button.html']
+        custom = options['button.html'].gsub('"', '&quot;')
+        html << " custom=\"#{ custom }\""
+      elsif options['button.link']
+        link = options['button.link'].gsub('"', '&quot;')
+        html << " link=\"#{ link }\""
+      end
+
+      html << "></tp:request>"
+
+      html
+    end
+  end
+end

data/lib/tinypass/ui/purchase_request.rb

@@ -0,0 +1,34 @@
+module Tinypass
+  class PurchaseRequest
+    attr_accessor :primary_offer, :secondary_offer, :options, :callback, :client_ip, :user_ref
+
+    def initialize(offer, options = {})
+      @primary_offer, @options = offer, options
+    end
+
+    def generate_tag
+      widget = HtmlWidget.new
+      widget.create_button_html(self)
+    end
+
+    def generate_link(return_url, cancel_url)
+      self.options['return_url'] = return_url if return_url
+      self.options['cancel_url'] = cancel_url if cancel_url
+
+      builder = ClientBuilder.new
+      ticket_string = builder.build_purchase_request(self)
+
+      Config.endpoint + Config::CONTEXT + "/jsapi/auth.js?aid=#{ Tinypass.aid }&r=#{ ticket_string }"
+    end
+
+    def client_ip=(value)
+      value.strip! if value
+      @client_ip = value
+    end
+
+    def user_ref=(value)
+      value.strip! if value
+      @user_ref = value
+    end
+  end
+end

data/lib/tinypass/utils.rb

@@ -0,0 +1,34 @@
+module Tinypass
+  module Utils
+    extend self
+
+    def valid_ip?(ip)
+      ip && ip =~ /\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}/
+    end
+
+    def parse_loose_period_in_msecs(period)
+      period = period.to_s
+      return period.to_i if period.to_i.to_s == period
+
+      if matches = /(\d+)\s*(\w+)/.match(period)
+        number = matches[1].to_i
+        string = matches[2]
+
+        return number if string.start_with?("ms")
+        return number * 1000 if string.start_with?("s")
+        return number * 1000 * 60 if string.start_with?("mi")
+        return number * 1000 * 60 * 60 if string.start_with?("h")
+        return number * 1000 * 60 * 60 * 24 if string.start_with?("d")
+        return number * 1000 * 60 * 60 * 24 * 7 if string.start_with?("w")
+        return number * 1000 * 60 * 60 * 24 * 30 if string.start_with?("mo")
+        return number * 1000 * 60 * 60 * 24 * 365 if string.start_with?("y")
+      end
+
+      raise ArgumentError.new("Cannot parse the specified period: #{ period }")
+    end
+
+    def parse_loose_period_in_secs(period)
+      parse_loose_period_in_msecs(period) / 1000
+    end
+  end
+end