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