ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್

Daniel Marino

ಗುರುವಾರ, ಜನವರಿ 2, 2025 09:00:56 ಅಪರಾಹ್ನ

ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರಲ್ಲಿ ಸಬ್‌ಡೊಮೈನ್ ಲಾಗಿನ್‌ಗಳು ಏಕೆ ಒಡೆಯುತ್ತವೆ: ನೈಜ-ಪ್ರಪಂಚದ ಒಗಟು

ಬಹು-ಹಿಡುವಳಿದಾರ ಜಾಂಗೊ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಿ, ಅಲ್ಲಿ ಪ್ರತಿ ಸಬ್‌ಡೊಮೇನ್ ವಿಭಿನ್ನ ಬಾಡಿಗೆದಾರರಿಗೆ ಸೇವೆ ಸಲ್ಲಿಸುತ್ತದೆ, ಬಳಕೆದಾರ ದೃಢೀಕರಣವನ್ನು ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸುತ್ತದೆ. ಸಬ್‌ಡೊಮೇನ್‌ನಲ್ಲಿನ ಲಾಗಿನ್ ಪುಟವು ಭಯಾನಕತೆಯನ್ನು ಎಸೆಯುವವರೆಗೆ ಎಲ್ಲವೂ ಪರಿಪೂರ್ಣವೆಂದು ತೋರುತ್ತದೆ 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ. ನೀವು ತಲೆ ಕೆರೆದುಕೊಳ್ಳುತ್ತೀರಿ, ಏಕೆ ಎಂದು ಆಶ್ಚರ್ಯ ಪಡುತ್ತೀರಿ ಪ್ರಾಥಮಿಕ ಡೊಮೇನ್ ಲಾಗಿನ್ ದೋಷರಹಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಸಬ್ಡೊಮೈನ್ ಲಾಗಿನ್ ಆಗುವುದಿಲ್ಲ. 🤔

ಈ ಸಮಸ್ಯೆಯು ನಿರಾಶಾದಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ವಿರೋಧಾಭಾಸದಂತೆ ಭಾಸವಾಗುತ್ತದೆ: ನೀವು ನಿರ್ವಾಹಕ ಫಲಕಕ್ಕೆ ಲಾಗ್ ಇನ್ ಆಗುವುದರಿಂದ ಸಿಸ್ಟಮ್ ಬಳಕೆದಾರರನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಗುರುತಿಸುತ್ತದೆ. ಒಮ್ಮೆ ಲಾಗ್ ಇನ್ ಮಾಡಿದ ನಂತರ, ನೀವು ಬಾಡಿಗೆದಾರ-ನಿರ್ದಿಷ್ಟ ಪುಟಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಫಾರ್ಮ್‌ಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸಲ್ಲಿಸಬಹುದು. ಆದರೂ, ನೀವು ಲಾಗಿನ್ ಪುಟವನ್ನು ಹೊಡೆದಾಗ, ದೋಷವು ಹೊರಹೊಮ್ಮುತ್ತದೆ: "ಅನಿರೀಕ್ಷಿತ ಟೋಕನ್" ಹುಡ್ ಅಡಿಯಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಏನು ನಡೆಯುತ್ತಿದೆ?

ನಾನು ಒಂದು ಸಂಬಂಧಿತ ಉದಾಹರಣೆಯನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇನೆ. ಇದು ಮನೆಗೆ ಎರಡು ಬಾಗಿಲುಗಳನ್ನು ಹೊಂದಿರುವಂತಿದೆ-ಒಂದು ಅತಿಥಿಗಳಿಗೆ (ನಿಮ್ಮ ಮುಖ್ಯ ಡೊಮೇನ್) ಮತ್ತು ಒಂದು ಕುಟುಂಬಕ್ಕೆ (ಉಪಡೊಮೇನ್‌ಗಳು). ಅತಿಥಿ ಬಾಗಿಲು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಕುಟುಂಬದ ಬಾಗಿಲು ಜಾಮ್ ಆಗುತ್ತದೆ. ಕೀಗಳು ಸರಿಯಾಗಿವೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ, ಆದರೆ ಲಾಕ್ ಮೆಕ್ಯಾನಿಸಮ್‌ನಲ್ಲಿ ಏನಾದರೂ ಆಳವಾದ ದೋಷವಿದೆ - ಡೇಟಾಬೇಸ್ ಸ್ಕೀಮಾ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಅನಿರೀಕ್ಷಿತ ಹೊಂದಾಣಿಕೆಯಿಲ್ಲ.

ಸಮಸ್ಯೆಯ ಮೂಲವು ಜಾಂಗೊ ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನಲ್ಲಿದೆ ಟೋಕನ್ ದೃಢೀಕರಣ ಜೊತೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರು ಗ್ರಂಥಾಲಯ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಟೋಕನ್‌ಗಳನ್ನು ಇದರ ವಿರುದ್ಧ ಪ್ರಶ್ನಿಸಲಾಗುತ್ತದೆ ಸಾರ್ವಜನಿಕ ಸ್ಕೀಮಾ ಹಿಡುವಳಿದಾರರ ಸ್ಕೀಮಾ ಬದಲಿಗೆ, ಕಾರಣವಾಗುತ್ತದೆ a ವಿದೇಶಿ ಕೀ ಉಲ್ಲಂಘನೆ ದೋಷ. ಈ ಸಮಸ್ಯೆಗೆ ಧುಮುಕೋಣ, ಕಾರಣವನ್ನು ಬಹಿರಂಗಪಡಿಸೋಣ ಮತ್ತು ನಿಮ್ಮ ಎಲ್ಲಾ ಸಬ್‌ಡೊಮೇನ್‌ಗಳಿಗೆ ಲಾಗಿನ್ ಬಾಗಿಲನ್ನು ಸರಿಪಡಿಸೋಣ! 🔧

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
schema_context()	ಬಹು-ಹಿಡುವಳಿದಾರ ಜಾಂಗೊ ಸೆಟಪ್‌ನಲ್ಲಿ ಸ್ಕೀಮಾಗಳ ನಡುವೆ ಬದಲಾಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಸ್ಕೀಮಾ_ಸಂದರ್ಭದೊಂದಿಗೆ ('ಬಾಡಿಗೆದಾರ_ಹೆಸರು'): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹಿಡುವಳಿದಾರನ ಡೇಟಾಬೇಸ್ ಸ್ಕೀಮಾದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
authenticate()	ಅವರ ರುಜುವಾತುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರರನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಒದಗಿಸಿದ ರುಜುವಾತುಗಳು ಮಾನ್ಯವಾಗಿದೆಯೇ ಎಂದು ಬಳಕೆದಾರ = ದೃಢೀಕರಿಸಿ (ವಿನಂತಿ, ಬಳಕೆದಾರ ಹೆಸರು = ಬಳಕೆದಾರಹೆಸರು, ಪಾಸ್‌ವರ್ಡ್ = ಪಾಸ್‌ವರ್ಡ್) ಪರಿಶೀಲಿಸುತ್ತದೆ.
Token.objects.get_or_create()	ಬಳಕೆದಾರರಿಗಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೋಕನ್ ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ ಅಥವಾ ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಒಂದನ್ನು ರಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಟೋಕನ್, ರಚಿಸಲಾಗಿದೆ = Token.objects.get_or_create(user=user).
csrf_exempt	ನಿರ್ದಿಷ್ಟ ವೀಕ್ಷಣೆಗಾಗಿ CSRF ರಕ್ಷಣೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಬಾಹ್ಯ ಅಥವಾ ಬ್ರೌಸರ್ ಅಲ್ಲದ API ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ @csrf_exempt ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
connection.tenant.schema_name	ಜಾಂಗೊ ಬಹು-ಬಾಡಿಗೆದಾರ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಬಾಡಿಗೆದಾರರ ಸ್ಕೀಮಾ ಹೆಸರನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. ಉದಾಹರಣೆ: tenant_schema_name = connection.tenant.schema_name.
JsonResponse()	JSON-ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಡೇಟಾವನ್ನು HTTP ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: JsonResponse ({"status": "success", "token": token.key}) ಹಿಂತಿರುಗಿಸಿ.
APIClient()	ಪರೀಕ್ಷೆಗಳಲ್ಲಿ HTTP ವಿನಂತಿಗಳನ್ನು ಅನುಕರಿಸಲು ಅನುಮತಿಸುವ ಜಾಂಗೊ ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಪರೀಕ್ಷಾ ಕ್ಲೈಂಟ್. ಉದಾಹರಣೆ: self.client = APIClient().
localStorage.setItem()	ಬ್ರೌಸರ್‌ನ ಸ್ಥಳೀಯ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಕೀ-ಮೌಲ್ಯದ ಜೋಡಿಯನ್ನು ಉಳಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: localStorage.setItem('ಟೋಕನ್', ಡೇಟಾ.ಟೋಕನ್) ಭವಿಷ್ಯದ ಬಳಕೆಗಾಗಿ ಟೋಕನ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.
Swal.fire()	SweetAlert2 ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಎಚ್ಚರಿಕೆಯ ಪಾಪ್‌ಅಪ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: Swal.fire ({icon: 'error', ಶೀರ್ಷಿಕೆ: 'ಲಾಗಿನ್ ವಿಫಲವಾಗಿದೆ'}) ಶೈಲಿಯ ದೋಷ ಸಂದೇಶವನ್ನು ತೋರಿಸುತ್ತದೆ.
TestCase	ಜಾಂಗೊದಲ್ಲಿ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: ವರ್ಗ TenantLoginTest(TestCase): ಸ್ಕೀಮಾ-ನಿರ್ದಿಷ್ಟ ಲಾಗಿನ್ ಪರೀಕ್ಷೆಗಾಗಿ ಪರೀಕ್ಷಾ ವರ್ಗವನ್ನು ರಚಿಸುತ್ತದೆ.

ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರಲ್ಲಿ ಮಾಸ್ಟರಿಂಗ್ ಬಾಡಿಗೆದಾರ-ನಿರ್ದಿಷ್ಟ ದೃಢೀಕರಣ

ಮೇಲೆ ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಬಹು-ಹಿಡುವಳಿದಾರ ಜಾಂಗೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿನ ನಿರ್ಣಾಯಕ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತವೆ, ಅಲ್ಲಿ ಟೋಕನ್‌ಗಳನ್ನು ಪ್ರಶ್ನಿಸಲಾಗುತ್ತದೆ ಸಾರ್ವಜನಿಕ ಸ್ಕೀಮಾ ಸೂಕ್ತವಾದ ಬಾಡಿಗೆದಾರರ ಸ್ಕೀಮಾ ಬದಲಿಗೆ. ಟೋಕನ್ ಮಾದರಿಗಳೊಂದಿಗೆ ಸಂವಹನ ಮಾಡುವಾಗ ಜಾಂಗೊ ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ (DRF) ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಕೀಮಾಗಳನ್ನು ಬದಲಾಯಿಸದ ಕಾರಣ ಈ ನಡವಳಿಕೆಯು ಸಂಭವಿಸುತ್ತದೆ. ಇದನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಹತೋಟಿ ಮಾಡುತ್ತೇವೆ ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರು ಗ್ರಂಥಾಲಯದ ಸ್ಕೀಮಾ_ಸಂದರ್ಭ ವಿಧಾನ, ಸರಿಯಾದ ಬಾಡಿಗೆದಾರರ ಸ್ಕೀಮಾದಲ್ಲಿ ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಪ್ರಾಥಮಿಕ ಡೊಮೇನ್ ಅಥವಾ ಸಬ್‌ಡೊಮೇನ್‌ಗಳ ಮೂಲಕ ಪ್ರವೇಶಿಸಲಾಗಿದ್ದರೂ, ಪ್ರತಿಯೊಬ್ಬ ಹಿಡುವಳಿದಾರನಿಗೆ ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ಮತ್ತು ಟೋಕನ್ ಮರುಪಡೆಯುವಿಕೆ ಮನಬಂದಂತೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಹೊಂದಾಣಿಕೆಯಿಲ್ಲದೆ, ಫಾರಿನ್‌ಕೀವಿಯೋಲೇಷನ್ ದೋಷವು ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಸಿಸ್ಟಮ್ ತಪ್ಪಾದ ಸ್ಕೀಮಾದಲ್ಲಿ ಬಳಕೆದಾರರ ದಾಖಲೆಗಳನ್ನು ಹುಡುಕುತ್ತದೆ.

ಬಾಡಿಗೆದಾರರ ಸ್ಕೀಮಾಗೆ ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ ಬಿಂದುಗಳನ್ನು ಖಾತ್ರಿಪಡಿಸುವಾಗ ಬಳಕೆದಾರರನ್ನು ದೃಢೀಕರಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು `dual_login_view` ಕಾರ್ಯವು ತೋರಿಸುತ್ತದೆ. ಮೊದಲಿಗೆ, ಇದು ವಿನಂತಿಯ ಪೇಲೋಡ್‌ನಿಂದ ಬಳಕೆದಾರಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. ನಂತರ, `ದೃಢೀಕರಣ' ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ಇದು ರುಜುವಾತುಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ. ಯಶಸ್ವಿಯಾದರೆ, ಇದು ಬಳಕೆದಾರರನ್ನು ಲಾಗ್ ಇನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು DRF ನ `Token.objects.get_or_create()` ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಟೋಕನ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಈ ಪ್ರಶ್ನೆಯು ಸರಿಯಾದ ಸ್ಕೀಮಾವನ್ನು ಗುರಿಯಾಗಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, `ಸ್ಕೀಮಾ_ಸಂದರ್ಭ` ಕಾರ್ಯವು ತರ್ಕವನ್ನು ಸುತ್ತುತ್ತದೆ, ಡೇಟಾಬೇಸ್ ಸಂದರ್ಭವನ್ನು ಸಕ್ರಿಯ ಬಾಡಿಗೆದಾರರ ಸ್ಕೀಮಾಗೆ ಬದಲಾಯಿಸುತ್ತದೆ. ಇದು ಸಿಸ್ಟಮ್ ಸರಿಯಾದ ಬಳಕೆದಾರ ಮತ್ತು ಟೋಕನ್ ದಾಖಲೆಗಳನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ, ಸ್ಕೀಮಾ ಹೊಂದಾಣಿಕೆಯ ದೋಷವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಮಾಡ್ಯುಲರ್ ವಿಧಾನಕ್ಕಾಗಿ ಜಾಂಗೊ ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ APIView ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ `TenantAwareLoginAPIView` ವರ್ಗವು ಪರಿಹಾರವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಇದು ಬಳಕೆದಾರರ ರುಜುವಾತುಗಳನ್ನು ಹೊಂದಿರುವ POST ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು `ದೃಢೀಕರಿಸು` ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಮತ್ತು ರುಜುವಾತುಗಳು ಸರಿಯಾಗಿದ್ದರೆ ಟೋಕನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಮುಖ್ಯವಾಗಿ, ಇದು ಸರಿಯಾದ ಬಾಡಿಗೆದಾರರ ಸ್ಕೀಮಾದಲ್ಲಿ ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು `ಸ್ಕೀಮಾ_ಸಂದರ್ಭ` ಅನ್ನು ಬಳಸುತ್ತದೆ. ಈ ವರ್ಗ-ಆಧಾರಿತ ವೀಕ್ಷಣೆಯು ಆಧುನಿಕ API ಅನುಷ್ಠಾನಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಶುದ್ಧ, ರಚನಾತ್ಮಕ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, JSON ಟೋಕನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವುದರಿಂದ ಮುಂಭಾಗವು ಅದನ್ನು ಸ್ಥಳೀಯ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ನಂತರದ ದೃಢೀಕೃತ ವಿನಂತಿಗಳಿಗಾಗಿ ಅದನ್ನು ಬಳಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮುಂಭಾಗದಲ್ಲಿ, ಲಾಗಿನ್ ಎಂಡ್ ಪಾಯಿಂಟ್‌ಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ರಚನಾತ್ಮಕ ವಿನಂತಿಗಳನ್ನು ಮಾಡುವಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫಾರ್ಮ್ ಸಲ್ಲಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಮುಖ ಪಾತ್ರ ವಹಿಸುತ್ತದೆ. ಇದು ಡೀಫಾಲ್ಟ್ ಫಾರ್ಮ್ ನಡವಳಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ, ಇನ್‌ಪುಟ್ ಕ್ಷೇತ್ರಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಮತ್ತು API ವಿನಂತಿಯನ್ನು ಪಡೆಯುವ ಮೂಲಕ CSRF ಟೋಕನ್ ಜೊತೆಗೆ ರುಜುವಾತುಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಯಶಸ್ವಿ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸಿದ ನಂತರ, ಟೋಕನ್ ಅನ್ನು `ಲೋಕಲ್ ಸ್ಟೋರೇಜ್` ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರನ್ನು ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ. ಸರ್ವರ್ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ, SweetAlert2 ಲೈಬ್ರರಿಯು ಸ್ನೇಹಪರ ಎಚ್ಚರಿಕೆ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಇದು ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಸರಿಯಾದ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಹಿಡುವಳಿದಾರನ ಉಪಡೊಮೇನ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವಾಗ, ಮಾನ್ಯ ರುಜುವಾತುಗಳೊಂದಿಗೆ ಲಾಗ್ ಇನ್ ಆಗುವ ಬಳಕೆದಾರರು ತಕ್ಷಣವೇ ಯಶಸ್ವಿ ಸಂದೇಶವನ್ನು ನೋಡುತ್ತಾರೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ. 🔒

ಆಪ್ಟಿಮೈಸ್ಡ್ ಸ್ಕೀಮಾ ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರಲ್ಲಿ ಸಬ್‌ಡೊಮೈನ್ ಲಾಗಿನ್ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸುವುದು

ಸ್ಪಷ್ಟ ಸ್ಕೀಮಾ ಆಯ್ಕೆ ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ಜಾಂಗೊ 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)

ಟೆನೆಂಟ್-ಅವೇರ್ ಸ್ಕೀಮಾಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಪಷ್ಟವಾದ ಟೋಕನ್ ನಿರ್ವಹಣೆ

ಬಹು-ಬಾಡಿಗೆದಾರರ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿ ಲಾಗಿನ್ ಮಾಡಲು ಮಾಡ್ಯುಲೈಸ್ ಮಾಡಲಾದ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಜಾಂಗೊ 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)

ಉಪಡೊಮೈನ್ ಲಾಗಿನ್ ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಫ್ರಂಟೆಂಡ್ ಸ್ಕ್ರಿಪ್ಟ್

ಫಾರ್ಮ್ ಸಲ್ಲಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಹಾರ ಮತ್ತು ಹಿಡುವಳಿದಾರ ಉಪಡೊಮೇನ್‌ಗಳಿಗಾಗಿ ಟೋಕನ್ ಆಧಾರಿತ ಲಾಗಿನ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ.

<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())

ಮಲ್ಟಿ-ಟೆನೆಂಟ್ ಜಾಂಗೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಬಾಡಿಗೆದಾರ-ನಿರ್ದಿಷ್ಟ ಟೋಕನ್ ಪ್ರಶ್ನೆಗಳ ಪಾತ್ರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಒಂದು ಪ್ರಮುಖ ಅಂಶ ಬಹು-ಹಿಡುವಳಿದಾರ ಜಾಂಗೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಯಾವಾಗಲೂ ಸರಿಯಾದ ಹಿಡುವಳಿದಾರರ ಸ್ಕೀಮಾದಲ್ಲಿ ನಡೆಯುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಮಸ್ಯೆ ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಜಾಂಗೊ ಅವರ ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆಯು ಒಂದೇ ಹಂಚಿಕೆಯ ಸ್ಕೀಮಾವನ್ನು ಊಹಿಸುತ್ತದೆ, ಇದು ಟೋಕನ್‌ಗಳು ಅಥವಾ ಬಳಕೆದಾರರನ್ನು ಹುಡುಕಲು ಸಾಧ್ಯವಾಗದಿದ್ದಾಗ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಸಾರ್ವಜನಿಕ ಸ್ಕೀಮಾ. ನಂತಹ ಪರಿಕರಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ schema_context ನಿಂದ ಕಾರ್ಯ ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರು ಲೈಬ್ರರಿ, ಬಾಡಿಗೆದಾರ-ನಿರ್ದಿಷ್ಟ ಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಾವು ಸ್ಕೀಮಾಗಳ ನಡುವೆ ಸ್ಪಷ್ಟವಾಗಿ ಬದಲಾಯಿಸುತ್ತೇವೆ. ಬಳಕೆದಾರರು ಮತ್ತು ಟೋಕನ್‌ಗಳಿಗೆ ದೃಢೀಕರಣ ಪ್ರಶ್ನೆಗಳನ್ನು ಸರಿಯಾದ ಸ್ಕೀಮಾಗೆ ನಿರ್ದೇಶಿಸಲಾಗಿದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಸಾಮಾನ್ಯವಾಗಿ ಕಡೆಗಣಿಸಲ್ಪಡುವ ಮತ್ತೊಂದು ಪ್ರಮುಖ ವಿವರ ಹೇಗೆ ಎಂಬುದು Token.objects.get_or_create() ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದು ಸಕ್ರಿಯ ಡೇಟಾಬೇಸ್ ಸ್ಕೀಮಾದಲ್ಲಿ ಬಳಕೆದಾರರ ದಾಖಲೆಗಳನ್ನು ಹುಡುಕುತ್ತದೆ. ಪ್ರಸ್ತುತ ಸ್ಕೀಮಾ ತಪ್ಪಾಗಿದ್ದರೆ, ಪ್ರಶ್ನೆಯು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ a ವಿದೇಶಿ ಕೀ ಉಲ್ಲಂಘನೆ ದೋಷ. ಇದನ್ನು ಸರಿಪಡಿಸಲು, ಟೋಕನ್ ಮಾದರಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಯಾವುದೇ ಪ್ರಶ್ನೆಯು ಸರಿಯಾದ ಹಿಡುವಳಿದಾರರ ಸ್ಕೀಮಾ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸುತ್ತೇವೆ. ಈ ಹೊಂದಾಣಿಕೆಯಿಲ್ಲದೆ, ಮಾನ್ಯ ಬಳಕೆದಾರರು ಸಹ ದೃಢೀಕರಿಸಲು ವಿಫಲರಾಗುತ್ತಾರೆ ಏಕೆಂದರೆ ಬಳಕೆದಾರರ ID ಡೀಫಾಲ್ಟ್ ಸ್ಕೀಮಾದಲ್ಲಿ ನೆಲೆಗೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಈ ಬ್ಯಾಕೆಂಡ್ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂವಹನ ಮಾಡುವಲ್ಲಿ ಫ್ರಂಟ್-ಎಂಡ್ ಕೋಡ್ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ. ಪಡೆಯುವ API ಅನ್ನು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳುವುದು CSRF ಟೋಕನ್ ಮತ್ತು JSON ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಉದಾಹರಣೆಗೆ, ಟ್ರೈ-ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ API ಕರೆಗಳನ್ನು ಸುತ್ತುವುದು ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು SweetAlert2 ಉಪಯುಕ್ತತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಸಬ್‌ಡೊಮೇನ್‌ಗಳ ನಡುವೆ ಬದಲಾಯಿಸುವಾಗ ಅಥವಾ ಸ್ಕೀಮಾ-ನಿರ್ದಿಷ್ಟ ದೋಷಗಳನ್ನು ಎದುರಿಸುವಾಗಲೂ ಸಹ ಲಾಗಿನ್ ಹರಿವು ತಡೆರಹಿತವಾಗಿರುತ್ತದೆ ಎಂದು ಈ ವರ್ಧನೆಗಳು ಖಚಿತಪಡಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರತಿ ಕಂಪನಿಯು (ಬಾಡಿಗೆದಾರ) ಸಬ್‌ಡೊಮೈನ್ ಅನ್ನು ಬಳಸುವ SaaS ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ - ಸ್ಕೀಮಾ ಸಂದರ್ಭವನ್ನು ಸರಿಪಡಿಸುವುದು ಪ್ರತಿ ಉದ್ಯೋಗಿ ಅಡೆತಡೆಗಳಿಲ್ಲದೆ ಸರಾಗವಾಗಿ ಲಾಗ್ ಇನ್ ಆಗುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. 🚀

ಮಲ್ಟಿ-ಟೆನೆಂಟ್ ಜಾಂಗೊ ಲಾಗಿನ್ ಸಮಸ್ಯೆಗಳ ಕುರಿತು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು

ಏನು ಕಾರಣವಾಗುತ್ತದೆ ಎ 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ ಲಾಗಿನ್ ಸಮಯದಲ್ಲಿ?
ಏಕೆಂದರೆ ದೋಷ ಸಂಭವಿಸುತ್ತದೆ Token.objects.get_or_create() ತಪ್ಪು ಸ್ಕೀಮಾವನ್ನು ಪ್ರಶ್ನಿಸುತ್ತದೆ, ಬಳಕೆದಾರ ದಾಖಲೆಗಳನ್ನು ಹುಡುಕುವಾಗ ಹೊಂದಾಣಿಕೆಯಾಗುವುದಿಲ್ಲ.
ಟೋಕನ್ ಪ್ರಶ್ನೆಗಳು ಸರಿಯಾದ ಹಿಡುವಳಿದಾರರ ಸ್ಕೀಮಾವನ್ನು ಸೂಚಿಸುವುದನ್ನು ನಾನು ಹೇಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು?
ಬಳಸಿ schema_context() ನಿಂದ ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರು ಲೈಬ್ರರಿಯು ಪ್ರಶ್ನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಸರಿಯಾದ ಸ್ಕೀಮಾಗೆ ಬದಲಾಯಿಸಲು.
ನಿರ್ವಾಹಕ ಫಲಕ ಲಾಗಿನ್ ಏಕೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಆದರೆ ಬಳಕೆದಾರರ ಲಾಗಿನ್ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ?
ಜಾಂಗೊ ನಿರ್ವಾಹಕರು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಕೀಮಾ ಸಂದರ್ಭಗಳನ್ನು ಸರಿಹೊಂದಿಸುತ್ತಾರೆ, ಆದರೆ ಕಸ್ಟಮ್ ವೀಕ್ಷಣೆಗಳನ್ನು ಬಳಸುತ್ತಾರೆ authenticate() ಅಥವಾ Token.objects ಸ್ಪಷ್ಟವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡದ ಹೊರತು ಇರಬಹುದು.
ಮುಂಭಾಗದಲ್ಲಿ ಲಾಗಿನ್ ಟೋಕನ್ ಅನ್ನು ಹಿಂಪಡೆಯುವುದು ಮತ್ತು ಸಂಗ್ರಹಿಸುವುದು ಹೇಗೆ?
ರುಜುವಾತುಗಳನ್ನು ಕಳುಹಿಸಲು ಪಡೆಯುವ API ಅನ್ನು ಬಳಸಿ, ನಂತರ ಪ್ರತಿಕ್ರಿಯೆ ಟೋಕನ್ ಅನ್ನು ಬಳಸಿ ಸಂಗ್ರಹಿಸಿ localStorage.setItem() ನಿರಂತರ ದೃಢೀಕರಣಕ್ಕಾಗಿ.
ವಿಫಲವಾದ ಲಾಗಿನ್‌ಗಳಿಗಾಗಿ ನಾನು ಉತ್ತಮ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಹೇಗೆ ಪ್ರದರ್ಶಿಸಬಹುದು?
ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮುಂಭಾಗದ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ SweetAlert2 ತಪ್ಪಾದ ರುಜುವಾತುಗಳು ಅಥವಾ ಸರ್ವರ್ ಸಮಸ್ಯೆಗಳ ಬಳಕೆದಾರರಿಗೆ ತಿಳಿಸಲು.

ಬಾಡಿಗೆದಾರರ ಉಪಡೊಮೇನ್‌ಗಳಾದ್ಯಂತ ಸ್ಮೂತ್ ಲಾಗಿನ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು

ಜಾಂಗೊ ಬಹು-ಹಿಡುವಳಿದಾರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಲಾಗಿನ್ ವೈಫಲ್ಯಗಳನ್ನು ಪರಿಹರಿಸಲು ಎಲ್ಲಾ ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳು ಸರಿಯಾದ ಸ್ಕೀಮಾದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ. ಸ್ಕೀಮಾ ಸಂದರ್ಭದಂತಹ ಪರಿಕರಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸುವ ಮೂಲಕ, ಸ್ಕೀಮಾ ಸಂಘರ್ಷಗಳನ್ನು ತಪ್ಪಿಸುವ ಮೂಲಕ ಸರಿಯಾದ ಹಿಡುವಳಿದಾರ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಬಳಕೆದಾರರ ಟೋಕನ್‌ಗಳನ್ನು ಪಡೆಯಲಾಗಿದೆ ಎಂದು ನಾವು ಖಾತರಿಪಡಿಸಬಹುದು.

ಉಪಡೊಮೇನ್‌ಗಳಲ್ಲಿ ಮಾತ್ರ ಬಳಕೆದಾರರು ಲಾಗಿನ್ ವೈಫಲ್ಯಗಳನ್ನು ಎದುರಿಸುತ್ತಿರುವ SaaS ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಸರಿಯಾದ ಸ್ಕೀಮಾ ಸ್ವಿಚಿಂಗ್‌ನೊಂದಿಗೆ, ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ, ತಡೆರಹಿತ ದೃಢೀಕರಣವನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಪರಿಹಾರವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು ಕೇವಲ ಸುಧಾರಿಸುವುದಿಲ್ಲ ಬಳಕೆದಾರ ಅನುಭವ ಆದರೆ ಪ್ರತಿ ಹಿಡುವಳಿದಾರನಿಗೆ ಸುರಕ್ಷಿತ, ಸಮರ್ಥ ಡೇಟಾ ಪ್ರವೇಶವನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ. 🔧

ಜಾಂಗೊ-ಟೆನೆಂಟ್ ಸಬ್‌ಡೊಮೈನ್ ಸಮಸ್ಯೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮೂಲಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳು

ವಿವರವಾದ ದಸ್ತಾವೇಜನ್ನು ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರು ಲೈಬ್ರರಿ, ಬಹು-ಹಿಡುವಳಿದಾರರ ಅನ್ವಯಗಳಲ್ಲಿ ಸ್ಕೀಮಾ ನಿರ್ವಹಣೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಲಭ್ಯವಿದೆ: ಜಾಂಗೊ-ಬಾಡಿಗೆದಾರರ ದಾಖಲೆ .
ಟೋಕನ್ ದೃಢೀಕರಣದ ಮೇಲೆ ಅಧಿಕೃತ ಜಾಂಗೊ ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ (DRF) ದಾಖಲಾತಿ. ಇಲ್ಲಿ ಇನ್ನಷ್ಟು ತಿಳಿಯಿರಿ: DRF ಟೋಕನ್ ದೃಢೀಕರಣ .
ಬಹು-ಹಿಡುವಳಿದಾರರ ಪರಿಸರದಲ್ಲಿ ಸ್ಕೀಮಾ_ಸಂದರ್ಭವನ್ನು ಬಳಸುವ ಕುರಿತು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ. ಇಲ್ಲಿ ಕಂಡುಬಂದಿದೆ: GitHub - ಜಾಂಗೊ ಬಾಡಿಗೆದಾರರು .
ಜಾಂಗೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ CSRF ಟೋಕನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಒಳನೋಟಗಳು: ಜಾಂಗೊ CSRF ಡಾಕ್ಯುಮೆಂಟೇಶನ್ .
ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ಸೇರಿದಂತೆ ಬಹು-ಬಾಡಿಗೆದಾರ SaaS ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು: ಸಾಸ್ ಪೆಗಾಸಸ್ ಮಲ್ಟಿ-ಟೆನೆನ್ಸಿ ಗೈಡ್ .

ರೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಟೋಕನ್‌ಗಳೊಂದಿಗೆ ಜಾಂಗೊ-ಟೆನೆಂಟ್ ಸಬ್‌ಡೊಮೈನ್ ಲಾಗಿನ್ ದೋಷಗಳನ್ನು ಪರಿಹರಿಸುವುದು