🔆 🐻 💷 एफ # पर एपीआई। प्रवेश भूमिका आधारित अनुप्रयोग मॉड्यूल 👨🏾‍🔬 🤮 👼🏾

ASP.NET Core मानक विशेषताओं के साथ एपीआई का उपयोग करने के लिए कॉन्फ़िगर करने के लिए मानक प्रस्तावों द्वारा प्रदान करता है, एक विशिष्ट दावे के साथ उपयोगकर्ताओं तक पहुंच को प्रतिबंधित करना संभव है, आप नीतियों को परिभाषित कर सकते हैं और नियंत्रकों को बांध सकते हैं, विभिन्न भूमिकाओं के लिए नियंत्रक बना सकते हैं।
इस प्रणाली में न्यूनतम, इस विशेषता को देखते हुए, सबसे बड़ा है:

[Authorize(Roles = "Administrator")] public class AdministrationController : Controller { }

व्यवस्थापक को क्या अधिकार हैं, इसके बारे में हमें कोई जानकारी नहीं मिलती है।

मेरा काम इस महीने के लिए सभी प्रतिबंधित उपयोगकर्ताओं को प्रदर्शित करना है (न केवल डेटाबेस पर जाएं और फ़िल्टर करें, कुछ गिनती के नियम हैं जो कहीं झूठ बोलते हैं), मैं परियोजना पर CTRL + N करता हूं और BannedUserHandler या IHasInAbounBannedUser या GetBannedUsersForAdmin को देखता हूं ।

मुझे विशेषता के साथ चिह्नित नियंत्रक मिलते हैं [अधिकृत (भूमिका = "प्रशासक")] , दो परिदृश्य हो सकते हैं:

हम सब कुछ कंट्रोलर में करते हैं

  [Route("api/[controller]/[action]")] public class AdminInfoController1 : ControllerBase { private readonly IGetUserInfoService _getInfoAboutActiveUsers; private readonly ICanBanUserService _banUserService; private readonly ICanRemoveBanUserService _removeBanUserService; //    action public AdminInfoController1( IGetUserInfoService infoAboutActiveUsers, ICanBanUserService banUserService, ICanRemoveBanUserService removeBanUserService) { _getInfoAboutActiveUsers = infoAboutActiveUsers; _banUserService = banUserService; _removeBanUserService = removeBanUserService; } // actions //... //... }

हम हैंडलर पर वितरित करते हैं

  [Route("api/[controller]/[action]")] public class AdminInfoController2 : ControllerBase { [HttpPatch("{id}")] public async Task<ActionResult<BanUserResult>> BanUser( [FromServices] IAsyncHandler<UserId, BanUserResult> handler, UserId userId) => await handler.Handle(userId, HttpContext.RequestAborted); [HttpPatch("{id}")] public async Task<ActionResult<RemoveBanUserResult>> RemoveBanUser( [FromServices] IAsyncHandler<UserId, RemoveBanUserResult> handler, UserId userId) => await handler.Handle(userId, HttpContext.RequestAborted); }

पहला दृष्टिकोण इस बात में बुरा नहीं है कि हम जानते हैं कि व्यवस्थापक के पास किन संसाधनों की पहुँच है, यह किन निर्भरताओं का उपयोग कर सकता है, मैं इस दृष्टिकोण का उपयोग छोटे अनुप्रयोगों में करूँगा, बिना किसी जटिल विषय के

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

यह सब एक बड़ी खामी है, कोड डेवलपर को यह नहीं बताता है कि क्या करना है, इससे आपको लगता है कि => समय की बर्बादी => कार्यान्वयन त्रुटियां

और जितना आपको सोचना है, उतनी ही गलतियाँ होती हैं।

सुवे रूटिंग का परिचय

क्या होगा अगर रूटिंग इस तरह से बनाया गया है :

 let webPart = choose [ path "/" >=> (OK "Home") path "/about" >=> (OK "About") path "/articles" >=> (OK "List of articles") path "/articles/browse" >=> (OK "Browse articles") path "/articles/details" >=> (OK "Content of an article") ]

''> => '' - क्या है? इस चीज़ का एक नाम है, लेकिन इसका ज्ञान पाठक को यह समझने के लिए एक ग्राम के करीब नहीं लाएगा कि यह कैसे काम करता है, इसलिए इसे लाने का कोई मतलब नहीं है, यह विचार करना बेहतर है कि सब कुछ कैसे काम करता है

सुवे से पाइपलाइन ऊपर लिखी गई है, जिराफ़ में इसका उपयोग किया जाता है (कार्यों के एक अलग हस्ताक्षर के साथ), एक हस्ताक्षर है:

 type WebPart = HttpContext -> Async<HttpContext option>

इस मामले में Async एक विशेष भूमिका नहीं निभाता है (यह समझने के लिए कि यह कैसे काम करता है), इसे छोड़ दें

 HttpContext -> HttpContext option

इस तरह के हस्ताक्षर के साथ एक फ़ंक्शन एक HttpContext को स्वीकार करता है, प्रक्रियाएं (शरीर को deserializes, कुकीज़ को देखता है, हेडर का अनुरोध करता है), एक प्रतिक्रिया बनाता है, और अगर सब कुछ ठीक हो जाता है, तो इसे कुछ में लपेटता है, अगर कुछ गलत हो जाता है, तो कोई भी नहीं देता है, उदाहरण के लिए ( लाइब्रेरी फ़ंक्शन ):

  //    async let OK s : WebPart = fun ctx -> { ctx with response = { ctx.response with status = HTTP_200.status; content = Bytes s }} |> Some |> async.Return

यह फ़ंक्शन "अनुरोध निष्पादन प्रवाह को लपेट नहीं सकता", यह हमेशा शरीर और स्थिति 200 के साथ आगे एक नई प्रतिक्रिया फेंकता है, लेकिन यह एक कर सकता है:

 let path (str:string) ctx = let path = ctx.request.rawPath if path.StartsWith str then ctx |> Some |> async.Return else async.Return None

अंतिम फ़ंक्शन जिसे आपको चुनने की आवश्यकता है - यह विभिन्न कार्यों की एक सूची प्राप्त करता है और उस का चयन करता है जो कुछ पहले देता है:

 let rec choose (webparts:(HttpContext) -> Async<HttpContext option>) list) context= async{ match webparts with | [head] -> return! head context | head::tail -> let! result = head context match result with | Some _-> return result | None -> return! choose tail context | [] -> return None }

खैर, सबसे महत्वपूर्ण बाध्यकारी कार्य (Async छोड़ा गया):

 type WebPartWithoutAsync = HttpContext -> HttpContext option let (>=>) (h1:WebPartWithoutAsync ) (h2:WebPartWithoutAsync) ctx : HttpContext option = let result = h1 ctx match result with | Some ctx' -> h2 ctx' | None -> None

Async संस्करण

 type WebPart = HttpContext -> Async<HttpContext option> let (>=>) (h1:WebPart ) (h2:WebPart ) ctx : Async<HttpContext option>= async{ let! result = h1 ctx match result with | Some ctx' -> return! h2 ctx' | None -> return None }

"> =>" बाएँ और दाएँ पक्ष और httpContext पर दो हैंडलर स्वीकार करता है, जब अनुरोध आता है, तो सर्वर एक HttpContext ऑब्जेक्ट बनाता है और इसे फ़ंक्शन में पास करता है, "> =>" पहले (बाएं) हैंडलर को निष्पादित करता है यदि यह कुछ ctx देता है, तो ctx पास करता है दूसरे हैंडलर के इनपुट के लिए।

और हम इस तरह क्यों लिख सकते हैं (कई कार्यों को जोड़ सकते हैं)?

 GET >=> path "/api" >=> OK

क्योंकि "> =>" दो WebPart फ़ंक्शन स्वीकार करता है और एक फ़ंक्शन देता है जो HttpContext लेता है और Async <HttpContext विकल्प> लौटाता है, और कौन सा फ़ंक्शन संदर्भ लेता है और Async <HttpContext विकल्प> लौटाता है?
वेबपार्ट ।

यह पता चला है कि "> =>" वेबपार्ट को हैंडलर के लिए लेता है और वेबपार्ट को लौटाता है, इसलिए हम एक पंक्ति में कई कॉम्बिनेटर लिख सकते हैं, और केवल दो नहीं।
कॉम्बिनेटर के काम के बारे में विवरण यहां पाया जा सकता है।

भूमिका और पहुंच प्रतिबंध का इससे क्या लेना-देना है?

आइए हम लेख की शुरुआत में लौटते हैं, हम प्रोग्रामर को स्पष्ट रूप से कैसे इंगित कर सकते हैं कि किसी विशेष भूमिका के लिए कौन से संसाधन एक्सेस किए जा सकते हैं? आपको इस डेटा को पाइपलाइन में दर्ज करने की आवश्यकता है ताकि हैंडलर उपयुक्त संसाधनों तक पहुंच सकें, मैंने इसे इस तरह किया है:

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

 // AdminPart AdminInfo * HttpContext -> Async<(AdminInfo * HttpContext) option> // AccountPart AccountInfo* HttpContext -> Async<(AccountInfo * HttpContext) option>

अंदर, नई सुविधाएँ पूरी तरह से मूल के समान हैं।

अब हैंडलर के पास तुरंत प्रत्येक भूमिका के लिए संसाधनों तक पहुंच है, केवल मुख्य चीज को वहां जोड़ा जाना चाहिए ताकि आप आसानी से नेविगेट कर सकें, उदाहरण के लिए, अकाउंटपार्ट में आप एक उपनाम, ईमेल, उपयोगकर्ता की भूमिका, मित्र सूची जोड़ सकते हैं यदि यह एक सामाजिक नेटवर्क है, लेकिन एक समस्या है: एक भारी के लिए अधिकांश हैंडलर मुझे एक मित्र सूची की आवश्यकता है, लेकिन बाकी के लिए मुझे इसकी बिल्कुल आवश्यकता नहीं है, मुझे क्या करना चाहिए? या तो इन हैंडलर को अलग-अलग मॉड्यूल (अधिमानतः) में वितरित करें, या एक्सेस आलसी बनाएं ( यूनिट में लपेटें -> दोस्तों की सूची ), मुख्य बात यह नहीं है कि IQueryable <Friend> को वहां रखा जाए , क्योंकि यह एक सेवा नहीं है - यह एक डेटा सेट है जो भूमिका को परिभाषित करता है।

मैंने अपने "आवेदन" के संदर्भ में, व्यवस्थापक द्वारा वर्तमान व्यवस्थापक द्वारा स्वीकृत और प्रतिबंधित उपयोगकर्ताओं के बारे में जानकारी डाल दी, यह प्रशासक की भूमिका को परिभाषित करता है:

  type AdminInfo = { ActiveUsersEmails: string list BanUsersEmails : string list } type UserInfo = { Name:string Surname:string }

क्लेम से क्या अंतर है? क्या यह संभव है कि User.Claims को कंट्रोलर में बनाया जाए और उसी चीज को प्राप्त किया जाए?

टाइपिंग और बातचीत में: मॉड्यूल, डेवलपर को एक ही संदर्भ में हैंडलर पर कोड उदाहरण देखने की जरूरत नहीं है, वह एक हैंडलर बनाता है और इसे रूटिंग में जोड़ता है और इसे सभी संकलन करता है

 let AccountPart handler = let getUserInfo ctx = async.Return {Name="Al";Surname="Pacino"} permissionHandler [User;Admin] getUserInfo handler

getUserInfo खाता मॉड्यूल के लिए डेटा प्राप्त करता है, व्यक्तिगत डेटा प्राप्त करने के लिए संदर्भ तक पहुंचता है (यह वास्तव में यह user'a, admina है)

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

पूर्ण स्रोत कोड github पर पाया जा सकता है

आपका ध्यान के लिए धन्यवाद!

एफ # पर एपीआई। प्रवेश भूमिका आधारित अनुप्रयोग मॉड्यूल

सुवे रूटिंग का परिचय

भूमिका और पहुंच प्रतिबंध का इससे क्या लेना-देना है?

More articles: