रिएक्ट टोकन

समस्या

प्राधिकरण एक नई परियोजना शुरू करने पर डेवलपर्स की पहली समस्याओं में से एक है। और सबसे आम प्रकार के प्राधिकरण में से एक (मेरे अनुभव से) टोकन आधारित प्राधिकरण (आमतौर पर जेडब्ल्यूटी का उपयोग करके) है।

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

• टोकन को स्थानीय भंडारण में संग्रहीत किया जाना चाहिए
• पेज रीलोड पर टोकन बहाल किए जाने चाहिए
• एक्सेस टोकन को नेटवर्क अनुरोधों में पारित किया जाना चाहिए
• यदि अंतिम प्रस्तुत किया जाता है, तो समाप्ति के बाद टोकन पहुंच को ताज़ा करके अपडेट किया जाना चाहिए
• उपयुक्त यूआई को प्रस्तुत करने के लिए प्रतिक्रियाशील घटकों की मूलभूत जानकारी तक पहुंच होनी चाहिए
• समाधान शुद्ध प्रतिक्रिया के साथ बनाया जाना चाहिए (बिना Redux, थंक, आदि ..)

मेरे लिए सबसे चुनौतीपूर्ण प्रश्नों में से एक थे:

• सिंक रिएक्ट घटकों राज्य और स्थानीय भंडारण डेटा में कैसे रखें?
• पूरे तत्वों के पेड़ के माध्यम से इसे पारित किए बिना भ्रूण के अंदर टोकन कैसे प्राप्त करें (विशेषकर यदि हम इस भ्रूण का उपयोग बाद में उदाहरण के लिए थंक कार्यों में करना चाहते हैं)

लेकिन समस्याओं को चरण दर चरण हल करें। सबसे पहले हम token provider को स्टोर करने के लिए token provider बनाएंगे और परिवर्तनों को सुनने की संभावना प्रदान करेंगे। उसके बाद, हम एक auth provider बनाएंगे, वास्तव में token provider करने के लिए token provider चारों ओर रैपर, रिएक्टर घटकों के लिए हुक, स्टेरॉयड पर लाने और कुछ अतिरिक्त तरीके। और अंत में, हम इस परियोजना में इस समाधान का उपयोग करने का तरीका देखेंगे।

मैं बस npm install ... करना चाहता हूँ npm install ... और उत्पादन जाना

मैंने पहले ही पैकेज इकट्ठा कर लिया है जिसमें नीचे वर्णित सभी (और थोड़ा अधिक) हैं। आपको बस इसे कमांड द्वारा स्थापित करने की आवश्यकता है:

 npm install react-token-auth 

और प्रतिक्रिया-टोकन-स्थित GitHub रिपॉजिटरी में उदाहरणों का पालन करें।

समाधान

समस्या को हल करने से पहले मैं एक धारणा बनाऊंगा कि हमारे पास एक बैकएंड है जो पहुंच और ताज़ा टोकन के साथ एक वस्तु देता है। प्रत्येक टोकन में एक JWT प्रारूप है। ऐसी वस्तु दिख सकती है:

 { "accessToken": "...", "refreshToken": "..." } 

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

जेडब्ल्यूटी

यदि आपको नहीं पता कि JWT टोकन सबसे अच्छा विकल्प क्या है, तो jwt.io पर जाएं और देखें कि यह कैसे काम करता है। अब यह महत्वपूर्ण है कि JWT टोकन में (आधार Base64 प्रारूप में) उस उपयोगकर्ता के बारे में जानकारी होती है जो उसे सर्वर पर प्रमाणित करने की अनुमति देता है।

आमतौर पर JWT टोकन में डॉट्स द्वारा विभाजित 3 भाग होते हैं और ऐसा दिखता है:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiSm9obiBEb2UiLCJpYXQiOjE1MTYyMzkwMjIsImV4cCI6MTUxNjIzOTAyMn0.yOZC0rjfSopcpJ-d3BWE8-BkoLR_SCqPdJpq8Wn-1Mc

यदि हम इस टोकन के मध्य भाग ( eyJu...Mn0 ) को डिकोड करते हैं, तो हमें अगला JSON मिलेगा:

 { "name": "John Doe", "iat": 1516239022, "exp": 1516239022 } 

इस जानकारी के साथ, हम टोकन की समाप्ति तिथि प्राप्त करने में सक्षम होंगे।

टोकन प्रदाता

जैसा कि मैंने पहले उल्लेख किया है, हमारा पहला कदम टोकन प्रदाता बना रहा है। टोकन प्रदाता सीधे स्थानीय भंडारण के साथ काम करेगा और टोकन के सभी परिवर्तन हम इसके माध्यम से करेंगे। यह हमें कहीं से भी बदलाव सुनने और तुरंत सुनने वालों को परिवर्तनों के बारे में सूचित करने की अनुमति देगा (लेकिन इसके बारे में थोड़ा बाद में)। प्रदाता के इंटरफ़ेस में अगले तरीके होंगे:

• getToken() वर्तमान टोकन प्राप्त करने के लिए (इसका उपयोग getToken() में किया जाएगा)
• setToken() लॉगिन, लॉगआउट या पंजीकरण के बाद टोकन सेट करने के लिए
• isLoggedIn() जांच करने के लिए उपयोगकर्ता लॉग इन है
• subscribe() प्रदाता को एक फ़ंक्शन देने के लिए जिसे किसी भी टोकन परिवर्तन के बाद बुलाया जाना चाहिए
• unsubscribe() हटाने के लिए सदस्यता unsubscribe()

फ़ंक्शन createTokenProvider() वर्णित इंटरफ़ेस के साथ टोकन प्रदाता का एक उदाहरण बनाएगा:

 const createTokenProvider = () => { /* Implementation */ return { getToken, isLoggedIn, setToken, subscribe, unsubscribe, }; }; 

सभी अगले कोड createTokenProvider फ़ंक्शन के अंदर होने चाहिए।

आइए टोकन को संग्रहीत करने और स्थानीय भंडारण से डेटा को पुनर्स्थापित करने के लिए एक चर बनाकर शुरू करें (यह सुनिश्चित करने के लिए कि पृष्ठ पुनः लोड होने के बाद सत्र खो नहीं जाएगा):

 let _token: { accessToken: string, refreshToken: string } = JSON.parse(localStorage.getItem('REACT_TOKEN_AUTH') || '') || null; 

अब हमें JWT टोकन के साथ काम करने के लिए कुछ अतिरिक्त फ़ंक्शन बनाने की आवश्यकता है। वर्तमान समय में, JWT टोकन मैजिक स्ट्रिंग की तरह दिखता है, लेकिन इसे पार्स करना और समाप्ति तिथि निकालने की कोशिश करना कोई बड़ी बात नहीं है। फ़ंक्शन getExpirationDate() एक JWT टोकन को एक पैरामीटर के रूप में लेगा और सफलता पर समाप्ति तिथि टाइमस्टैम्प लौटाएगा (या विफलता पर null ):

 const getExpirationDate = (jwtToken?: string): number | null => { if (!jwtToken) { return null; } const jwt = JSON.parse(atob(jwtToken.split('.')[1])); // multiply by 1000 to convert seconds into milliseconds return jwt && jwt.exp && jwt.exp * 1000 || null; }; 

और एक और उपयोग समारोह की जांच की गई है isExpired() की जाँच करने के लिए समयसीमा समाप्त हो गई है। यदि समाप्ति टाइमस्टैम्प प्रस्तुत की गई है और यह Date.now() से कम है तो यह फ़ंक्शन सही है।

 const isExpired = (exp?: number) => { if (!exp) { return false; } return Date.now() > exp; }; 

टोकन प्रदाता इंटरफ़ेस का पहला फ़ंक्शन बनाने का समय। फ़ंक्शन getToken() को टोकन लौटा देना चाहिए और यदि आवश्यक हो तो इसे अपडेट करना चाहिए। यह फ़ंक्शन async होना चाहिए क्योंकि यह टोकन को अपडेट करने के लिए नेटवर्क अनुरोध कर सकता है।

पहले से बनाए गए कार्यों का उपयोग करके हम देख सकते हैं कि एक्सपायर टोकन की अवधि समाप्त हो गई है या नहीं ( isExpired(getExpirationDate(_token.accessToken)) )। और टोकन को अद्यतन करने के लिए अनुरोध करने के लिए पहले मामले में। उसके बाद, हम टोकन (अभी तक लागू नहीं किए गए फ़ंक्शन setToken() ) के साथ टोकन बचा सकते हैं। और अंत में, हम एक्सेस टोकन वापस कर सकते हैं:

 const getToken = async () => { if (!_token) { return null; } if (isExpired(getExpirationDate(_token.accessToken))) { const updatedToken = await fetch('/update-token', { method: 'POST', body: _token.refreshToken }) .then(r => r.json()); setToken(updatedToken); } return _token && _token.accessToken; }; 

फ़ंक्शन isLoggedIn() सरल होगा: यह सही हो जाएगा अगर _tokens null नहीं है और टोकन समाप्ति की जांच नहीं करेगा (इस मामले में हम टोकन तक पहुंचने की समाप्ति के बारे में तब तक नहीं जान पाएंगे, जब तक कि हम टोकन प्राप्त करने में विफल नहीं हो जाते, लेकिन आमतौर पर यह पर्याप्त है , और हमें फंक्शन रखने की अनुमति दी है। तुल्यकालिक):

 const isLoggedIn = () => { return !!_token; }; 

मुझे लगता है कि पर्यवेक्षकों के प्रबंधन के लिए कार्यक्षमता बनाने के लिए यह एक अच्छा समय है। हम ऑब्जर्वर पैटर्न के समान कुछ लागू करेंगे, और सबसे पहले, हमारे सभी पर्यवेक्षकों को संग्रहीत करने के लिए एक सरणी बनाएंगे। हम उम्मीद करेंगे कि इस सरणी में प्रत्येक तत्व वह फ़ंक्शन है जिसे हमें प्रत्येक परिवर्तन के बाद कॉल करना चाहिए:

 let observers: Array<(isLogged: boolean) => void> = []; 

अब हम तरीके बना सकते हैं subscribe() और unsubscribe() । पहले वाला बनाया गया ऑब्जर्वर थोड़ा पहले वाली सरणी में नया ऑब्जर्वर जोड़ेगा, दूसरा व्यक्ति प्रेक्षक को सूची से हटा देगा।

 const subscribe = (observer: (isLogged: boolean) => void) => { observers.push(observer); }; const unsubscribe = (observer: (isLogged: boolean) => void) => { observers = observers.filter(_observer => _observer !== observer); }; 

आप पहले से ही कार्यों के इंटरफ़ेस से देख सकते हैं subscribe() और unsubscribe() कि हम केवल पर्यवेक्षकों को भेज देंगे उपयोगकर्ता लॉग इन है। लेकिन सामान्य तौर पर, आप जो कुछ भी चाहते हैं उसे भेज सकते हैं (संपूर्ण टोकन, समाप्ति समय, आदि ...)। लेकिन हमारे उद्देश्यों के लिए, यह बूलियन ध्वज भेजने के लिए पर्याप्त होगा।

आइए एक छोटा सा उपयोग फंक्शन notify() बनाएं जो इस ध्वज को लेगा और सभी पर्यवेक्षकों को भेजेगा:

 const notify = () => { const isLogged = isLoggedIn(); observers.forEach(observer => observer(isLogged)); }; 

और अंतिम लेकिन कम से कम फ़ंक्शन जिसे हमें लागू करने की आवश्यकता है वह setToken() । इस फ़ंक्शन का उद्देश्य स्थानीय भंडारण में टोकन की बचत कर रहा है (या टोकन खाली होने पर स्थानीय भंडारण को साफ करना) और परिवर्तन के लिए पर्यवेक्षकों को सूचित करना। इसलिए, मैं लक्ष्य देखता हूं, मैं लक्ष्य पर जाता हूं।

 const setToken = (token: typeof _token) => { if (token) { localStorage.setItem('REACT_TOKEN_AUTH', JSON.stringify(token)); } else { localStorage.removeItem('REACT_TOKEN_AUTH'); } _token = token; notify(); }; 

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

प्रामाणिक प्रदाता

आइए वस्तुओं का एक नया वर्ग बनाते हैं जिसे हम एक प्रामाणिक प्रदाता के रूप में कहेंगे। इंटरफ़ेस में 4 तरीके होंगे: हुक का useAuth() रिएक्ट घटक से ताजा स्थिति प्राप्त करने के लिए, वास्तविक टोकन और login() साथ नेटवर्क के लिए अनुरोध करने के लिए, authFetch() login() , logout() विधियां जो विधि setToken() प्रॉक्सी कॉल setToken() टोकन प्रदाता का) (इस मामले में, हमारे पास पूरी बनाई गई कार्यक्षमता के लिए केवल एक प्रविष्टि बिंदु होगा, और बाकी कोड को टोकन प्रदाता के मौजूदा के बारे में नहीं जानना होगा)। जैसा कि पहले हम फंक्शन क्रिएटर से शुरू करेंगे:

 export const createAuthProvider = () => { /* Implementation */ return { useAuth, authFetch, login, logout } }; 

सबसे पहले, यदि हम एक टोकन प्रदाता का उपयोग करना चाहते हैं, तो हमें इसका एक उदाहरण बनाने की आवश्यकता है:

 const tokenProvider = createTokenProvider(); 

तरीके login() और logout() बस टोकन प्रदाता को टोकन पास करते हैं। मैंने इन तरीकों को केवल स्पष्ट अर्थ के लिए अलग किया (वास्तव में खाली / अशक्त टोकन पास करने से स्थानीय भंडारण से डेटा हटा दिया जाता है):

 const login: typeof tokenProvider.setToken = (newTokens) => { tokenProvider.setToken(newTokens); }; const logout = () => { tokenProvider.setToken(null); }; 

अगला चरण भ्रूण का कार्य है। मेरे विचार के अनुसार, इस फ़ंक्शन में मूल रूप में बिल्कुल समान इंटरफ़ेस होना चाहिए और समान प्रारूप वापस करना चाहिए लेकिन प्रत्येक अनुरोध पर पहुंच टोकन इंजेक्षन करना चाहिए।

फ़ेच फ़ंक्शन को दो तर्क लेने चाहिए: अनुरोध जानकारी (आमतौर पर URL) और अनुरोध init (विधि, निकाय के साथ एक वस्तु। हेडर और इतने पर); और प्रतिसाद देने का वादा करता है:

 const authFetch = async (input: RequestInfo, init?: RequestInit): Promise<Response> => { const token = await tokenProvider.getToken(); init = init || {}; init.headers = { ...init.headers, Authorization: `Bearer ${token}`, }; return fetch(input, init); }; 

फ़ंक्शन के अंदर हमने दो चीजें बनाईं: टोकन प्रदाता से टोकन लेने के लिए बयान का await tokenProvider.getToken(); करें टोकन await tokenProvider.getToken(); ( getToken पहले से ही समाप्ति के बाद टोकन को अपडेट करने का तर्क शामिल है) और इस टोकन को लाइन में getToken Authorization द्वारा Authorization किया जाता है Authorization: 'Bearer ${token}' । उसके बाद, हम केवल अपडेट किए गए तर्कों के साथ लौटाते हैं।

इसलिए, हम पहले से ही प्रदाता को टोकन बचाने और उन्हें लाने के लिए उपयोग कर सकते हैं। आखिरी समस्या यह है कि हम अपने घटकों से टोकन परिवर्तनों पर प्रतिक्रिया नहीं कर सकते हैं। इसे हल करने का समय।

जैसा कि मैंने पहले बताया था कि हम एक हुक का उपयोग useAuth() जो घटक को जानकारी प्रदान करेगा उपयोगकर्ता लॉग इन है या नहीं। यह करने में सक्षम होने के लिए कि हम इस जानकारी को रखने के लिए हुक का उपयोग करेंगे useState() । यह उपयोगी है क्योंकि इस स्थिति में कोई भी परिवर्तन इस हुक का उपयोग करने वाले घटकों के रेंडरर का कारण होगा।

और हमने पहले से ही स्थानीय भंडारण में परिवर्तन को सुनने में सक्षम होने के लिए सब कुछ तैयार किया। हुक के साथ सिस्टम में किसी भी परिवर्तन को सुनने का एक सामान्य तरीका हुक का उपयोग कर रहा useEffect() । यह हुक दो तर्क लेता है: कार्य और निर्भरता की सूची। उपयोग की पहली कॉल के बाद फ़ंक्शन को निकाल दिया जाएगा और फिर निर्भरता की सूची में किसी भी परिवर्तन के बाद फिर से लॉन्च किया जाएगा। इस फ़ंक्शन में, हम स्थानीय संग्रहण में परिवर्तन सुनना शुरू कर सकते हैं। लेकिन क्या महत्वपूर्ण है हम इस फ़ंक्शन से लौट सकते हैं ... नया फ़ंक्शन और, इस नए फ़ंक्शन को या तो पहले एक को फिर से शुरू करने से पहले या घटक के अनमाउंट करने के बाद निकाल दिया जाएगा। नए फ़ंक्शन में, हम परिवर्तनों और प्रतिक्रिया की गारंटी को सुनना बंद कर सकते हैं, कि यह फ़ंक्शन निकाल दिया जाएगा (कम से कम यदि इस प्रक्रिया के दौरान कोई अपवाद नहीं होता है)। थोड़ा जटिल लगता है लेकिन सिर्फ कोड देखें:

 const useAuth = () => { const [isLogged, setIsLogged] = useState(tokenProvider.isLoggedIn()); useEffect(() => { const listener = (newIsLogged: boolean) => { setIsLogged(newIsLogged); }; tokenProvider.subscribe(listener); return () => { tokenProvider.unsubscribe(listener); }; }, []); return [isLogged] as [typeof isLogged]; }; 

और बस इतना ही। हमने अभी स्पष्ट API के साथ कॉम्पैक्ट और पुन: प्रयोज्य टोकन स्टोरेज स्टोरेज बनाया है। अगले भाग में, हम कुछ उपयोग उदाहरणों को देखेंगे।

प्रयोग

ऊपर हमने जो लागू किया, उसका उपयोग शुरू करने के लिए, हमें एक प्रदाता प्रदाता का एक उदाहरण बनाने की आवश्यकता है। यह हमें कार्य के उपयोग की सुविधा useAuth() , authFetch() , login() , logout() स्थानीय स्टोरेज में एक ही टोकन से संबंधित है (सामान्य तौर पर, कुछ भी आपको अलग-अलग टोकन के लिए ऑवर प्रदाता के विभिन्न इंस्टेंसेस बनाने से रोकता है) लेकिन आपको स्थानीय संग्रहण में डेटा को संग्रहीत करने के लिए उपयोग की जाने वाली कुंजी को सम्‍मिलित करना होगा:

 export const {useAuth, authFetch, login, logout} = createAuthProvider(); 

लॉग इन फॉर्म

अब हम उन कार्यों का उपयोग करना शुरू कर सकते हैं जो हमें मिले। आइए लॉगिन फॉर्म घटक के साथ शुरू करें। इस घटक को उपयोगकर्ता की साख के लिए इनपुट प्रदान करना चाहिए और इसे आंतरिक स्थिति में सहेजना चाहिए। सबमिट करने पर हमें टोकन प्राप्त करने के लिए क्रेडेंशियल्स के साथ एक अनुरोध भेजने की आवश्यकता है और यहां हम प्राप्त टोकन का संग्रह करने के लिए फ़ंक्शन login() का उपयोग कर सकते हैं:

 const LoginComponent = () => { const [credentials, setCredentials] = useState({ name: '', password: '' }); const onChange = ({target: {name, value}}: ChangeEvent<HTMLInputElement>) => { setCredentials({...credentials, [name]: value}) }; const onSubmit = (event?: React.FormEvent) => { if (event) { event.preventDefault(); } fetch('/login', { method: 'POST', body: JSON.stringify(credentials) }) .then(r => r.json()) .then(token => login(token)) }; return <form onSubmit={onSubmit}> <input name="name" value={credentials.name} onChange={onChange}/> <input name="password" value={credentials.password} onChange={onChange}/> </form> }; 

और वह सब है, यह सब कुछ है जिसे हमें टोकन स्टोर करने की आवश्यकता है। उसके बाद, जब एक टोकन प्राप्त होता है, तो हमें इसे लाने के लिए या घटकों में अतिरिक्त प्रयास करने की आवश्यकता नहीं होगी, क्योंकि यह पहले से ही प्रदाता के अंदर लागू है।

पंजीकरण फॉर्म समान है, इनपुट फ़ील्ड की संख्या और नामों में केवल अंतर हैं, इसलिए मैं इसे यहां छोड़ दूंगा।

रूटर

इसके अलावा, हम प्रदाता प्रदाता का उपयोग करके रूटिंग को लागू कर सकते हैं। मान लेते हैं कि हमारे पास दो पैक रूट हैं: एक पंजीकृत उपयोगकर्ता के लिए और एक पंजीकृत न होने के लिए। उन्हें विभाजित करने के लिए हमें जांचने की आवश्यकता है कि क्या हमारे पास स्थानीय भंडारण में टोकन है या नहीं, और यहां हम हुक का उपयोग कर सकते हैं। useAuth() :

 export const Router = () => { const [logged] = useAuth(); return <BrowserRouter> <Switch> {!logged && <> <Route path="/register" component={Register}/> <Route path="/login" component={Login}/> <Redirect to="/login"/> </>} {logged && <> <Route path="/dashboard" component={Dashboard} exact/> <Redirect to="/dashboard"/> </>} </Switch> </BrowserRouter>; }; 

और अच्छी बात यह है कि स्थानीय भंडारण में किसी भी परिवर्तन के बाद इसे फिर से प्रस्तुत किया जाएगा, क्योंकि उपयोग के लिए इन परिवर्तनों की सदस्यता है।

अनुरोध प्राप्त करें

और तब हम टोकन का उपयोग करके डेटा को सुरक्षित कर सकते हैं। इसमें एक ही इंटरफ़ेस है जैसे कि, यदि आप पहले से ही कोड में authFetch उपयोग करते हैं, तो आप बस इसे authFetch द्वारा बदल सकते हैं:

 const Dashboard = () => { const [posts, setPosts] = useState([]); useEffect(() => { authFetch('/posts') .then(r => r.json()) .then(_posts => setPosts(_posts)) }, []); return <div> {posts.map(post => <div key={post.id}> {post.message} </div>)} </div> }; 

सारांश

हमने कर दिखाया। यह एक दिलचस्प यात्रा थी, लेकिन इसका अंत भी है (शायद खुश भी)।

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

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

यहां मैं लेख पढ़ने के लिए धन्यवाद कह सकता हूं और मुझे आशा है कि यह आपके लिए उपयोगी था।