Usually users' profiles are stored in single model. When there are multiple user types, separation is made by some field like user_type.
Situation is a little more complicated when different data is needed for each user type.
Of course it's better when all users have same type and are granted different permissions. But since we got task to have separate user types - we'll have to solve it.
Simple solution
The most obvious solution is to make base profile with type identifier, which will pull needed model instance:
request.user.get_profile().get_final_profile()But I don't really like this solution. Firstly, get_final_profile method is basically a big switch-case. Secondly - we must not forget to call extra method.
I wanted to simply write request.user.profile ans get needed profile instance. This is possible by combining two known tricks - Upcast and AutoOneToOneField.
Upcast
Allows to get sublass instance from base class instance.
AutoOneToOneField
Allows creating related objects on request. This field is not needed per se, only idea. Taking AutoOneToOneField as a base, it's easy to create a new one that calls upcast when related objects is requested.
Solution
class UpCastModel(models.Model):
"""
Base class for models that are ment to be inherited.
Introduces upcast method that returns child instance.
"""
final_type = models.ForeignKey(ContentType, editable=False)
def save(self, args, **kwargs):
if not self.pk:
self.final_type = ContentType.objects.get_for_model(type(self))
super(UpCastModel, self).save(args, **kwargs)
def upcast(self):
if not hasattr(self, '_upcast'):
if self.final_type.model_class == self.class:
self._upcast = self
else:
self._upcast = self.final_type.get_object_for_this_type(id=self.pk)
return self._upcast
class Meta:
abstract = True
class UpCastSingleRelatedObjectDescriptor(SingleRelatedObjectDescriptor):
def get(self, instance, instance_type=None):
parent = super(
UpCastSingleRelatedObjectDescriptor, self
).get(instance, instance_type)
return parent.upcast()
class UpCastOneToOneField(models.OneToOneField):
"""
UpCastOneToOneField gets child of related object.
"""
def contribute_to_related_class(self, cls, related):
setattr(
cls, related.get_accessor_name(),
UpCastSingleRelatedObjectDescriptor(related)
)
Now profile looks like this:
class BaseProfile(UpcastModel):
user = UpCastOneToOneField(User)
class BoyProfile(BaseProfile):
pass
class GirlProfile(CitizenProfile):
passIn order to get users, profile, we just need to write requst.user.profile.
Subscribe for the news and updates
In this article we'll review general approach to working with the best kind of projects - the ones with old untested and undocumented spaghetti code and a tight schedule. We'll review anger management techniques, coping mechanisms and some refactoring tips that might come in handy.
Lead management is an important part of the marketing strategy of every company of any size. Besides automating various business processes, privately-held organizations should consider implementing an IT solution that would help them manage their leads. So, how should you make a web-based leads management system for a University in order to significantly increase sales?
For any project there may be a need to use a database full-text search. We expect high speed and relevant results from this search. When we face such problem, we usually think about Solr, ElasticSearch, Sphinx, AWS CloudSearch, etc. But in this article we will talk about PostgreSQL. Starting from version 8.3, a full-text search support in PostgreSQL is available. Let's look at how it is implemented in the DBMS itself.
Quite often we have to write paginated or filtered blocks of information on page. I created a decorator that would automate this process.
For local project settings, I use old trick with settings_local file:try:from settings_local import \*except ImportError:passSo in settings_local.py we can override variables from settings.py. I didn't know how to supplement them. For example how to add line to INSTALLED_APPS without copying whole list.Yesterday I finally understood that I can import settings from settings_local:# settings_local.pyfrom settings import \*INSTALLED_APPS += (# ...)
In my recent project there was a lot of data business logic, so I had to organize this code somehow. In this article I'll describe a few hints on how to it.