def __init__(self, request_executor, base_url = None):

        assert_instance(request_executor, HttpClientRequestExecutor, "request_executor")

        self.base_url = self._get_base_url_(base_url)
        self.request_executor = request_executor
        self.resource_factory = ResourceFactory(self)
    def __init__(self, client_builder = None):

        self.application_href = None
        if (client_builder):
            assert_instance(client_builder, ClientBuilder, 'client_builder')
            self.client_builder = client_builder
        else:
            self.client_builder = ClientBuilder()
    def _save_(self, href, resource, return_type):

        assert_instance(resource, Resource, "resource")
        assert_subclass(return_type, Resource, "return_type")

        q_href = self._qualify_(href) if self._needs_to_be_fully_qualified_(href) else href

        response = self._execute_request_('post', q_href, json.dumps(self._to_dict_(resource)))

        return  self.resource_factory.instantiate(return_type, response)
    def execute_request(self, request):

        full_request_name = Request.__module__ + "." + Request.__name__
        assert_instance(request, Request, "request argument must be an instance of {}.".format(full_request_name))

        if self.api_key:
            self.signer.sign_request(api_key=self.api_key, request=request)

        self._add_query_string_to_href_(request)

        resp, content = self.http_client.request(request.href, request.http_method, request.body, request.http_headers)

        return Response(int(resp.status), resp.get('content-type'), content.decode())
    def _get_href_with_user_info_(self, href, at_sign_index):
        assert_instance(href, str, 'href')
        assert_instance(at_sign_index, int, 'at_sign_index')

        double_slash_index = href.find('//')

        assert_true(double_slash_index > 0, 'Invalid application href URL')

        parts = {}
        parts[0] = href[0:double_slash_index + 2] #up to and including the double slash
        parts[1] = href[double_slash_index + 2:at_sign_index] #raw user info
        parts[2] = href[at_sign_index + 1:len(href)] #after the @ character

        return parts
Exemplo n.º 6
0
    def authenticate(self, parent_href, request):
        assert_not_none(parent_href, "parent_href must be specified.")
        assert_instance(request, UsernamePasswordRequest, 'request')

        username = request.principals if request.principals else ''
        password = request.credentials if request.credentials else ''

        value = base64.b64encode(bytes((username + ':' + password).encode()))

        attempt = self.data_store.instantiate(BasicLoginAttempt)
        attempt.type('basic')
        attempt.value(value.decode())

        href = parent_href + '/loginAttempts'

        return self.data_store.create(href, attempt, AuthenticationResult)
    def save(self, resource, clazz = None):

        assert_instance(resource, Resource, "resource")

        href = resource.href
        assert_true(href, "save may only be called on objects that have already been persisted (i.e. they have an existing href).")

        href = self._qualify_(href) if self._needs_to_be_fully_qualified_(href) else href

        clazz = clazz if clazz else resource.__class__

        returned_resource = self._save_(href, resource, clazz)

        # ensure the caller's argument is updated with what is returned from the server:
        resource.set_properties(returned_resource.properties)

        return returned_resource
Exemplo n.º 8
0
 def __init__(self, api_key, base_url = None):
     assert_instance(api_key, ApiKey, 'api_key')
     request_executor = HttpClientRequestExecutor(api_key)
     self.data_store = DataStore(request_executor, base_url)
 def create_application(self, application):
     assert_instance(application, stormpath.resource.Application, 'application')
     href = '/applications' #TODO enable auto discovery
     return self.data_store.create(href, application, stormpath.resource.Application)
    def delete(self, resource):

        assert_instance(resource, Resource, 'resource')

        self._execute_request_('delete', resource.href)
    def __init__(self, data_store):

        assert_instance(data_store, DataStore, "data_store")
        self.data_store = data_store
Exemplo n.º 12
0
 def __init__(self, data_store):
     assert_instance(data_store, stormpath.ds.DataStore, 'data_store')
     self.data_store = data_store