Module: Userbin

Defined in:
lib/userbin/utils.rb,
lib/userbin.rb,
lib/userbin/jwt.rb,
lib/userbin/helpers.rb,
lib/userbin/request.rb,
lib/userbin/version.rb,
lib/userbin/models/base.rb,
lib/userbin/models/user.rb,
lib/userbin/configuration.rb,
lib/userbin/models/session.rb,
lib/userbin/models/challenge.rb

Overview

TODO: scope Userbin::Utils

Defined Under Namespace

Modules: Request Classes: Base, Challenge, Configuration, ConfigurationError, Error, Forbidden, JWT, SecurityError, Session, User, UserUnauthorizedError

Constant Summary collapse

API = 
Userbin.setup_api
VERSION = 
"1.0.4"

Class Method Summary collapse

Class Method Details

.api_secret=(api_secret) ⇒ Object 



17
18
19
 
# File 'lib/userbin/configuration.rb', line 17

def api_secret=(api_secret)
  config.api_secret = api_secret
end

.authenticate(session_token, user_id, opts = {}) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/userbin/helpers.rb', line 4

def authenticate(session_token, user_id, opts = {})
  session = Userbin::Session.new(token: session_token)

  user_data = opts.fetch(:properties, {})

  if session.token
    if session.expired?
      session = Userbin.with_context(opts[:context]) do
        session.refresh(user: user_data)
      end
    end
  else
    session = Userbin.with_context(opts[:context]) do
      Userbin::Session.post(
        "users/#{URI.encode(user_id.to_s)}/sessions", user: user_data)
    end
  end

  session_token = session.token

  # By encoding the context to the JWT payload, we avoid having to
  # fetch the context for subsequent Userbin calls during the
  # current request
  jwt = Userbin::JWT.new(session_token)
  jwt.merge!(context: opts[:context])
  jwt.to_token
end

.config ⇒ Object 



13
14
15
 
# File 'lib/userbin/configuration.rb', line 13

def config
  @configuration ||= Userbin::Configuration.new
end

.configure(config_hash = nil) {|config| ... } ⇒ Object

Yields:



3
4
5
6
7
8
9
10
11
 
# File 'lib/userbin/configuration.rb', line 3

def configure(config_hash=nil)
  if config_hash
    config_hash.each do |k,v|
      config.send("#{k}=", v)
    end
  end

  yield(config) if block_given?
end

.deauthenticate(session_token) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/userbin/helpers.rb', line 32

def deauthenticate(session_token)
  return unless session_token

  # Extract context from authenticated session token
  jwt = Userbin::JWT.new(session_token)
  context = jwt.payload['context']

  Userbin.with_context(context) do
    Userbin::Session.destroy_existing(session_token)
  end
end

.security_settings_url(session_token) ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/userbin/helpers.rb', line 72

def security_settings_url(session_token)
  return '' unless session_token
  begin
    app_id = Userbin::JWT.new(session_token).app_id
    "https://security.userbin.com/?session_token=#{session_token}"
  rescue Userbin::Error
    ''
  end
end

.setup_api(api_secret = nil) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/userbin/utils.rb', line 5

def setup_api(api_secret = nil)
  api_endpoint = ENV.fetch('USERBIN_API_ENDPOINT') {
    "https://secure.userbin.com/v1"
  }

  Her::API.setup url: api_endpoint do |c|
    c.use Userbin::Request::Middleware::BasicAuth, api_secret
    c.use Userbin::Request::Middleware::EnvironmentHeaders
    c.use Userbin::Request::Middleware::ContextHeaders
    c.use FaradayMiddleware::EncodeJson
    c.use Userbin::Request::Middleware::JSONParser
    c.use Faraday::Adapter::NetHttp
  end
end

.two_factor_authenticate!(session_token) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/userbin/helpers.rb', line 44

def two_factor_authenticate!(session_token)
  return unless session_token

  challenge = Userbin::JWT.new(session_token).payload['challenge']

  if challenge
    case challenge['type']
    when 'otp_authenticator' then :authenticator
    when 'otp_sms' then :sms
    end
  end
end

.verify_code(session_token, response) ⇒ Object

TODO: almost the same as deauthenticate. Refactor?



58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/userbin/helpers.rb', line 58

def verify_code(session_token, response)
  return unless session_token

  # Extract context from authenticated session token
  jwt = Userbin::JWT.new(session_token)
  context = jwt.payload['context']

  session = Userbin.with_context(context) do
    Userbin::Session.new(token: session_token).verify(response: response)
  end

  session.token
end

.with_context(opts, &block) ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/userbin/utils.rb', line 20

def with_context(opts, &block)
  return block.call unless opts
  RequestStore.store[:userbin_headers] = {}
  RequestStore.store[:userbin_headers][:ip] = opts[:ip] if opts[:ip]
  RequestStore.store[:userbin_headers][:user_agent] = opts[:user_agent] if opts[:user_agent]
  block.call
end