def setUp(self):
self.init()
self.login_url = reverse('rest_login')
self.password_change_url = reverse('rest_password_change')
self.register_url = reverse('rest_register')
self.password_reset_url = reverse('rest_password_reset')
self.user_url = reverse('rest_user_details')
setattr(settings, 'REST_PROFILE_MODULE', self.PROFILE_MODEL)
self.user_profile_model = None
if self.PROFILE_MODEL:
self.user_profile_model = _resolve_model(self.PROFILE_MODEL)
if self.REGISTRATION_VIEW:
setattr(settings, 'REST_REGISTRATION_BACKEND', self.REGISTRATION_VIEW)
elif hasattr(settings, 'REST_REGISTRATION_BACKEND'):
delattr(settings, 'REST_REGISTRATION_BACKEND')
def setUp(self):
self.init()
self.login_url = reverse('rest_login')
self.password_change_url = reverse('rest_password_change')
self.register_url = reverse('rest_register')
self.password_reset_url = reverse('rest_password_reset')
self.user_url = reverse('rest_user_details')
setattr(settings, 'REST_PROFILE_MODULE', self.PROFILE_MODEL)
self.user_profile_model = None
if self.PROFILE_MODEL:
self.user_profile_model = _resolve_model(self.PROFILE_MODEL)
if self.REGISTRATION_VIEW:
setattr(settings, 'REST_REGISTRATION_BACKEND',
self.REGISTRATION_VIEW)
elif hasattr(settings, 'REST_REGISTRATION_BACKEND'):
delattr(settings, 'REST_REGISTRATION_BACKEND')
def register(self, request, **cleaned_data):
username, email, password = cleaned_data['username'], cleaned_data['email'], cleaned_data['password1']
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
new_user = RegistrationProfile.objects.create_inactive_user(username, email,
password, site, send_email=False)
signals.user_registered.send(sender=self.__class__,
user=new_user,
request=request)
# create user profile
user_profile_model = _resolve_model(
getattr(settings, 'REST_PROFILE_MODULE', None))
user_profile_model.objects.create(user=new_user)
return new_user
def register(self, request, **cleaned_data):
username, email, password = cleaned_data['username'], cleaned_data[
'email'], cleaned_data['password1']
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
new_user = RegistrationProfile.objects.create_inactive_user(
username, email, password, site, send_email=False)
signals.user_registered.send(sender=self.__class__,
user=new_user,
request=request)
# create user profile
user_profile_model = _resolve_model(
getattr(settings, 'REST_PROFILE_MODULE', None))
user_profile_model.objects.create(user=new_user)
return new_user
def restore_fields(self, data, files):
"""
Core of deserialization, together with `restore_object`.
Converts a dictionary of data into a dictionary of deserialized fields.
"""
reverted_data = {}
copy_data = data.copy()
if data is not None and not isinstance(data, dict):
self._errors['non_field_errors'] = ['Invalid data']
return None
for field_name, field in self.fields.items():
copy_data.pop(field_name, None)
self.restore_initialize_field(field_name, field, data, files, reverted_data)
# what's left of the data
cls = self.opts.model
assert cls is not None, \
"Serializer class '%s' is missing 'model' Meta option" % self.__class__.__name__
opts = get_concrete_model(cls)._meta
nested = bool(self.opts.depth)
for field_name in copy_data.keys():
try:
model_field_tuple = opts.get_field_by_name(field_name)
model_field = model_field_tuple[0]
except models.FieldDoesNotExist:
continue
if model_field.rel:
related_model = _resolve_model(model_field.rel.to)
to_many = isinstance(model_field,
models.fields.related.ManyToManyField)
if nested:
field = self.get_nested_field(model_field, related_model, to_many)
else:
field = self.get_related_field(model_field, related_model, to_many)
self.restore_initialize_field(field_name, field, data, files, reverted_data)
return reverted_data
def get_default_fields(self):
"""
Overriding get_default_fields to do two things:
2. Add suffix '_id' to all foreign keys
"""
ret = super(AutoModelSerializer, self).get_default_fields()
# Deal with forward relationships
cls = self.opts.model
opts = get_concrete_model(cls)._meta
related_fields = [field for field in opts.fields if field.serialize if field.rel]
# adding embedded fields for the foreign keys
for model_field in related_fields:
field_name = model_field.name
del ret[field_name]
to_many = isinstance(model_field, ManyToManyField)
if not to_many:
related_model = _resolve_model(model_field.rel.to)
ret[field_name + '_id'] = self.get_related_field_with_source(model_field, related_model, to_many,
source=field_name)
# adding links field
ret['_meta'] = MetaField()
ret['_embedded'] = EmbeddedObjectsField(cls, embedded_def_dict=self.embedded_def_dict)
# adding fields for properties
for p_name, p_val in class_properties_with_attr(cls, 'field_class'):
field_name = getattr(p_val, 'name', p_name) or p_name # we use property name as field name by default
ret[field_name] = p_val.field_class(source=p_name)
return ret
def test_resolve_improper_string_representation(self):
with self.assertRaises(ValueError):
_resolve_model('BasicModel')
self.assertEqual(
bool(
filter(lambda x: content_type in x,
response._headers['content-type'])), True)
return response
def init(self):
settings.DEBUG = True
self.client = APIClient()
# -----------------------
# T E S T H E R E
# -----------------------
user_profile_model = _resolve_model(
getattr(settings, 'REST_PROFILE_MODULE', None))
class LoginAPITestCase(TestCase, BaseAPITestCase):
"""
just run: python manage.py test rest_auth
"""
USERNAME = '******'
PASS = '******'
EMAIL = "*****@*****.**"
NEW_PASS = '******'
def setUp(self):
self.init()
self.login_url = reverse('rest_login')
response = self.send_request('get', *args, **kwargs)
if content_type:
self.assertEqual(
bool(filter(lambda x: content_type in x, response._headers['content-type'])), True)
return response
def init(self):
settings.DEBUG = True
self.client = APIClient()
# -----------------------
# T E S T H E R E
# -----------------------
user_profile_model = _resolve_model(
getattr(settings, 'REST_PROFILE_MODULE', None))
class LoginAPITestCase(TestCase, BaseAPITestCase):
"""
just run: python manage.py test rest_auth
"""
USERNAME = '******'
PASS = '******'
EMAIL = "*****@*****.**"
NEW_PASS = '******'
def setUp(self):
self.init()
self.login_url = reverse('rest_login')
def get_user_profile_model():
# Get the UserProfile model from the setting value
user_profile_path = getattr(settings, 'REST_PROFILE_MODULE', None)
if user_profile_path:
setattr(settings, 'AUTH_PROFILE_MODULE', user_profile_path)
return _resolve_model(user_profile_path)
class Meta:
# http://stackoverflow.com/questions/4881607/django-get-model-from-string
model = _resolve_model(getattr(settings, 'REST_PROFILE_MODULE', None))
class Meta:
model = _resolve_model(getattr(settings, 'REST_PROFILE_MODULE', None))
fields = filter(lambda x: x != 'id' and x != 'user',
map(lambda x: x.name, model._meta.fields))
def field_to_native(self, obj, the_field_name):
result = {}
embedded_def_dict = self.get_embedded_def_dict() or {}
# for the foreign keys
for model_field in self.related_fields:
field_name = model_field.name
related_model = _resolve_model(model_field.rel.to)
if field_name in embedded_def_dict:
result[field_name] = serialize_model(related_model,
getattr(obj, field_name),
embedded_def_dict[field_name])
# for the reverse relations
for relation in self.reverse_rels:
relation_name = relation.get_accessor_name()
if relation_name not in embedded_def_dict:
continue
related_model = relation.model
to_many = relation.field.rel.multiple
if to_many:
result[relation_name] = serialize_queryset(related_model,
getattr(obj, relation_name).all(),
embedded_def_dict[relation_name])
else:
try:
instance = getattr(obj, relation_name)
except ObjectDoesNotExist:
instance = None
result[relation_name] = serialize_model(related_model,
instance,
embedded_def_dict[relation_name])
# embedded functions
for method_name, method in self.embedded_functions():
if method_name and method_name in embedded_def_dict:
embedded_result = method(obj) # calling the method
result[method_name] = convert_result(embedded_result,
embedded_def_dict[method_name],
getattr(method, 'rest_data_type', None),
getattr(method, 'rest_many', False))
# embedded properties
for prop_name, descriptor in self.embedded_properties():
if prop_name and prop_name in embedded_def_dict:
embedded_result = getattr(obj, prop_name) # getting property value
result[prop_name] = convert_result(embedded_result,
embedded_def_dict[prop_name],
getattr(descriptor, 'rest_data_type', None),
getattr(descriptor, 'rest_many', False))
return result
def get_user_profile_model():
# Get the UserProfile model from the setting value
user_profile_path = getattr(settings, 'REST_PROFILE_MODULE', None)
if user_profile_path:
setattr(settings, 'AUTH_PROFILE_MODULE', user_profile_path)
return _resolve_model(user_profile_path)
class Meta:
model = _resolve_model(profile_model_path())
fields = filter(lambda x: x != 'id' and x != 'user',
map(lambda x: x.name, model._meta.fields))
def test_resolve_non_django_model(self):
with self.assertRaises(ValueError):
_resolve_model(TestCase)
def test_resolve_unicode_representation(self):
resolved_model = _resolve_model(six.text_type('tests.BasicModel'))
self.assertEqual(resolved_model, BasicModel)
def test_resolve_string_representation(self):
resolved_model = _resolve_model('tests.BasicModel')
self.assertEqual(resolved_model, BasicModel)
def test_resolve_django_model(self):
resolved_model = _resolve_model(BasicModel)
self.assertEqual(resolved_model, BasicModel)
class Meta:
# http://stackoverflow.com/questions/4881607/django-get-model-from-string
model = _resolve_model(profile_model_path())
def get_default_fields(self, base_fields):
"""
Return all the fields that should be serialized for the model.
"""
cls = self.opts.model
assert cls is not None, \
"Serializer class '%s' is missing 'model' Meta option" % self.__class__.__name__
opts = get_concrete_model(cls)._meta
ret = SortedDict()
nested = bool(self.opts.depth)
# Deal with adding the primary key field
pk_field = opts.pk
while pk_field.rel and pk_field.rel.parent_link:
# If model is a child via multitable inheritance, use parent's pk
pk_field = pk_field.rel.to._meta.pk
field = self.get_pk_field(pk_field)
if field:
ret[pk_field.name] = field
# Deal with forward relationships
forward_rels = [field for field in opts.fields if field.serialize]
forward_rels += [field for field in opts.many_to_many if field.serialize]
for model_field in forward_rels:
has_through_model = False
if model_field.rel:
to_many = isinstance(model_field,
models.fields.related.ManyToManyField)
related_model = _resolve_model(model_field.rel.to)
if to_many and not model_field.rel.through._meta.auto_created:
has_through_model = True
if model_field.rel and nested:
self.add_field_to_embedded(model_field.name, self.get_nested_field(model_field, related_model, to_many))
elif model_field.rel and model_field.name in base_fields:
key = model_field.name
field = base_fields[key]
if isinstance(field, HyperlinkedRelatedField):
self.add_field_to_links(key, field)
else:
self.add_field_to_embedded(key, field)
ret[model_field.name] = field
elif model_field.rel:
field = self.get_related_field(model_field, related_model, to_many)
if model_field.name not in self.additional_links:
self.add_field_to_links(model_field.name, field)
ret[model_field.name] = field
else:
if model_field.name in self.additional_links:
# already been added to links
continue
field = self.get_field(model_field)
if field:
if has_through_model:
field.read_only = True
ret[model_field.name] = field
# Deal with reverse relationships
reverse_rels = opts.get_all_related_objects()
reverse_rels += opts.get_all_related_many_to_many_objects()
for relation in reverse_rels:
accessor_name = relation.get_accessor_name()
if accessor_name not in self.opts.fields and accessor_name not in base_fields:
continue
related_model = relation.model
to_many = relation.field.rel.multiple
has_through_model = False
is_m2m = isinstance(relation.field,
models.fields.related.ManyToManyField)
if (is_m2m and
hasattr(relation.field.rel, 'through') and
not relation.field.rel.through._meta.auto_created):
has_through_model = True
if nested:
field = self.get_nested_field(None, related_model, to_many)
elif accessor_name in base_fields:
field = base_fields[accessor_name]
base_fields.pop(accessor_name)
else:
field = self.get_related_field(None, related_model, to_many)
if field:
self.add_field_to_embedded(accessor_name, field, has_through_model)
# Add the `read_only` flag to any fields that have bee specified
# in the `read_only_fields` option
for field_name in self.opts.read_only_fields:
assert field_name not in self.base_fields.keys(), (
"field '%s' on serializer '%s' specified in "
"`read_only_fields`, but also added "
"as an explicit field. Remove it from `read_only_fields`." %
(field_name, self.__class__.__name__))
assert field_name in ret, (
"Non-existant field '%s' specified in `read_only_fields` "
"on serializer '%s'." %
(field_name, self.__class__.__name__))
ret[field_name].read_only = True
for field_name in self.opts.write_only_fields:
assert field_name not in self.base_fields.keys(), (
"field '%s' on serializer '%s' specified in "
"`write_only_fields`, but also added "
"as an explicit field. Remove it from `write_only_fields`." %
(field_name, self.__class__.__name__))
assert field_name in ret, (
"Non-existant field '%s' specified in `write_only_fields` "
"on serializer '%s'." %
(field_name, self.__class__.__name__))
ret[field_name].write_only = True
return ret
