Add filter, risk and log endpoint clients

README.rst

@@ -118,11 +118,10 @@ Here is a simple example of track event.
 .. code:: python
 
     from castle.client import Client
-    from castle import events
 
     castle = Client.from_request(request)
     castle.track({
-      'event': '$login',
+      'event': '$login.succeeded',
       'user_id': 'user_id'
     })
 
@@ -148,11 +147,10 @@ background worker you can generate data for a worker:
 .. code:: python
 
     from castle.payload.prepare import PayloadPrepare
-    from castle import events
 
     payload = PayloadPrepare.call(
         {
-          'event': $login,
+          'event': '$login.succeeded',
           'user_id': user.id,
           'properties': { 'key': 'value' },
           'user_traits': { 'key': 'value' }

castle/client.py

@@ -1,5 +1,8 @@
 from castle.api_request import APIRequest
 from castle.commands.authenticate import CommandsAuthenticate
+from castle.commands.filter import CommandsFilter
+from castle.commands.log import CommandsLog
+from castle.commands.risk import CommandsRisk
 from castle.commands.start_impersonation import CommandsStartImpersonation
 from castle.commands.end_impersonation import CommandsEndImpersonation
 from castle.commands.track import CommandsTrack
@@ -21,11 +24,11 @@ def from_request(cls, request, options=None):
         return cls(options)
 
     @staticmethod
-    def failover_response_or_raise(options, exception):
+    def failover_response_or_raise(user_id, exception):
         if configuration.failover_strategy == FailoverStrategy.THROW.value:
             raise exception
         return FailoverPrepareResponse(
-            options.get('user_id'), None, exception.__class__.__name__
+            user_id, None, exception.__class__.__name__
         ).call()
 
     def __init__(self, options=None):
@@ -49,14 +52,55 @@ def authenticate(self, options):
                 response.update(failover=False, failover_reason=None)
                 return response
             except (RequestError, InternalServerError) as exception:
-                return Client.failover_response_or_raise(options, exception)
+                return Client.failover_response_or_raise(options.get('user_id'), exception)
         else:
             return FailoverPrepareResponse(
                 options.get('user_id'),
                 'allow',
                 'Castle set to do not track.'
             ).call()
 
+    def filter(self, options):
+        if self.tracked():
+            self._add_timestamp_if_necessary(options)
+            command = CommandsFilter(self.context).call(options)
+            try:
+                response = self.api.call(command)
+                response.update(failover=False, failover_reason=None)
+                return response
+            except (RequestError, InternalServerError) as exception:
+                return Client.failover_response_or_raise(options.get('user').get('id'), exception)
+        else:
+            return FailoverPrepareResponse(
+                options.get('user').get('id'),
+                'allow',
+                'Castle set to do not track.'
+            ).call()
+
+    def log(self, options):
+        if not self.tracked():
+            return None
+        self._add_timestamp_if_necessary(options)
+
+        return self.api.call(CommandsLog(self.context).call(options))
+
+    def risk(self, options):
+        if self.tracked():
+            self._add_timestamp_if_necessary(options)
+            command = CommandsRisk(self.context).call(options)
+            try:
+                response = self.api.call(command)
+                response.update(failover=False, failover_reason=None)
+                return response
+            except (RequestError, InternalServerError) as exception:
+                return Client.failover_response_or_raise(options.get('user').get('id'), exception)
+        else:
+            return FailoverPrepareResponse(
+                options.get('user').get('id'),
+                'allow',
+                'Castle set to do not track.'
+            ).call()
+
     def start_impersonation(self, options):
         self._add_timestamp_if_necessary(options)
         response = self.api.call(CommandsStartImpersonation(self.context).call(options))

castle/commands/filter.py

@@ -0,0 +1,20 @@
+from castle.command import Command
+from castle.utils.timestamp import UtilsTimestamp as generate_timestamp
+from castle.context.merge import ContextMerge
+from castle.context.sanitize import ContextSanitize
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsFilter(object):
+    def __init__(self, context):
+        self.context = context
+
+    def call(self, options):
+        ValidatorsPresent.call(options, 'event')
+        context = ContextMerge.call(self.context, options.get('context'))
+        context = ContextSanitize.call(context)
+        if context:
+            options.update({'context': context})
+        options.update({'sent_at': generate_timestamp.call()})
+
+        return Command(method='post', path='filter', data=options)

castle/commands/log.py

@@ -0,0 +1,20 @@
+from castle.command import Command
+from castle.utils.timestamp import UtilsTimestamp as generate_timestamp
+from castle.context.merge import ContextMerge
+from castle.context.sanitize import ContextSanitize
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsLog(object):
+    def __init__(self, context):
+        self.context = context
+
+    def call(self, options):
+        ValidatorsPresent.call(options, 'event')
+        context = ContextMerge.call(self.context, options.get('context'))
+        context = ContextSanitize.call(context)
+        if context:
+            options.update({'context': context})
+        options.update({'sent_at': generate_timestamp.call()})
+
+        return Command(method='post', path='log', data=options)

castle/commands/risk.py

@@ -0,0 +1,20 @@
+from castle.command import Command
+from castle.utils.timestamp import UtilsTimestamp as generate_timestamp
+from castle.context.merge import ContextMerge
+from castle.context.sanitize import ContextSanitize
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsRisk(object):
+    def __init__(self, context):
+        self.context = context
+
+    def call(self, options):
+        ValidatorsPresent.call(options, 'event')
+        context = ContextMerge.call(self.context, options.get('context'))
+        context = ContextSanitize.call(context)
+        if context:
+            options.update({'context': context})
+        options.update({'sent_at': generate_timestamp.call()})
+
+        return Command(method='post', path='risk', data=options)

castle/test/client_test.py

@@ -109,7 +109,7 @@ def test_authenticate_tracked_true(self):
             status=200
         )
         client = Client.from_request(request(), {})
-        options = {'event': '$login.authenticate', 'user_id': '1234'}
+        options = {'event': '$login.succeeded', 'user_id': '1234'}
         response_text.update(failover=False, failover_reason=None)
         self.assertEqual(client.authenticate(options), response_text)
 
@@ -128,7 +128,7 @@ def test_authenticate_tracked_true_status_500(self):
             status=500
         )
         client = Client.from_request(request(), {})
-        options = {'event': '$login.authenticate', 'user_id': '1234'}
+        options = {'event': '$login.succeeded', 'user_id': '1234'}
         self.assertEqual(client.authenticate(options), response_text)
 
     def test_authenticate_tracked_false(self):
@@ -140,7 +140,7 @@ def test_authenticate_tracked_false(self):
         }
         client = Client.from_request(request(), {})
         client.disable_tracking()
-        options = {'event': '$login.authenticate', 'user_id': '1234'}
+        options = {'event': '$login.succeeded', 'user_id': '1234'}
         self.assertEqual(client.authenticate(options), response_text)
 
     @responses.activate
@@ -153,14 +153,155 @@ def test_track_tracked_true(self):
             status=200
         )
         client = Client.from_request(request(), {})
-        options = {'event': '$login.authenticate', 'user_id': '1234'}
+        options = {'event': '$login.succeeded', 'user_id': '1234'}
         self.assertEqual(client.track(options), response_text)
 
     def test_track_tracked_false(self):
         client = Client.from_request(request(), {})
         client.disable_tracking()
         self.assertEqual(client.track({}), None)
 
+    @responses.activate
+    def test_filter_tracked_true(self):
+        response_text = {'action': Verdict.ALLOW.value, 'user_id': '1234'}
+        responses.add(
+            responses.POST,
+            'https://api.castle.io/v1/filter',
+            json=response_text,
+            status=200
+        )
+        client = Client.from_request(request(), {})
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        response_text.update(failover=False, failover_reason=None)
+        self.assertEqual(client.filter(options), response_text)
+
+    @responses.activate
+    def test_filter_tracked_true_status_500(self):
+        response_text = {
+            'action': Verdict.ALLOW.value,
+            'user_id': '1234',
+            'failover': True,
+            'failover_reason': 'InternalServerError'
+        }
+        responses.add(
+            responses.POST,
+            'https://api.castle.io/v1/filter',
+            json='filter',
+            status=500
+        )
+        client = Client.from_request(request(), {})
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        self.assertEqual(client.filter(options), response_text)
+
+    def test_filter_tracked_false(self):
+        response_text = {
+            'action': Verdict.ALLOW.value,
+            'user_id': '1234',
+            'failover': True,
+            'failover_reason': 'Castle set to do not track.'
+        }
+        client = Client.from_request(request(), {})
+        client.disable_tracking()
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        self.assertEqual(client.filter(options), response_text)
+
+    @responses.activate
+    def test_log_tracked_true(self):
+        response_text = 'log'
+        responses.add(
+            responses.POST,
+            'https://api.castle.io/v1/log',
+            json=response_text,
+            status=200
+        )
+        client = Client.from_request(request(), {})
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        self.assertEqual(client.log(options), response_text)
+
+    def test_log_tracked_false(self):
+        client = Client.from_request(request(), {})
+        client.disable_tracking()
+        self.assertEqual(client.log({}), None)
+
+    @responses.activate
+    def test_risk_tracked_true(self):
+        response_text = {'action': Verdict.ALLOW.value, 'user_id': '1234'}
+        responses.add(
+            responses.POST,
+            'https://api.castle.io/v1/risk',
+            json=response_text,
+            status=200
+        )
+        client = Client.from_request(request(), {})
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        response_text.update(failover=False, failover_reason=None)
+        self.assertEqual(client.risk(options), response_text)
+
+    @responses.activate
+    def test_risk_tracked_true_status_500(self):
+        response_text = {
+            'action': Verdict.ALLOW.value,
+            'user_id': '1234',
+            'failover': True,
+            'failover_reason': 'InternalServerError'
+        }
+        responses.add(
+            responses.POST,
+            'https://api.castle.io/v1/risk',
+            json='risk',
+            status=500
+        )
+        client = Client.from_request(request(), {})
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        self.assertEqual(client.risk(options), response_text)
+
+    def test_risk_tracked_false(self):
+        response_text = {
+            'action': Verdict.ALLOW.value,
+            'user_id': '1234',
+            'failover': True,
+            'failover_reason': 'Castle set to do not track.'
+        }
+        client = Client.from_request(request(), {})
+        client.disable_tracking()
+        options = {
+            'request_token': '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
+            'event': '$login',
+            'status': '$succeeded',
+            'user': {'id': '1234'}
+        }
+        self.assertEqual(client.risk(options), response_text)
+
     def test_disable_tracking(self):
         client = Client.from_request(request(), {})
         client.disable_tracking()
@@ -184,7 +325,7 @@ def test_tracked_when_do_not_track_true(self):
     def test_failover_strategy_not_throw(self):
         options = {'user_id': '1234'}
         self.assertEqual(
-            Client.failover_response_or_raise(options, Exception()),
+            Client.failover_response_or_raise(options.get('user_id'), Exception()),
             {
                 'action': Verdict.ALLOW.value,
                 'user_id': '1234',