Class: Userbin::Client

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(request, cookies, opts = {}) ⇒ Client

Returns a new instance of Client.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/userbin/client.rb', line 20

def initialize(request, cookies, opts = {})
  # Save a reference in the per-request store so that the request
  # middleware in request.rb can access it
  RequestStore.store[:userbin] = self

  # By default the session token is persisted in the Rack store, which may
  # in turn point to any source. This option give you an option to
  # use any store, such as Redis or Memcached to store your Userbin tokens.
  if opts[:session_store]
    @session_store = opts[:session_store]
  else
    @session_store = Userbin::SessionStore::Rack.new(request.session)
  end

  @trusted_token_store = Userbin::TrustedTokenStore::Rack.new(cookies)

  @request_context = {
    ip: request.ip,
    user_agent: request.user_agent
  }
end

Instance Attribute Details

#request_context ⇒ Object

Returns the value of attribute request_context.



4
5
6
 
# File 'lib/userbin/client.rb', line 4

def request_context
  @request_context
end

Class Method Details

.install_proxy_methods(*names) ⇒ Object 



6
7
8
9
10
11
12
13
14
 
# File 'lib/userbin/client.rb', line 6

def self.install_proxy_methods(*names)
  names.each do |name|
    class_eval "      def \#{name}(*args)\n        Userbin::User.new('$current').\#{name}(*args)\n      end\n    RUBY\n  end\nend\n", __FILE__, __LINE__ + 1

Instance Method Details

#authorize ⇒ Object 



75
76
77
78
79
80
81
 
# File 'lib/userbin/client.rb', line 75

def authorize
  return unless session_token

  if session_token.expired?
    Userbin::Monitoring.heartbeat
  end
end

#authorize! ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/userbin/client.rb', line 87

def authorize!
  unless session_token
    raise Userbin::UserUnauthorizedError,
      'Need to call login before authorize'
  end

  authorize

  if mfa_in_progress?
    logout
    raise Userbin::UserUnauthorizedError,
        'Logged out due to being unverified'
  end

  if mfa_required? && !device_trusted?
    raise Userbin::ChallengeRequiredError
  end
end

#authorized? ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/userbin/client.rb', line 83

def authorized?
  !!session_token
end

#device_trusted? ⇒ Boolean

Returns:

  • (Boolean) 


149
150
151
 
# File 'lib/userbin/client.rb', line 149

def device_trusted?
  session_token ? session_token.device_trusted? : false
end

#has_default_pairing? ⇒ Boolean

Returns:

  • (Boolean) 


161
162
163
 
# File 'lib/userbin/client.rb', line 161

def has_default_pairing?
  session_token ? session_token.has_default_pairing? : false
end

#identify(user_id) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/userbin/client.rb', line 67

def identify(user_id)
  # The user identifier is used in API paths so it needs to be cleaned
  user_id = URI.encode(user_id.to_s)

  @session_store.user_id = user_id
  @trusted_token_store.user_id = user_id
end

#login(user_id, user_attrs = {}) ⇒ Object 



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

def (user_id, user_attrs = {})
  # Clear the session token if any
  self.session_token = nil

  identify(user_id)

  user = Userbin::User.new(@session_store.user_id)
  session = user.sessions.create(
    user: user_attrs, trusted_device_token: self.trusted_device_token)

  # Set the session token for use in all subsequent requests
  self.session_token = session.token

  session
end

#logout ⇒ Object

This method ends the current monitoring session. It should be called whenever the user logs out from your system.



132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/userbin/client.rb', line 132

def logout
  return unless session_token

  # Destroy the current session specified in the session token
  begin
    sessions.destroy('$current')
  rescue Userbin::Error # ignored
  end

  # Clear the session token
  self.session_token = nil
end

#mfa_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


145
146
147
 
# File 'lib/userbin/client.rb', line 145

def mfa_enabled?
  session_token ? session_token.mfa_enabled? : false
end

#mfa_in_progress? ⇒ Boolean

Returns:

  • (Boolean) 


153
154
155
 
# File 'lib/userbin/client.rb', line 153

def mfa_in_progress?
  session_token ? session_token.has_challenge? : false
end

#mfa_required? ⇒ Boolean

Returns:

  • (Boolean) 


157
158
159
 
# File 'lib/userbin/client.rb', line 157

def mfa_required?
  session_token ? session_token.needs_challenge? : false
end

#session_token ⇒ Object 



50
51
52
53
 
# File 'lib/userbin/client.rb', line 50

def session_token
  token = @session_store.read
  Userbin::SessionToken.new(token) if token
end

#session_token=(value) ⇒ Object 



42
43
44
45
46
47
48
 
# File 'lib/userbin/client.rb', line 42

def session_token=(value)
  if value && value != @session_store.read
    @session_store.write(value)
  elsif !value
    @session_store.destroy
  end
end

#trust_device(attrs = {}) ⇒ Object 



122
123
124
125
126
127
 
# File 'lib/userbin/client.rb', line 122

def trust_device(attrs = {})
  trusted_device = trusted_devices.create(attrs)

  # Set the session token for use in all subsequent requests
  self.trusted_device_token = trusted_device.token
end

#trusted_device_token ⇒ Object 



63
64
65
 
# File 'lib/userbin/client.rb', line 63

def trusted_device_token
  @trusted_token_store.read
end

#trusted_device_token=(value) ⇒ Object 



55
56
57
58
59
60
61
 
# File 'lib/userbin/client.rb', line 55

def trusted_device_token=(value)
  if value && value != @trusted_token_store.read
    @trusted_token_store.write(value)
  elsif !value
    @trusted_token_store.destroy
  end
end