ਰੈਸਟ ਫਰੇਮਵਰਕ ਟੋਕਨਾਂ

Daniel Marino

ਵੀਰਵਾਰ, 2 ਜਨਵਰੀ 2025 9:40:58 ਬਾ.ਦੁ.

Django-Tenants ਵਿੱਚ ਸਬਡੋਮੇਨ ਲੌਗਇਨ ਕਿਉਂ ਟੁੱਟਦੇ ਹਨ: ਇੱਕ ਅਸਲ-ਵਿਸ਼ਵ ਬੁਝਾਰਤ

ਇੱਕ ਬਹੁ-ਕਿਰਾਏਦਾਰ Django ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਹਰੇਕ ਸਬਡੋਮੇਨ ਇੱਕ ਵੱਖਰੇ ਕਿਰਾਏਦਾਰ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ, ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣੀਕਰਨ ਨੂੰ ਸਹਿਜੇ ਹੀ ਏਕੀਕ੍ਰਿਤ ਕਰਦਾ ਹੈ। ਸਭ ਕੁਝ ਸੰਪੂਰਣ ਜਾਪਦਾ ਹੈ-ਜਦੋਂ ਤੱਕ ਕਿ ਇੱਕ ਸਬਡੋਮੇਨ 'ਤੇ ਲੌਗਇਨ ਪੰਨਾ ਇੱਕ ਡਰਾਉਣਾ ਨਹੀਂ ਸੁੱਟਦਾ 500 ਅੰਦਰੂਨੀ ਸਰਵਰ ਗੜਬੜ. ਤੁਸੀਂ ਆਪਣਾ ਸਿਰ ਖੁਰਕਦੇ ਹੋ, ਹੈਰਾਨ ਹੁੰਦੇ ਹੋ ਕਿ ਕਿਉਂ ਪ੍ਰਾਇਮਰੀ ਡੋਮੇਨ ਲੌਗਇਨ ਨਿਰਵਿਘਨ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਸਬਡੋਮੇਨ ਲੌਗਇਨ ਨਹੀਂ ਕਰਦਾ. 🤔

ਇਹ ਮੁੱਦਾ ਨਿਰਾਸ਼ਾਜਨਕ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਵਿਰੋਧਾਭਾਸ ਵਾਂਗ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ: ਸਿਸਟਮ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਪਛਾਣਦਾ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਐਡਮਿਨ ਪੈਨਲ ਵਿੱਚ ਲੌਗਇਨ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਕ ਵਾਰ ਲੌਗਇਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਕਿਰਾਏਦਾਰ-ਵਿਸ਼ੇਸ਼ ਪੰਨਿਆਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਫਾਰਮਾਂ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਜਮ੍ਹਾਂ ਕਰ ਸਕਦੇ ਹੋ। ਫਿਰ ਵੀ, ਜਦੋਂ ਤੁਸੀਂ ਲੌਗਇਨ ਪੰਨੇ ਨੂੰ ਦਬਾਉਂਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸਾਹਮਣੇ ਆਉਂਦੀ ਹੈ: "ਅਚਾਨਕ ਟੋਕਨ' ਅਸਲ ਵਿੱਚ ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਕੀ ਹੋ ਰਿਹਾ ਹੈ?

ਮੈਨੂੰ ਇੱਕ ਸੰਬੰਧਿਤ ਉਦਾਹਰਣ ਸਾਂਝੀ ਕਰਨ ਦਿਓ. ਇਹ ਇੱਕ ਘਰ ਦੇ ਦੋ ਦਰਵਾਜ਼ੇ ਹੋਣ ਵਰਗਾ ਹੈ—ਇੱਕ ਮਹਿਮਾਨਾਂ ਲਈ (ਤੁਹਾਡਾ ਮੁੱਖ ਡੋਮੇਨ) ਅਤੇ ਇੱਕ ਪਰਿਵਾਰ (ਉਪ ਡੋਮੇਨ) ਲਈ। ਮਹਿਮਾਨ ਦਰਵਾਜ਼ਾ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਪਰਿਵਾਰ ਦਾ ਦਰਵਾਜ਼ਾ ਜਾਮ ਹੋ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਕੁੰਜੀਆਂ ਸਹੀ ਹਨ, ਪਰ ਲਾਕ ਵਿਧੀ ਨਾਲ ਕੁਝ ਡੂੰਘੀ ਗਲਤੀ ਹੈ - ਜਿਵੇਂ ਕਿ ਡੇਟਾਬੇਸ ਸਕੀਮਾ ਸਵਾਲਾਂ ਵਿੱਚ ਅਚਾਨਕ ਬੇਮੇਲ ਹੋਣਾ।

ਇਸ ਮੁੱਦੇ ਦੀ ਜੜ੍ਹ ਇਸ ਗੱਲ ਵਿੱਚ ਹੈ ਕਿ ਜੰਜੋ ਰੈਸਟ ਫਰੇਮਵਰਕ ਕਿਵੇਂ ਹੈ ਟੋਕਨ ਪ੍ਰਮਾਣਿਕਤਾ ਨਾਲ ਗੱਲਬਾਤ ਕਰਦਾ ਹੈ django-ਕਿਰਾਏਦਾਰ ਲਾਇਬ੍ਰੇਰੀ. ਖਾਸ ਤੌਰ 'ਤੇ, ਟੋਕਨਾਂ ਦੇ ਵਿਰੁੱਧ ਪੁੱਛਗਿੱਛ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਨਤਕ ਸਕੀਮਾ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਦੀ ਬਜਾਏ, ਜਿਸ ਕਾਰਨ ਏ ਵਿਦੇਸ਼ੀ ਕੁੰਜੀ ਉਲੰਘਣਾ ਗਲਤੀ ਆਉ ਇਸ ਸਮੱਸਿਆ ਵਿੱਚ ਡੁਬਕੀ ਮਾਰੀਏ, ਕਾਰਨ ਨੂੰ ਉਜਾਗਰ ਕਰੀਏ, ਅਤੇ ਤੁਹਾਡੇ ਸਾਰੇ ਉਪ-ਡੋਮੇਨਾਂ ਲਈ ਲੌਗਇਨ ਦਰਵਾਜ਼ੇ ਨੂੰ ਠੀਕ ਕਰੀਏ! 🔧

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
schema_context()	ਇੱਕ ਮਲਟੀ-ਕਿਰਾਏਦਾਰ Django ਸੈੱਟਅੱਪ ਵਿੱਚ ਸਕੀਮਾਂ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ: schema_context('tenant_name') ਦੇ ਨਾਲ: ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਨਿਰਧਾਰਤ ਕਿਰਾਏਦਾਰ ਦੇ ਡੇਟਾਬੇਸ ਸਕੀਮਾ ਵਿੱਚ ਕਾਰਵਾਈਆਂ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।
authenticate()	ਇੱਕ ਉਪਭੋਗਤਾ ਨੂੰ ਉਹਨਾਂ ਦੇ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ: ਯੂਜ਼ਰ = ਪ੍ਰਮਾਣਿਤ(ਬੇਨਤੀ, ਯੂਜ਼ਰਨੇਮ=ਯੂਜ਼ਰਨੇਮ, ਪਾਸਵਰਡ=ਪਾਸਵਰਡ) ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਪ੍ਰਮਾਣ ਪੱਤਰ ਵੈਧ ਹਨ ਜਾਂ ਨਹੀਂ।
Token.objects.get_or_create()	ਇੱਕ ਉਪਭੋਗਤਾ ਲਈ ਇੱਕ ਮੌਜੂਦਾ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਜਾਂ ਇੱਕ ਬਣਾਉਂਦਾ ਹੈ ਜੇਕਰ ਇਹ ਮੌਜੂਦ ਨਹੀਂ ਹੈ। ਉਦਾਹਰਨ: ਟੋਕਨ, ਬਣਾਇਆ = Token.objects.get_or_create(user=user)।
csrf_exempt	ਕਿਸੇ ਖਾਸ ਦ੍ਰਿਸ਼ ਲਈ CSRF ਸੁਰੱਖਿਆ ਨੂੰ ਅਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ: @csrf_exempt ਦੀ ਵਰਤੋਂ ਬਾਹਰੀ ਜਾਂ ਗੈਰ-ਬ੍ਰਾਊਜ਼ਰ API ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
connection.tenant.schema_name	Django ਮਲਟੀ-ਟੇਨੈਂਟ ਐਪ ਵਿੱਚ ਮੌਜੂਦਾ ਕਿਰਾਏਦਾਰ ਦੇ ਸਕੀਮਾ ਨਾਮ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ: tenant_schema_name = connection.tenant.schema_name।
JsonResponse()	HTTP ਜਵਾਬ ਵਜੋਂ JSON-ਫਾਰਮੈਟ ਕੀਤਾ ਡਾਟਾ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ: JsonResponse ਵਾਪਸ ਕਰੋ({"status": "success", "token": token.key})।
APIClient()	ਇੱਕ Django ਰੈਸਟ ਫਰੇਮਵਰਕ ਟੈਸਟਿੰਗ ਕਲਾਇੰਟ ਜੋ ਟੈਸਟਾਂ ਵਿੱਚ HTTP ਬੇਨਤੀਆਂ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ: self.client = APIClient()।
localStorage.setItem()	ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਸਥਾਨਕ ਸਟੋਰੇਜ ਵਿੱਚ ਇੱਕ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਾ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ: localStorage.setItem('token', data.token) ਭਵਿੱਖ ਦੀ ਵਰਤੋਂ ਲਈ ਟੋਕਨ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ।
Swal.fire()	SweetAlert2 ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਲਰਟ ਪੌਪਅੱਪ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ: Swal.fire({icon: 'error', title: 'Login Failed'}) ਇੱਕ ਸ਼ੈਲੀ ਵਾਲਾ ਗਲਤੀ ਸੁਨੇਹਾ ਦਿਖਾਉਂਦਾ ਹੈ।
TestCase	Django ਵਿੱਚ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ: ਕਲਾਸ TenantLoginTest(TestCase): ਸਕੀਮਾ-ਵਿਸ਼ੇਸ਼ ਲਾਗਇਨ ਟੈਸਟਿੰਗ ਲਈ ਇੱਕ ਟੈਸਟ ਕਲਾਸ ਬਣਾਉਂਦਾ ਹੈ।

Django-ਕਿਰਾਏਦਾਰਾਂ ਵਿੱਚ ਕਿਰਾਏਦਾਰ-ਵਿਸ਼ੇਸ਼ ਪ੍ਰਮਾਣਿਕਤਾ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ

ਉੱਪਰ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਮਲਟੀ-ਟੇਨੈਂਟ ਡਜੈਂਗੋ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਇੱਕ ਨਾਜ਼ੁਕ ਮੁੱਦੇ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਦੀਆਂ ਹਨ ਜਿੱਥੇ ਟੋਕਨਾਂ ਤੋਂ ਪੁੱਛਗਿੱਛ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਨਤਕ ਸਕੀਮਾ ਉਚਿਤ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਦੀ ਬਜਾਏ। ਇਹ ਵਿਵਹਾਰ ਇਸ ਲਈ ਵਾਪਰਦਾ ਹੈ ਕਿਉਂਕਿ Django Rest Framework (DRF) ਟੋਕਨ ਮਾਡਲਾਂ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੇ ਸਮੇਂ ਆਪਣੇ ਆਪ ਸਕੀਮਾਂ ਨੂੰ ਬਦਲਦਾ ਨਹੀਂ ਹੈ। ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਅਸੀਂ ਲਾਭ ਉਠਾਉਂਦੇ ਹਾਂ django-ਕਿਰਾਏਦਾਰ ਲਾਇਬ੍ਰੇਰੀ ਦੇ schema_context ਵਿਧੀ, ਸਾਨੂੰ ਸਹੀ ਕਿਰਾਏਦਾਰ ਦੀ ਸਕੀਮਾ ਦੇ ਅੰਦਰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਡਾਟਾਬੇਸ ਸਵਾਲਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣੀਕਰਨ ਅਤੇ ਟੋਕਨ ਪ੍ਰਾਪਤੀ ਹਰੇਕ ਕਿਰਾਏਦਾਰ ਲਈ ਸਹਿਜੇ ਹੀ ਕੰਮ ਕਰਦੇ ਹਨ, ਭਾਵੇਂ ਪ੍ਰਾਇਮਰੀ ਡੋਮੇਨ ਜਾਂ ਸਬਡੋਮੇਨਾਂ ਦੁਆਰਾ ਐਕਸੈਸ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। ਇਸ ਐਡਜਸਟਮੈਂਟ ਤੋਂ ਬਿਨਾਂ, ForeignKeyViolation ਗਲਤੀ ਵਾਪਰਦੀ ਹੈ ਕਿਉਂਕਿ ਸਿਸਟਮ ਗਲਤ ਸਕੀਮਾ ਵਿੱਚ ਉਪਭੋਗਤਾ ਰਿਕਾਰਡਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ।

'dual_login_view' ਫੰਕਸ਼ਨ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਲਈ ਡੇਟਾਬੇਸ ਕਨੈਕਸ਼ਨ ਪੁਆਇੰਟਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਦੌਰਾਨ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਹੈ। ਪਹਿਲਾਂ, ਇਹ ਬੇਨਤੀ ਪੇਲੋਡ ਤੋਂ ਉਪਭੋਗਤਾ ਨਾਮ ਅਤੇ ਪਾਸਵਰਡ ਕੱਢਦਾ ਹੈ। ਫਿਰ, 'ਪ੍ਰਮਾਣਿਤ' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਇਹ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਸਫਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਪਭੋਗਤਾ ਨੂੰ ਲੌਗ ਇਨ ਕਰਦਾ ਹੈ ਅਤੇ DRF ਦੀ `Token.objects.get_or_create()` ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਟੋਕਨ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ ਪੁੱਛਗਿੱਛ ਸਹੀ ਸਕੀਮਾ ਨੂੰ ਨਿਸ਼ਾਨਾ ਬਣਾਉਂਦੀ ਹੈ, `schema_context` ਫੰਕਸ਼ਨ ਤਰਕ ਨੂੰ ਸਮੇਟਦਾ ਹੈ, ਡਾਟਾਬੇਸ ਸੰਦਰਭ ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਇਹ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਸਿਸਟਮ ਸਹੀ ਉਪਭੋਗਤਾ ਅਤੇ ਟੋਕਨ ਰਿਕਾਰਡਾਂ ਨੂੰ ਲੱਭ ਸਕਦਾ ਹੈ, ਸਕੀਮਾ ਬੇਮੇਲ ਗਲਤੀ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ।

'TenantAwareLoginAPIView' ਕਲਾਸ ਮਾਡਿਊਲਰ ਪਹੁੰਚ ਲਈ Django Rest Framework ਦੇ APIView ਨੂੰ ਅਪਣਾ ਕੇ ਹੱਲ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ। ਇਹ ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਵਾਲੀਆਂ POST ਬੇਨਤੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਉਹਨਾਂ ਨੂੰ `ਪ੍ਰਮਾਣਿਤ` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਪ੍ਰਮਾਣ ਪੱਤਰ ਸਹੀ ਹਨ ਤਾਂ ਇੱਕ ਟੋਕਨ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ, ਇਹ ਸਹੀ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਦੇ ਅੰਦਰ ਸਾਰੀਆਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਚਲਾਉਣ ਲਈ `schema_context` ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਕਲਾਸ-ਆਧਾਰਿਤ ਦ੍ਰਿਸ਼ ਆਧੁਨਿਕ API ਲਾਗੂ ਕਰਨ ਲਈ ਆਦਰਸ਼ ਹੈ ਕਿਉਂਕਿ ਇਹ ਗਲਤੀ ਦੇ ਪ੍ਰਬੰਧਨ ਨੂੰ ਕੇਂਦਰਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਸਾਫ਼, ਢਾਂਚਾਗਤ ਜਵਾਬ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ JSON ਟੋਕਨ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਫਰੰਟਐਂਡ ਇਸਨੂੰ ਸਥਾਨਕ ਸਟੋਰੇਜ ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਪ੍ਰਮਾਣਿਤ ਬੇਨਤੀਆਂ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ।

ਫਰੰਟਐਂਡ 'ਤੇ, JavaScript ਫਾਰਮ ਸਬਮਿਸ਼ਨ ਸਕ੍ਰਿਪਟ ਲੌਗਇਨ ਐਂਡਪੁਆਇੰਟ ਲਈ ਸੁਰੱਖਿਅਤ ਅਤੇ ਢਾਂਚਾਗਤ ਬੇਨਤੀਆਂ ਕਰਨ ਵਿੱਚ ਮੁੱਖ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੀ ਹੈ। ਇਹ ਡਿਫਾਲਟ ਫਾਰਮ ਵਿਵਹਾਰ ਨੂੰ ਰੋਕਦਾ ਹੈ, ਇਨਪੁਟ ਖੇਤਰਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪ੍ਰਾਪਤ API ਬੇਨਤੀ ਦੁਆਰਾ CSRF ਟੋਕਨ ਦੇ ਨਾਲ ਪ੍ਰਮਾਣ ਪੱਤਰ ਭੇਜਦਾ ਹੈ। ਇੱਕ ਸਫਲ ਜਵਾਬ ਪ੍ਰਾਪਤ ਕਰਨ 'ਤੇ, ਟੋਕਨ ਨੂੰ 'ਲੋਕਲ ਸਟੋਰੇਜ' ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਸਰਵਰ ਇੱਕ ਗਲਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਤਾਂ SweetAlert2 ਲਾਇਬ੍ਰੇਰੀ ਇੱਕ ਦੋਸਤਾਨਾ ਚੇਤਾਵਨੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੀ ਹੈ। ਇਹ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਨਿਰਵਿਘਨ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਸਹੀ ਗਲਤੀ ਫੀਡਬੈਕ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕਿਰਾਏਦਾਰ ਸਬਡੋਮੇਨ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਵੇਲੇ, ਵੈਧ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨਾਲ ਲੌਗਇਨ ਕਰਨ ਵਾਲੇ ਉਪਭੋਗਤਾ ਨੂੰ ਤੁਰੰਤ ਇੱਕ ਸਫਲਤਾ ਸੁਨੇਹਾ ਦਿਖਾਈ ਦੇਵੇਗਾ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਡੈਸ਼ਬੋਰਡ 'ਤੇ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਜਾਵੇਗਾ। 🔒

ਆਪਟੀਮਾਈਜ਼ਡ ਸਕੀਮਾ ਸਵਾਲਾਂ ਦੇ ਨਾਲ Django-ਕਿਰਾਏਦਾਰਾਂ ਵਿੱਚ ਸਬਡੋਮੇਨ ਲੌਗਇਨ ਮੁੱਦਿਆਂ ਨੂੰ ਸੰਭਾਲਣਾ

ਸਪਸ਼ਟ ਸਕੀਮਾ ਚੋਣ ਅਤੇ ਤਰੁੱਟੀ ਸੰਭਾਲਣ ਦੇ ਨਾਲ Django ORM ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬੈਕਐਂਡ ਹੱਲ।

# Import necessary libraries
from django.db import connection
from rest_framework.authtoken.models import Token
from django.contrib.auth import authenticate, login
from django.http import JsonResponse
from django_tenants.utils import schema_context
from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def dual_login_view(request):
    """Handle login for multi-tenant subdomains with correct schema."""
    if request.method == "POST":
        username = request.POST.get("login")
        password = request.POST.get("password")
        tenant_schema_name = connection.tenant.schema_name
        try:
            # Switch to the correct tenant schema
            with schema_context(tenant_schema_name):
                user = authenticate(request, username=username, password=password)
                if user is not None:
                    login(request, user)
                    # Generate or retrieve token
                    token, created = Token.objects.get_or_create(user=user)
                    return JsonResponse({"status": "success", "token": token.key})
                else:
                    return JsonResponse({"status": "error", "message": "Invalid credentials"}, status=400)
        except Exception as e:
            return JsonResponse({"status": "error", "message": str(e)}, status=500)
    return JsonResponse({"status": "error", "message": "Invalid request method"}, status=405)

ਕਿਰਾਏਦਾਰ-ਜਾਗਰੂਕ ਸਕੀਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਪੱਸ਼ਟ ਟੋਕਨ ਪ੍ਰਬੰਧਨ

ਮਲਟੀ-ਟੇਨੈਂਟ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਲੌਗਇਨ ਕਰਨ ਲਈ ਇੱਕ ਮਾਡਿਊਲਰਾਈਜ਼ਡ ਅਤੇ ਮੁੜ ਵਰਤੋਂ ਯੋਗ Django API ਦ੍ਰਿਸ਼।

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.contrib.auth import authenticate
from rest_framework.authtoken.models import Token
from django_tenants.utils import schema_context
class TenantAwareLoginAPIView(APIView):
    """Login endpoint that ensures tenant-aware schema handling."""
    def post(self, request):
        username = request.data.get("username")
        password = request.data.get("password")
        tenant_schema_name = request.tenant.schema_name
        if not username or not password:
            return Response({"error": "Username and password required"}, status=status.HTTP_400_BAD_REQUEST)
        try:
            with schema_context(tenant_schema_name):
                user = authenticate(request, username=username, password=password)
                if user is None:
                    return Response({"error": "Invalid credentials"}, status=status.HTTP_401_UNAUTHORIZED)
                # Generate or retrieve token for the user
                token, created = Token.objects.get_or_create(user=user)
                return Response({"token": f"Token {token.key}"}, status=status.HTTP_200_OK)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

ਸਬਡੋਮੇਨ ਲਾਗਇਨ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫਰੰਟਐਂਡ ਸਕ੍ਰਿਪਟ

ਕਿਰਾਏਦਾਰ ਸਬ ਡੋਮੇਨਾਂ ਲਈ ਫਾਰਮ ਸਬਮਿਸ਼ਨ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਟੋਕਨ-ਅਧਾਰਿਤ ਲੌਗਇਨ ਨੂੰ ਸੰਭਾਲਣ ਲਈ JavaScript ਹੱਲ।

<script>
document.querySelector('form').addEventListener('submit', function(event) {
    event.preventDefault();
    let form = event.target;
    let formData = new FormData(form);
    fetch("{% url 'tenant_aware_login' %}", {
        method: 'POST',
        body: JSON.stringify(Object.fromEntries(formData)),
        headers: {
            'Content-Type': 'application/json',
            'X-CSRFToken': formData.get('csrfmiddlewaretoken')
        }
    })
    .then(response => {
        if (!response.ok) throw new Error('Server Error');
        return response.json();
    })
    .then(data => {
        if (data.token) {
            localStorage.setItem('token', data.token);
            window.location.href = '/';
        } else {
            Swal.fire({
                icon: 'error',
                title: 'Login Failed',
                text: data.error || 'Invalid credentials'
            });
        }
    })
    .catch(error => {
        console.error('Error:', error);
    });
});
</script>

ਸਕੀਮਾ-ਜਾਗਰੂਕ ਟੋਕਨ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ API ਸਕੀਮਾ ਸਵਿਚਿੰਗ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਹੈਂਡਲ ਕਰਦਾ ਹੈ, ਪਾਈਥਨ ਵਿੱਚ ਯੂਨਿਟ ਟੈਸਟ।

from django.test import TestCase
from rest_framework.test import APIClient
from django_tenants.utils import schema_context
from django.contrib.auth.models import User
from rest_framework.authtoken.models import Token
class TenantLoginTest(TestCase):
    def setUp(self):
        self.client = APIClient()
        with schema_context('test_tenant'):  # Switch to tenant schema
            self.user = User.objects.create_user(username='testuser', password='testpass')
    def test_successful_login(self):
        with schema_context('test_tenant'):
            response = self.client.post('/api/login/', {
                'username': 'testuser',
                'password': 'testpass'
            })
            self.assertEqual(response.status_code, 200)
            self.assertIn('token', response.json())
    def test_invalid_login(self):
        with schema_context('test_tenant'):
            response = self.client.post('/api/login/', {
                'username': 'wronguser',
                'password': 'wrongpass'
            })
            self.assertEqual(response.status_code, 401)
            self.assertIn('error', response.json())

ਮਲਟੀ-ਟੈਨੈਂਟ ਜੰਜੋ ਐਪਸ ਵਿੱਚ ਕਿਰਾਏਦਾਰ-ਵਿਸ਼ੇਸ਼ ਟੋਕਨ ਸਵਾਲਾਂ ਦੀ ਭੂਮਿਕਾ ਨੂੰ ਸਮਝਣਾ

ਦਾ ਇੱਕ ਪ੍ਰਮੁੱਖ ਪਹਿਲੂ ਮਲਟੀ-ਕਿਰਾਏਦਾਰ Django ਐਪਸ ਇਹ ਯਕੀਨੀ ਬਣਾ ਰਿਹਾ ਹੈ ਕਿ ਡੇਟਾਬੇਸ ਓਪਰੇਸ਼ਨ ਹਮੇਸ਼ਾ ਸਹੀ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਦੇ ਅੰਦਰ ਹੁੰਦੇ ਹਨ। ਇਸ ਕੇਸ ਵਿੱਚ ਮੁੱਦਾ ਇਸ ਲਈ ਵਾਪਰਦਾ ਹੈ ਕਿਉਂਕਿ Django ਦਾ ਡਿਫੌਲਟ ਵਿਵਹਾਰ ਇੱਕ ਸਿੰਗਲ ਸ਼ੇਅਰਡ ਸਕੀਮਾ ਨੂੰ ਮੰਨਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਗਲਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਟੋਕਨ ਜਾਂ ਉਪਭੋਗਤਾ ਜਨਤਕ ਸਕੀਮਾ. ਵਰਗੇ ਸਾਧਨਾਂ ਦਾ ਲਾਭ ਉਠਾ ਕੇ schema_context ਤੋਂ ਫੰਕਸ਼ਨ django-ਕਿਰਾਏਦਾਰ ਲਾਇਬ੍ਰੇਰੀ, ਅਸੀਂ ਕਿਰਾਏਦਾਰ-ਵਿਸ਼ੇਸ਼ ਸਵਾਲਾਂ ਨੂੰ ਕਰਨ ਲਈ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਕੀਮਾਂ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰਦੇ ਹਾਂ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾਵਾਂ ਅਤੇ ਟੋਕਨਾਂ ਲਈ ਪ੍ਰਮਾਣਿਕਤਾ ਸਵਾਲਾਂ ਨੂੰ ਸਹੀ ਸਕੀਮਾ 'ਤੇ ਨਿਰਦੇਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਇਕ ਹੋਰ ਮੁੱਖ ਵੇਰਵੇ ਨੂੰ ਅਕਸਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ Token.objects.get_or_create() ਚਲਾਉਂਦਾ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ ਕਿਰਿਆਸ਼ੀਲ ਡੇਟਾਬੇਸ ਸਕੀਮਾ ਵਿੱਚ ਉਪਭੋਗਤਾ ਰਿਕਾਰਡਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਮੌਜੂਦਾ ਸਕੀਮਾ ਗਲਤ ਹੈ, ਤਾਂ ਪੁੱਛਗਿੱਛ a ਨਾਲ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ ਵਿਦੇਸ਼ੀ ਕੁੰਜੀ ਉਲੰਘਣਾ ਗਲਤੀ ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ, ਅਸੀਂ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਟੋਕਨ ਮਾਡਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਵਾਲੀ ਕੋਈ ਵੀ ਪੁੱਛਗਿੱਛ ਇੱਕ ਉਚਿਤ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਸੰਦਰਭ ਵਿੱਚ ਹੁੰਦੀ ਹੈ। ਇਸ ਵਿਵਸਥਾ ਦੇ ਬਿਨਾਂ, ਵੈਧ ਉਪਭੋਗਤਾ ਵੀ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਣਗੇ ਕਿਉਂਕਿ ਉਪਭੋਗਤਾ ਦੀ ID ਡਿਫੌਲਟ ਸਕੀਮਾ ਵਿੱਚ ਸਥਿਤ ਨਹੀਂ ਹੋ ਸਕਦੀ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਫਰੰਟ-ਐਂਡ ਕੋਡ ਇਹਨਾਂ ਬੈਕਐਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨਾਲ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ API ਭੇਜਦਾ ਹੈ CSRF ਟੋਕਨ ਅਤੇ JSON ਜਵਾਬਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਏਪੀਆਈ ਕਾਲਾਂ ਨੂੰ ਟਰਾਈ-ਕੈਚ ਬਲਾਕਾਂ ਵਿੱਚ ਲਪੇਟਣਾ ਅਤੇ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣਾ SweetAlert2 ਉਪਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ. ਇਹ ਸੁਧਾਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਲੌਗਇਨ ਪ੍ਰਵਾਹ ਨਿਰਵਿਘਨ ਰਹਿੰਦਾ ਹੈ, ਭਾਵੇਂ ਉਪ-ਡੋਮੇਨਾਂ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰਨ ਜਾਂ ਸਕੀਮਾ-ਵਿਸ਼ੇਸ਼ ਗਲਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨ ਵੇਲੇ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ SaaS ਪਲੇਟਫਾਰਮ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਹਰ ਕੰਪਨੀ (ਕਿਰਾਏਦਾਰ) ਇੱਕ ਸਬਡੋਮੇਨ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ — ਫਿਕਸਿੰਗ ਸਕੀਮਾ ਸੰਦਰਭ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਕਰਮਚਾਰੀ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਆਸਾਨੀ ਨਾਲ ਲੌਗ ਇਨ ਕਰਦਾ ਹੈ। 🚀

ਮਲਟੀ-ਟੈਨੈਂਟ ਜੈਂਗੋ ਲੌਗਇਨ ਮੁੱਦਿਆਂ 'ਤੇ ਆਮ ਸਵਾਲ

ਕੀ ਕਾਰਨ ਹੈ ਏ 500 ਅੰਦਰੂਨੀ ਸਰਵਰ ਗੜਬੜ ਲਾਗਇਨ ਦੌਰਾਨ?
ਗਲਤੀ ਇਸ ਕਰਕੇ ਹੁੰਦੀ ਹੈ Token.objects.get_or_create() ਗਲਤ ਸਕੀਮਾ ਦੀ ਪੁੱਛ-ਗਿੱਛ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਦੇ ਰਿਕਾਰਡਾਂ ਨੂੰ ਦੇਖਦੇ ਸਮੇਂ ਇੱਕ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ।
ਮੈਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾਵਾਂ ਕਿ ਟੋਕਨ ਸਵਾਲ ਸਹੀ ਕਿਰਾਏਦਾਰ ਸਕੀਮਾ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ?
ਵਰਤੋ schema_context() ਤੋਂ django-ਕਿਰਾਏਦਾਰ ਕਿਊਰੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਸਮੇਟਣ ਅਤੇ ਸਹੀ ਸਕੀਮਾ 'ਤੇ ਸਵਿਚ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀ।
ਐਡਮਿਨ ਪੈਨਲ ਲੌਗਇਨ ਕਿਉਂ ਕੰਮ ਕਰਦਾ ਹੈ ਪਰ ਉਪਭੋਗਤਾ ਲੌਗਇਨ ਅਸਫਲ ਕਿਉਂ ਹੁੰਦਾ ਹੈ?
Django ਐਡਮਿਨ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸਕੀਮਾ ਸੰਦਰਭਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਦਾ ਹੈ, ਪਰ ਕਸਟਮ ਵਿਯੂਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ authenticate() ਜਾਂ Token.objects ਉਦੋਂ ਤੱਕ ਨਹੀਂ ਹੋ ਸਕਦਾ ਜਦੋਂ ਤੱਕ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਸੰਰਚਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।
ਮੈਂ ਫਰੰਟਐਂਡ 'ਤੇ ਲੌਗਇਨ ਟੋਕਨ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਅਤੇ ਸਟੋਰ ਕਰਾਂ?
ਕ੍ਰੈਡੈਂਸ਼ੀਅਲ ਭੇਜਣ ਲਈ ਫੈਚ API ਦੀ ਵਰਤੋਂ ਕਰੋ, ਫਿਰ ਜਵਾਬ ਟੋਕਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਟੋਰ ਕਰੋ localStorage.setItem() ਲਗਾਤਾਰ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ.
ਮੈਂ ਅਸਫਲ ਲੌਗਿਨ ਲਈ ਬਿਹਤਰ ਗਲਤੀ ਸੁਨੇਹੇ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰ ਸਕਦਾ ਹਾਂ?
ਵਰਗੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਰੰਟਐਂਡ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਲਾਗੂ ਕਰੋ SweetAlert2 ਗਲਤ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਜਾਂ ਸਰਵਰ ਸਮੱਸਿਆਵਾਂ ਬਾਰੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਸੂਚਿਤ ਕਰਨ ਲਈ।

ਕਿਰਾਏਦਾਰ ਸਬਡੋਮੇਨਾਂ ਵਿੱਚ ਨਿਰਵਿਘਨ ਲੌਗਇਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ

Django ਮਲਟੀ-ਟੇਨੈਂਟ ਐਪਸ ਵਿੱਚ ਲੌਗਇਨ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਸਾਰੀਆਂ ਡਾਟਾਬੇਸ ਪੁੱਛਗਿੱਛਾਂ ਸਹੀ ਸਕੀਮਾ ਵਿੱਚ ਕੰਮ ਕਰਦੀਆਂ ਹਨ। ਸਕੀਮਾ ਸੰਦਰਭ ਵਰਗੇ ਸਾਧਨਾਂ ਦੀ ਸਪਸ਼ਟ ਵਰਤੋਂ ਕਰਕੇ, ਅਸੀਂ ਗਰੰਟੀ ਦੇ ਸਕਦੇ ਹਾਂ ਕਿ ਉਪਭੋਗਤਾ ਟੋਕਨਾਂ ਨੂੰ ਸਹੀ ਕਿਰਾਏਦਾਰ ਡੇਟਾਬੇਸ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਸਕੀਮਾ ਵਿਵਾਦਾਂ ਤੋਂ ਬਚਦੇ ਹੋਏ।

ਇੱਕ SaaS ਪਲੇਟਫਾਰਮ 'ਤੇ ਕੰਮ ਕਰਨ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਉਪਭੋਗਤਾ ਸਿਰਫ ਸਬਡੋਮੇਨ 'ਤੇ ਲੌਗਇਨ ਅਸਫਲਤਾਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ. ਸਹੀ ਸਕੀਮਾ ਸਵਿਚਿੰਗ ਨਾਲ, ਇਹ ਮੁੱਦੇ ਹੱਲ ਹੋ ਜਾਂਦੇ ਹਨ, ਸਹਿਜ ਪ੍ਰਮਾਣਿਕਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ। ਇਸ ਫਿਕਸ ਨੂੰ ਅਪਣਾਉਣ ਨਾਲ ਨਾ ਸਿਰਫ਼ ਸੁਧਾਰ ਹੁੰਦਾ ਹੈ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਪਰ ਹਰੇਕ ਕਿਰਾਏਦਾਰ ਲਈ ਸੁਰੱਖਿਅਤ, ਕੁਸ਼ਲ ਡੇਟਾ ਐਕਸੈਸ ਦੀ ਗਾਰੰਟੀ ਵੀ ਦਿੰਦਾ ਹੈ। 🔧

Django-ਕਿਰਾਏਦਾਰ ਸਬਡੋਮੇਨ ਮੁੱਦਿਆਂ ਨੂੰ ਸਮਝਣ ਲਈ ਸਰੋਤ ਅਤੇ ਹਵਾਲੇ

'ਤੇ ਵਿਸਤ੍ਰਿਤ ਦਸਤਾਵੇਜ਼ django-ਕਿਰਾਏਦਾਰ ਲਾਇਬ੍ਰੇਰੀ, ਬਹੁ-ਕਿਰਾਏਦਾਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਸਕੀਮਾ ਪ੍ਰਬੰਧਨ ਦੀ ਵਿਆਖਿਆ ਕਰਨਾ। ਇੱਥੇ ਉਪਲਬਧ: Django-ਕਿਰਾਏਦਾਰਾਂ ਦੇ ਦਸਤਾਵੇਜ਼ .
ਟੋਕਨ ਪ੍ਰਮਾਣਿਕਤਾ 'ਤੇ ਅਧਿਕਾਰਤ Django ਰੈਸਟ ਫਰੇਮਵਰਕ (DRF) ਦਸਤਾਵੇਜ਼। ਇੱਥੇ ਹੋਰ ਜਾਣੋ: DRF ਟੋਕਨ ਪ੍ਰਮਾਣਿਕਤਾ .
ਬਹੁ-ਕਿਰਾਏਦਾਰ ਵਾਤਾਵਰਨ ਵਿੱਚ schema_context ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਵਿਆਪਕ ਗਾਈਡ। ਇੱਥੇ ਮਿਲਿਆ: GitHub - Django ਕਿਰਾਏਦਾਰ .
Django ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ CSRF ਟੋਕਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਬਾਰੇ ਸੂਝ: Django CSRF ਦਸਤਾਵੇਜ਼ .
ਬਹੁ-ਕਿਰਾਏਦਾਰ SaaS ਪਲੇਟਫਾਰਮਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ, ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣੀਕਰਨ ਸਮੇਤ: SaaS Pegasus ਮਲਟੀ-ਟੇਨੈਂਸੀ ਗਾਈਡ .

ਰੈਸਟ ਫਰੇਮਵਰਕ ਟੋਕਨਾਂ ਨਾਲ ਜੰਜੋ-ਟੈਨੈਂਟ ਸਬਡੋਮੇਨ ਲੌਗਇਨ ਗਲਤੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ