Beispiel #1
0
    def post(self, request, largs, name, dry=False):
        """
        Create a new property.
        """
        if not request.user.has_perm('Users.prop_create'):
            return HttpResponseForbidden()

        # If AssertionError: 400 Bad Request
        key, value = self._parse_post(request)
        if not resource_validator(key):
            raise PreconditionFailed("Property contains invalid characters")

        # If UserNotFound: 404 Not Found
        user = user_backend.get(username=name)

        # If PropertyExists: 409 Conflict
        key, value = property_backend.create(user=user,
                                             key=key,
                                             value=value,
                                             dry=dry)

        self.log.info('Created property "%s" as "%s"', key, value, extra=largs)
        return HttpResponseCreated(request,
                                   'users.user.props.prop',
                                   name=name,
                                   subname=key)
Beispiel #2
0
    def post(self, request, largs, dry=False):
        """Create a new user."""

        if not request.user.has_perm('Users.user_create'):
            return HttpResponseForbidden()

        name, password, properties = self._parse_post(request)
        name = name.lower()

        # check username:
        if not resource_validator(name):
            raise PreconditionFailed("Username contains invalid characters")
        # If UsernameInvalid: 412 Precondition Failed
        validate_username(name)

        # check password:
        if password is not None and password != '':
            if len(password) < settings.MIN_PASSWORD_LENGTH:
                raise PasswordInvalid("Password too short")

        # check properties:
        if properties is not None:
            for key in six.iterkeys(properties):
                if not resource_validator(key):
                    raise PreconditionFailed(
                        "Property contains invalid characters")

        # If ResourceExists: 409 Conflict
        # If PasswordInvalid: 412 Precondition Failed
        user = user_backend.create(username=name,
                                   password=password,
                                   properties=properties,
                                   property_backend=property_backend,
                                   dry=dry)

        self.log.info('%s: Created user', user.username, extra=largs)
        return HttpResponseCreated(request, 'users.user', name=user.username)
Beispiel #3
0
    def put(self, request, largs, name):
        """
        Set multiple properties.
        """
        if not request.user.has_perm('Users.prop_create'):
            return HttpResponseForbidden()

        # If UserNotFound: 404 Not Found
        user = user_backend.get(username=name)
        properties = parse_dict(request)
        for key in six.iterkeys(properties):
            if not resource_validator(key):
                raise PreconditionFailed(
                    "Property contains invalid characters")

        property_backend.set_multiple(user=user, props=properties)
        return HttpResponseNoContent()
Beispiel #4
0
    def post(self, request, largs, dry=False):
        """
        Create a new group.
        """
        if not request.user.has_perm('Groups.group_create'):
            return HttpResponseForbidden()

        # If BadRequest: 400 Bad Request
        groupname = self._parse_post(request).lower()
        if not resource_validator(groupname):
            raise PreconditionFailed('Group name contains invalid characters!')

        # If ResourceExists: 409 Conflict
        group = group_backend.create(service=request.user,
                                     name=groupname,
                                     dry=dry)

        self.log.info('%s: Created group', group.name, extra=largs)
        return HttpResponseCreated(request, 'groups.group',
                                   name=group.name)  # Created
Beispiel #5
0
    def __call__(self, parser, namespace, value, option_string):
        username = value.lower()
        if not six.PY3:  # pragma: no branch, pragma: py2
            username = username.decode('utf-8')

        if namespace.create_user:
            if not resource_validator(username):
                raise ArgumentError(self, "Username contains invalid characters")

            try:
                validate_username(username)
                user = user_backend.create(username=username, property_backend=property_backend)
            except UserExists:
                raise ArgumentError(self, 'User already exists.')
            except PreconditionFailed as e:
                raise ArgumentError(self, e)
        else:
            try:
                user = user_backend.get(username=username)
            except UserNotFound:
                raise ArgumentError(self, 'User does not exist.')
        setattr(namespace, self.dest, user)
Beispiel #6
0
 def test_stringprep(self):
     self.assertFalse(resource_validator('foo\u2000bar'))  # C.1.2 Non-ASCII space characters
     self.assertFalse(resource_validator('foo\u0002bar'))  # C.2.1 ASCII control characters
     self.assertFalse(resource_validator('foo\u001Fbar'))  # C.2.1 ASCII control characters
     self.assertFalse(resource_validator('foo\u180Ebar'))  # C.2.2 Non-ASCII control characters
     self.assertFalse(resource_validator('foo\uE000bar'))  # C.3 Private use
     self.assertFalse(resource_validator('foo\uFDD0bar'))  # C.4 Non-character code points
     self.assertFalse(resource_validator('foo\uD800bar'))  # C.5 Surrogate codes
     self.assertFalse(resource_validator('foo\uFFFDbar'))  # C.6 Inappropriate for plain text
     self.assertFalse(resource_validator('foo\u2FF0bar'))  # C.7 Inappropriate for canonical representation
     self.assertFalse(resource_validator('foo\u0340bar'))  # C.8 Change display properties or are deprecated
     self.assertFalse(resource_validator('foo\uE0001bar'))  # C.9 Tagging characters
     self.assertFalse(resource_validator('foo\U000E0001bar'))  # C.9 Tagging characters
Beispiel #7
0
 def test_ok(self):
     self.assertTrue(resource_validator(username1))
     self.assertTrue(resource_validator(username2))
     self.assertTrue(resource_validator(str('foobar')))