एकाधिक उपयोगकर्ता कक्षाओं के साथ फ्लास्क-लॉगिन कार्यान्वित करना

Question

मैं एक ऐप लिख रहा हूं जिसमें कई वर्ग हैं जो उपयोगकर्ता के रूप में कार्य करते हैं (उदाहरण के लिए, एक स्कूल खाता और एक कर्मचारी खाता)। मैं इसे आसान बनाने के लिए फ्लास्क-लॉगिन का उपयोग करने की कोशिश कर रहा हूं लेकिन मुझे पूरा यकीन नहीं है कि इसे कैसे बनाया जाए ताकि जब कोई उपयोगकर्ता लॉग इन करे, तो मेरे पास यह देखने के लिए मेरा ऐप जांच हो सकता है कि उपयोगकर्ता नाम किसी स्कूल खाते से संबंधित है या नहीं या कर्मचारी खाता, और फिर उचित रूप से लॉग इन करें। मुझे पता है कि टाइप खाता किस प्रकार से संबंधित है (क्योंकि सभी उपयोगकर्ता नाम अद्वितीय होना चाहिए), लेकिन उसके बाद मुझे यकीन नहीं है कि ऐप को कैसे बताना है कि मैं इसे उस विशिष्ट उपयोगकर्ता को लॉगिन करना चाहता हूं। अभी, मेरे पास केवल एक सार्वभौमिक लॉगिन पृष्ठ है। क्या यह आसान है अगर मैं स्टाफ खातों और स्कूल खातों के लिए अलग लॉगिन पेज बना देता हूं? मैं फ्लास्क-स्क्लाक्लेमी के माध्यम से एक MySQL डीबी का उपयोग कर रहा हूँ। किसी भी सहायता की सराहना की जाएगी।

Answer 1

आप प्रत्येक उपयोगकर्ता को एक विशिष्ट भूमिका के साथ परिभाषित कर सकते हैं। उदाहरण के लिए, उपयोगकर्ता 'x' स्कूल हो सकता है जबकि उपयोगकर्ता 'y' 'STAFF' हो सकता है।

class User(db.Model): 

    __tablename__ = 'User' 
    id = db.Column(db.Integer,primary_key=True) 
    username = db.Column(db.String(80),unique=True) 
    pwd_hash = db.Column(db.String(200)) 
    email = db.Column(db.String(256),unique=True) 
    is_active = db.Column(db.Boolean,default=False) 
    urole = db.Column(db.String(80)) 


    def __init__(self,username,pwd_hash,email,is_active,urole): 
      self.username = username 
      self.pwd_hash = pwd_hash 
      self.email = email 
      self.is_active = is_active 
      self.urole = urole 

    def get_id(self): 
      return self.id 
    def is_active(self): 
      return self.is_active 
    def activate_user(self): 
      self.is_active = True   
    def get_username(self): 
      return self.username 
    def get_urole(self): 
      return self.urole 

कुप्पी के लॉगिन हालांकि अभी तक उपयोगकर्ता भूमिकाओं की अवधारणा नहीं है और मुझे लगता है कि ओवरराइड करने के लिए login_required डेकोरेटर के अपने स्वयं के संस्करण में लिखा था। मैं इस बहुत ही उपयोगी है, धन्यवाद पाया

@app.route('/school/') 
@login_required(role="SCHOOL") 
def restricted_view_for_school(): 
    pass 

Answer 2

यह एक उदाहरण है कि आप क्या कर सकते हैं। मुझे फ्लास्क-स्क्लाक्लेमी का उपयोग करने का अनुभव नहीं है, लेकिन यह और भी अलग नहीं होना चाहिए। नीचे दिया गया उदाहरण सीधे SQLAlchemy का उपयोग करता है।

सबसे पहले आप एक उपयोगकर्ता वर्ग कि Base से विरासत इतना है कि यह ORM (घोषणात्मक) द्वारा मैप किया जा सकता

class User(Base): 

    __tablename__ = 'user_table' 
    id = Column(Integer, primary_key=True) 
    email = Column(String(45), unique=True) 
    name = Column(String(45)) 
    pwd = Column(String(8)) 
    user_role = Column(String(15)) 

    __mapper_args__ = { 
     'polymorphic_identity': 'user_table', 
     'polymorphic_on': user_role 
    } 

एक बार अपने माता पिता के वर्ग वर्ग के लिए तैयार है, भूमिकाओं में से प्रत्येक के लिए एक अलग वर्ग सेट को परिभाषित है कि इसे रखने की इच्छा है।

class SchoolAccount(User): 
    __tablename__ = 'school_account' 
    id = Column(Integer, ForeignKey('user_table.id'), primary_key=True) 
    representative_name = Column(String(45)) 

    __mapper_args__ = { 
     'polymorphic_identity': 'school_account' 
    } 

फ्लास्क-लॉगिन का उपयोग करके आप उपयोगकर्ता को लॉगिन करते हैं और भूमिकाओं के आधार पर पहुंच सीमित करते हैं।

यहां दो अलग-अलग भूमिकाओं के साथ एक लॉगिन सिस्टम का एक उदाहरण दिया गया है। यह फ्लास्क, फ्लास्क-स्क्लाल्चेमी, फ्लास्क-लॉगिन के लिए एक अच्छा ट्यूटोरियल है: http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-v-user-logins

Answer 3

@codegeek: फिर

def login_required(role="ANY"): 
    def wrapper(fn): 
     @wraps(fn) 
     def decorated_view(*args, **kwargs): 

      if not current_user.is_authenticated(): 
       return current_app.login_manager.unauthorized() 
      urole = current_app.login_manager.reload_user().get_urole() 
      if ((urole != role) and (role != "ANY")): 
       return current_app.login_manager.unauthorized()  
      return fn(*args, **kwargs) 
     return decorated_view 
    return wrapper 

आप की तरह एक दृश्य समारोह पर इस डेकोरेटर का उपयोग कर सकते: तो आप की तरह कुछ का उपयोग करना चाहते हो सकता है। मैं यह मेरे लिए काम कर पाने के लिए कोड थोड़ा संशोधित करने के लिए किया था, तो मैं मैं मामले में यहाँ छोड़ चाहते हैं यह किसी और में मदद कर सकते लगा:

from functools import wraps 

def login_required(role="ANY"): 
    def wrapper(fn): 
     @wraps(fn) 
     def decorated_view(*args, **kwargs): 
      if not current_user.is_authenticated(): 
       return lm.unauthorized() 
      if ((current_user.role != role) and (role != "ANY")): 
       return lm.unauthorized() 
      return fn(*args, **kwargs) 
     return decorated_view 
    return wrapper 

Answer 4

Flask-Security से "भूमिका प्रबंधन" पर एक नजर डालें। इसे फ्लास्क-लॉगिन के साथ आसानी से एकीकृत किया जा सकता है।