Django एकाधिक उपयोगकर्ता प्रोफाइल

Question

प्रारंभ में, मैं इस तरह मेरी UserProfile शुरू कर दिया।

हालांकि, मेरे पास अपनी वेबसाइट, व्यक्तियों और कॉर्पोरेट में दो अलग-अलग प्रकार के उपयोगकर्ता हैं, जिनमें से प्रत्येक के अपने अद्वितीय गुण हैं। उदाहरण के लिए, मैं चाहता हूं कि मेरे व्यक्तिगत उपयोगकर्ताओं के पास केवल एक उपयोगकर्ता हो, इसलिए user = models.OneToOneField(User) है, और कॉर्पोरेट के लिए मैं चाहता हूं कि वे एक ही प्रोफ़ाइल से संबंधित एकाधिक उपयोगकर्ता हों, इसलिए मेरे पास user = models.ForeignKey(User) होगा।

तो मैं दो अलग अलग मॉडल, IndivProfile और CorpProfile में मॉडल अलग-अलग रखने, दोनों UserProfile से इनहेरिट करते हुए प्रासंगिक उप-मॉडल में मॉडल-विशिष्ट विशेषताओं ले जाने के बारे में सोचा। मुझे एक अच्छा विचार लगता है और शायद काम करेगा, हालांकि मैं AUTH_PROFILE_MODULE इस तरह से निर्दिष्ट नहीं कर पाऊंगा क्योंकि मेरे पास दो उपयोगकर्ता प्रोफाइल हैं जो अलग-अलग उपयोगकर्ताओं के लिए अलग होंगे।

मैं भी यह दूसरी तरह के आसपास करने के बारे में सोचा है, इस तरह कई वर्गों (मॉडल), कुछ से UserProfile इनहेरिट होने:

class UserProfile(IndivProfile, CorpProfile): 
    # some field 

    def __unicode__(self): 
     return self.user.email 

इस तरह से मैं AUTH_PROFILE_MODULE = 'accounts.UserProfile' सेट और उसके समस्या का समाधान होगा। लेकिन ऐसा लगता है कि यह काम करने जा रहा है, क्योंकि पाइथन में विरासत बाएं से दाएं काम करती है और IndivProfile में सभी चर प्रभावी होंगे।

निश्चित रूप से मैं हमेशा IndivProfile और CorpProfile चर के साथ एक एकल मॉडल रख सकता हूं जो सभी एक साथ मिश्रित होते हैं और फिर आवश्यकतानुसार आवश्यकतानुसार उपयोग करेंगे। लेकिन यह सिर्फ मुझे साफ नहीं दिखता है, बल्कि मैं उन्हें अलग-अलग जगह पर उपयुक्त मॉडल का उपयोग और उपयोग कर दूंगा।

के कोई सुझाव यह करने का तरीका साफ है?

Answer 1

मैंने इसे इस तरह से किया है।

PROFILE_TYPES = (
    (u'INDV', 'Individual'), 
    (u'CORP', 'Corporate'), 
) 

# used just to define the relation between User and Profile 
class UserProfile(models.Model): 
    user = models.ForeignKey(User) 
    profile = models.ForeignKey('Profile') 
    type = models.CharField(choices=PROFILE_TYPES, max_length=16) 

# common fields reside here 
class Profile(models.Model): 
    verified = models.BooleanField(default=False) 

मैं दो सार मॉडल, User जो पहले से ही Django में परिभाषित किया गया है, और मेरे Profile मॉडल के बीच संबंध को प्रतिबिंबित करने के लिए एक मध्यवर्ती तालिका का उपयोग कर समाप्त हो गया। ऐसे गुण होने के मामले में जो सामान्य नहीं हैं, मैं एक नया मॉडल तैयार करूंगा और इसे Profile से जोड़ूंगा।

Answer 2

फ़ील्ड का उपयोग करने का प्रयास करने के लायक हो सकता है। इसके पीछे विचार उपयोगकर्ताप्रोफाइल मॉडल को कॉर्पप्रोफाइल या इंडिवप्रोफाइल मॉडल के मॉडल के माध्यम से उपयोग करना है। यही कारण है कि जिस तरह से यह जैसे ही एक कॉर्प या व्यक्ति प्रोफाइल एक उपयोगकर्ता से जुड़ा हुआ है बनाया जा रहा है:

from django.db import models 
from django.contrib.auth.models import User 

class UserProfile(models.Model): 
    user = models.ForeignKey(User) 
    profile = models.ForeignKey(Profile, related_name='special_profile') 

class Profile(models.Model): 
    common_property=something 

class CorpProfile(Profile): 
    user=models.ForeignKey(User, through=UserProfile) 
    corp_property1=someproperty1 
    corp_property2=someproperty2 

class IndivProfile(Profile): 
    user=models.ForeignKey(User, through=UserProfile, unique=true) 
    indiv_property1=something 
    indiv_property2=something 

मुझे लगता है कि AUTH_PROFILE_MODULE = 'accounts.UserProfile' स्थापित करने के लिए है कि जिस तरह से यह संभव हो जाना चाहिए, और हर बार जब आप या तो एक CorpProfile या एक IndivProfile बनाने जो एक वास्तविक उपयोगकर्ता से जुड़ा हुआ है एक अद्वितीय UserProfile मॉडल बनाया गया है। इसके बाद आप उस डीबी प्रश्नों या जो कुछ भी चाहते हैं उसे एक्सेस कर सकते हैं।

मैंने इसका परीक्षण नहीं किया है, इसलिए कोई गारंटी नहीं है। यह थोड़ा सा हैकी हो सकता है, लेकिन दूसरी ओर मुझे यह विचार काफी आकर्षक लगता है। :)

Answer 3

आप इसे निम्न तरीके से कर सकते हैं। एक प्रोफ़ाइल है जिसमें सामान्य फ़ील्ड होंगे जो दोनों प्रोफाइल में आवश्यक हैं। और आप कक्षा UserProfile बनाकर पहले ही ऐसा कर चुके हैं।

class UserProfile(models.Model): 
    user = models.ForeignKey(User) 
    #some common fields here, which are shared among both corporate and individual profiles 

class CorporateUser(models.Model): 
    profile = models.ForeignKey(UserProfile) 
    #corporate fields here 

    class Meta: 
     db_table = 'corporate_user' 

class IndividualUser(models.Model): 
    profile = models.ForeignKey(UserProfile) 
    #Individual user fields here 

    class Meta: 
     db_table = 'individual_user' 

यहां कोई रॉकेट विज्ञान शामिल नहीं है। बस एक ऐसा कीवर्ड है जो कॉर्पोरेट प्रोफ़ाइल या व्यक्तिगत प्रोफ़ाइल के बीच अंतर करेगा। जैसे विचार करें कि उपयोगकर्ता साइन अप कर रहा है। फिर फॉर्म पर एक फ़ील्ड है जो अलग-अलग होगा कि उपयोगकर्ता कॉर्पोरेट के लिए साइन अप कर रहा है या नहीं। और उपयोगकर्ता को संबंधित मॉडल में सहेजने के लिए उस कीवर्ड (अनुरोध पैरामीटर) का उपयोग करें।

फिर बाद में जब आप यह जांचना चाहते हैं कि उपयोगकर्ता की प्रोफ़ाइल कॉर्पोरेट या व्यक्तिगत है तो आप इसे एक छोटे से फ़ंक्शन लिखकर देख सकते हैं।

def is_corporate_profile(profile): 
    try: 
     profile.corporate_user 
     return True 
    except: 
     return False 

#If there is no corporate profile is associated with main profile then it will raise exception and it means its individual profile 
#you can use this function as a template function also to use in template 
{%if profile|is_corporate_profile %} 

आशा है कि यह आपको कुछ जगह ले जाएगा। धन्यवाद