🛌🏿 ⏱️ 🎅🏼 एक Django परियोजना में जूमला खातों का उपयोग करना 🎂 🔐 🗄️

मान लीजिए कि आपके उपयोगकर्ताओं द्वारा उपयोग की जाने वाली साइट जूमला में लिखी गई है, लेकिन अपने दर्शकों के लिए एक नया उत्पाद बनाने के लिए, आपने पायथन / जिंगो बंडल को चुना।

नतीजतन, आपको जिओगो में जूमला डेटाबेस से उपयोगकर्ता खातों का उपयोग करने की आवश्यकता है।

हालाँकि, समस्या यह है कि जूमला और Django अलग-अलग पासवर्ड हैशिंग एल्गोरिदम का उपयोग करते हैं, इसलिए केवल खातों की प्रतिलिपि बनाना विफल रहता है।

Django प्रलेखन को पढ़ने के बाद, अतिप्रवाह और कुछ समय बिताने के बाद, मुझे नीचे वर्णित समाधान मिला, जो Django के लिए अनुशंसित विकास प्रथाओं का अधिकतम उपयोग करता है।

चेतावनी

हो सकता है कि यह वास्तु समाधान आपको पसंद न आए, टिप्पणियों में चर्चा देखें।

नीचे दिए गए उदाहरणों में क्या होता है यह समझने के लिए, आपको Django वास्तुकला की कुछ समझ होनी चाहिए।

मैं यह भी मानता हूं कि आप जानते हैं कि कैसे एक Django परियोजना को तैनात करना है, इसलिए मैं इस प्रक्रिया का वर्णन नहीं कर रहा हूं।

कोड को किसी कार्यशील प्रोजेक्ट से कॉपी किया जाता है, लेकिन कम से कम परिवर्तनों के साथ अपनी परियोजना में समायोजित करना आसान होगा।

संभवतः, Django के अगले प्रमुख संस्करण में, यह कोड टूट सकता है, लेकिन समाधान का सिद्धांत समान रहेगा।

इस गाइड में, मैं प्राधिकरण प्रणाली के सामने के छोर का वर्णन नहीं करता हूं, क्योंकि:

आपके पास जो फ्रंट-एंड है वह आपकी परियोजना की जरूरतों पर निर्भर करेगा (उदाहरण के लिए यह JSON API समापन बिंदु भी हो सकता है)
यह जानकारी आधिकारिक Django ट्यूटोरियल और विभिन्न स्टार्टर लेखों में पहले ही वर्णित है

एल्गोरिथ्म

जूमला डेटाबेस (DB) को Django प्रोजेक्ट से कनेक्ट करें
जूमला डेटाबेस से एक उपयोगकर्ता का प्रतिनिधित्व करने वाला जूमलाउज़र मॉडल बनाएँ
एक check_joomla_password() फ़ंक्शन लिखें जो सत्यापित करता है कि दर्ज किया गया पासवर्ड उपयोगकर्ता के मूल पासवर्ड से मेल खाता है।
परियोजना में एक नया प्राधिकरण बैकएंड "जुमला ऑथेंटिक बैकएंड" जोड़ें, जो जब Django में क्लाइंट को अधिकृत करता है, तो उसे जूमला डेटाबेस से उपयोगकर्ता खाता मिलेगा

1. जूमला डेटाबेस से कनेक्शन:

पढ़ें कि कैसे Django कई डेटाबेस के साथ काम करता है

जूमला डेटाबेस को हमारे Django प्रोजेक्ट से कनेक्ट करने के लिए, प्रोजेक्ट सेटिंग्स फ़ाइल के लिए निम्न कोड जोड़ें /project_name/settings.py :

 DATABASES = { #    'default': { ... }, 'joomla_db': { 'ENGINE': 'django.db.backends.mysql', 'OPTIONS': {}, 'NAME': 'joomla_database_name', # Don't store passwords in the code, instead use env vars: 'USER': os.environ['joomla_db_user'], 'PASSWORD': os.environ['joomla_db_pass'], 'HOST': 'joomla_db_host, can be localhost or remote IP', 'PORT': '3306', } }

यदि आवश्यक हो, तो प्रोजेक्ट सेटिंग्स के साथ एक ही फ़ाइल में, आप डेटाबेस प्रश्नों को लॉग इन कर सकते हैं:

 # add logging to see DB requests: LOGGING = { 'version': 1, 'handlers': { 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'level': 'DEBUG', 'handlers': ['console'], }, }, }

2. एक जूमलेउसर मॉडल बनाएं

पढ़ें कि कैसे एक Django मॉडल मौजूदा डेटाबेस का उपयोग कर सकता है
इस बारे में सोचें कि नया जूमलाउज़र कहां रखा जाए।
मेरे प्रोजेक्ट में, मैंने "उपयोगकर्ता" नामक एक एप्लिकेशन बनाया ( manage.py startapp users )। इसमें प्राधिकरण बैकएंड और जूमला यूजर मॉडल होगा।
इंस्पेक्टडब का उपयोग करके स्वचालित रूप से मॉडल उत्पन्न करें:
python manage.py inspectdb live_users --database="joomla_db"
joomla_db - उस डेटाबेस का नाम, जिसे आपने settings.py/DATABASES में निर्दिष्ट किया था/DATABASES;
live_users - खातों के साथ तालिका का नाम।

अपने मॉडल को users/models.py मॉडल के लिए जोड़ें:

 class JoomlaUser(models.Model): """ Represents our customer from the legacy Joomla database. """ username = models.CharField(max_length=150, primary_key=True) email = models.CharField(max_length=100) password = models.CharField(max_length=100) # you can copy more fields from `inspectdb` output, # but it's enough for the example class Meta: # joomla db user table. WARNING, your case can differs. db_table = 'live_users' # readonly managed = False # tip for the database router app_label = "joomla_users"

अगला, हमें यह सुनिश्चित करने की आवश्यकता है कि मॉडल सही डेटाबेस तक पहुंच जाएगा। ऐसा करने के लिए, विभिन्न डेटाबेस के प्रश्नों के लिए प्रोजेक्ट राउटर में जोड़ें, जो जूमलेउसर मॉडल से इसके मूल डेटाबेस के अनुरोधों को पुनर्निर्देशित करेगा।

प्रोजेक्ट के मुख्य फ़ोल्डर में "db_routers.py" फ़ाइल बनाएँ (उसी स्थान पर जहाँ आपका "settings.py" है:

 # project_name/db_routers.py class DbRouter: """this router makes sure that django uses legacy 'Joomla' database for models, that are stored there (JoomlaUser)""" def db_for_read(self, model, **kwargs): if model._meta.app_label == 'joomla_user': return 'joomla_db' return None def db_for_write(self, model, **kwargs): if model._meta.app_label == 'joomla_user': return 'joomla_db' return None

settings.py में एक नया राउटर पंजीकृत करें:

 # ensure that Joomla users are populated from the right database: DATABASE_ROUTERS = ['project_name.db_routers.DbRouter']

अब आप पुराने डेटाबेस से एक खाता प्राप्त कर सकते हैं।
एक Django टर्मिनल लॉन्च करें और एक मौजूदा उपयोगकर्ता को खींचने का प्रयास करें: python manage.py shell

 >>> from users.models import JoomlaUser >>> print(JoomlaUser.objects.get(username='someuser')) JoomlaUser object (someusername) >>>

यदि सब कुछ काम करता है (आप उपयोगकर्ता को देखते हैं), तो अगले चरण पर जाएं। अन्यथा, त्रुटि आउटपुट को देखें और सेटिंग्स को ठीक करें।

3. जूमला खाता पासवर्ड सत्यापित करें

उदाहरण के लिए, जूमला यूजर पासवर्ड को स्टोर नहीं करता है
$2y$10$aoZ4/bA7pe.QvjTU0R5.IeFGYrGag/THGvgKpoTk6bTz6XNkY0F2e

Joomla v3.2 के साथ शुरू, उपयोगकर्ता पासवर्ड BLOWFISH एल्गोरिथ्म का उपयोग करके एन्क्रिप्ट किया गया है।

इसलिए मैंने इस एल्गोरिथ्म के साथ अजगर कोड डाउनलोड किया:

 pip install bcrypt echo bcrypt >> requirements.txt

और users/backend.py में पासवर्ड की जाँच करने के लिए एक फ़ंक्शन बनाया:

 def check_joomla_password(password, hashed): """ Check if password matches the hashed password, using same hashing method (Blowfish) as Joomla >= 3.2 If you get wrong results with this function, check that the Hash starts from prefix "$2y", otherwise it is probably not a blowfish hash :return: True/False """ import bcrypt if password is None: return False # bcrypt requires byte strings password = password.encode('utf-8') hashed = hashed.encode('utf-8') return hashed == bcrypt.hashpw(password, hashed)

चेतावनी! 3.2 से कम Joomla संस्करण एक अलग हैशिंग विधि (md5 + नमक) का उपयोग करते हैं, इसलिए यह फ़ंक्शन काम नहीं करेगा। इस मामले में, पढ़ें
Stackoverflow पर चर्चा और एक हैश चेक फ़ंक्शन बनाएं जो कुछ इस तरह दिखता है:

 # WARNING - THIS FUNCTION WAS NOT TESTED WITH REAL JOOMLA USERS # and definitely has some errors def check_old_joomla_password(password, hashed): from hashlib import md5 password = password.encode('utf-8') hashed = hashed.encode('utf-8') if password is None: return False # check carefully this part: hash, salt = hashed.split(':') return hash == md5(password+salt).hexdigest()

दुर्भाग्य से, मेरे पास जूमला के पुराने संस्करण से एक उपयोगकर्ता आधार नहीं है, इसलिए मैं आपके लिए इस सुविधा का परीक्षण नहीं कर सकता।

4. बैकएंड यूजर ऑथराइजेशन जूमला

अब आप जूमला परियोजना से उपयोगकर्ताओं को अधिकृत करने के लिए एक Django बैकएंड बनाने के लिए तैयार हैं।

कैसे Django प्राधिकरण प्रणाली को संशोधित करने के लिए पढ़ें

project/settings.py में एक नया बैकएंड (अभी तक विद्यमान नहीं) पंजीकृत करें:

 AUTHENTICATION_BACKENDS = [ # Check if user already in the local DB # by using default django users backend 'django.contrib.auth.backends.ModelBackend', # If user was not found among django users, # use Joomla backend, which: # - search for user in Joomla DB # - check joomla user password # - copy joomla user into Django user. 'users.backend.JoomlaBackend', ]

users/backend.py backend.py में एक जूमला उपयोगकर्ता प्राधिकरण बैकएंड बनाएं

 from django.contrib.auth.models import User from .models import JoomlaUser def check_joomla_password(password, hashed): # this is a fuction, that we wrote before ... class JoomlaBackend: """ authorize users against Joomla user records """ def authenticate(self, request, username=None, password=None): """ IF joomla user exists AND password is correct: create django user return user object ELSE: return None """ try: joomla_user = JoomlaUser.objects.get(username=username) except JoomlaUser.DoesNotExist: return None if check_joomla_password(password, joomla_user.password): # Password is correct, let's create and return Django user, # identical to Joomla user: # but before let's ensure there is no same username # in DB. That could happen, when user changed password # in Joomla, but Django doesn't know that User.objects.filter(username=username).delete() return User.objects.create_user( username=username, email=joomla_user.email, password=password, # any additional fields from the Joomla user: ... ) # this method is required to match Django Auth Backend interface def get_user(self, user_id): try: return User.objects.get(pk=user_id) except User.DoesNotExist: return None

संपूर्ण

बधाई - अब आपकी मौजूदा Joomla साइट के उपयोगकर्ता एक नई साइट / एप्लिकेशन पर अपनी साख का उपयोग कर सकते हैं।

नए इंटरफ़ेस के माध्यम से सक्रिय उपयोगकर्ताओं के प्राधिकरण के रूप में, उन्हें एक-एक करके नए डेटाबेस में कॉपी किया जाएगा।

वैकल्पिक रूप से, आप उपयोगकर्ता सिस्टम को पुराने सिस्टम से नए में कॉपी नहीं करना चाह सकते हैं।

इस मामले में, यहां एक लेख का लिंक दिया गया है जो बताता है कि डिफ़ॉल्ट उपयोगकर्ता मॉडल को Django (ऊपर वर्णित JoomlaUser मॉडल) में अपने स्वयं के साथ कैसे बदला जाए ।

अंतिम निर्णय, उपयोगकर्ताओं को स्थानांतरित करने या न करने के लिए, उस संबंध के आधार पर किया जाता है जिसमें नई और पुरानी परियोजनाएं होंगी। उदाहरण के लिए, नए उपयोगकर्ताओं का पंजीकरण कहां होगा, कौन सा साइट / एप्लिकेशन मुख्य होगा, आदि।

परीक्षण और प्रलेखन

अब कृपया नए कोड को कवर करते हुए उचित परीक्षण और प्रलेखन जोड़ें। इस समाधान का तर्क बारीकी से Django वास्तुकला के साथ जुड़ा हुआ है और बहुत स्पष्ट नहीं है, इसलिए यदि आप अभी परीक्षण / प्रलेखन नहीं करते हैं, तो भविष्य में परियोजना के लिए समर्थन अधिक जटिल हो जाएगा।

एक Django परियोजना में जूमला खातों का उपयोग करना