एकाधिक अनुमति प्रकारों को संभालने का सबसे अच्छा तरीका क्या है?

मुझे अक्सर निम्नलिखित परिदृश्य का सामना करना पड़ता है जहां मुझे कई अलग-अलग प्रकार की अनुमतियां प्रदान करने की आवश्यकता होती है। मैं मुख्य रूप से एसक्यूएल सर्वर 2000 के साथ एएसपी.NET / VB.NET का उपयोग करता हूं।

परिदृश्य

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

अतीत में, मैंने निम्नलिखित दो तरीकों में से एक चुना है जिसे मैं जानता हूं।

1) पैरामीटर को लागू करने के तरीके को निर्धारित करने के लिए उपयोग किए जाने वाले विशेष कॉलम के साथ एक एकल अनुमति तालिका का उपयोग करें। इस उदाहरण में विशेष कॉलम टाइपआईडी और टाइपएक्सआईडीआईडी ​​हैं। एसक्यूएल इस तरह कुछ दिखता है।

SELECT COUNT(PermissionID)
FROM application_permissions
WHERE
(TypeID = 1 AND TypeAuxID = @UserID) OR
(TypeID = 2 AND TypeAuxID = @DepartmentID)
AND ApplicationID = 1

2) प्रत्येक प्रकार की अनुमति के लिए मैपिंग टेबल का उपयोग करें, फिर उन सभी को एक साथ जोड़ना।

SELECT COUNT(perm.PermissionID)
FROM application_permissions perm
LEFT JOIN application_UserPermissions emp
ON perm.ApplicationID = emp.ApplicationID
LEFT JOIN application_DepartmentPermissions dept
ON perm.ApplicationID = dept.ApplicationID
WHERE [email protected]
  AND ([email protected] OR [email protected] OR
 (emp.UserID IS NULL AND dept.DeptID IS NULL)) AND ApplicationID = 1
ORDER BY q.QID ASC

मेरे विचार

मुझे आशा है कि उदाहरण समझ में आएंगे। मैंने उन्हें एक साथ दबाया।

पहले उदाहरण के लिए कम काम की आवश्यकता है, लेकिन उनमें से कोई भी सर्वश्रेष्ठ जवाब की तरह महसूस नहीं करता है। क्या इसे संभालने का कोई बेहतर तरीका है?

0
जोड़ा संपादित
विचारों: 1
स्रोत

5 उत्तर

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

क्षमा करें अगर मैंने आपके प्रश्न का उत्तर नहीं दिया है, तो मैं ऐसे व्यक्ति की तरह हूं जो सी # सीखने के लिए कहता है जब कोई वीबी प्रश्न पूछता है।

0
जोड़ा
स्रोत

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

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

new PermissionToken()
{
    Target = PermissionTokenTarget.Application,
    Action = PermissionTokenAction.View,
    Value = "ShippingApp"
};

इसे स्पष्ट रूप से कस्टम वैल्यू प्रॉपर्टी के कारण बनाने, संपादित करने, हटाने आदि के लिए बढ़ाया जा सकता है, और कोई भी एप्लीकेशन, मॉड्यूल या विजेट अपनी आवश्यक अनुमतियों को परिभाषित कर सकता है। वाईएमएमवी, लेकिन यह हमेशा मेरे लिए एक कुशल तरीका रहा है जिसे मैंने अच्छी तरह से स्केल किया है।

0
जोड़ा
स्रोत

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

0
जोड़ा
स्रोत

मैं जॉन डाउनी से सहमत हूं।

निजी तौर पर, मैं कभी-कभी अनुमतियों की ध्वजांकित गणना का उपयोग करता हूं। इस तरह आप गणना की वस्तुओं पर AND, OR, NOT और XOR bitwise संचालन का उपयोग कर सकते हैं।

"[Flags]
public enum Permission
{
    VIEWUSERS = 1, // 2^0 // 0000 0001
    EDITUSERS = 2, // 2^1 // 0000 0010
    VIEWPRODUCTS = 4, // 2^2 // 0000 0100
    EDITPRODUCTS = 8, // 2^3 // 0000 1000
    VIEWCLIENTS = 16, // 2^4 // 0001 0000
    EDITCLIENTS = 32, // 2^5 // 0010 0000
    DELETECLIENTS = 64, // 2^6 // 0100 0000
}"

Then, you can combine several permissions using the AND bitwise operator.

For example, if a user can view & edit users, the binary result of the operation is 0000 0011 which converted to decimal is 3.
You can then store the permission of one user into a single column of your DataBase (in our case it would be 3).

Inside your application, you just need another bitwise operation (OR) to verify if a user has a particular permission or not.

0
जोड़ा
स्रोत
इस दृष्टिकोण के साथ मुझे मिली समस्या यह है कि इस दृष्टिकोण का उपयोग करके भूमिकाओं से बाहर निकलना वास्तव में आसान है। जैसा कि आप देख सकते हैं कि 6 भूमिकाओं का मूल्य 2 ^ 6 = 64 है, जब 31 भूमिकाओं में 2 ^ 31 = 2,147,483,647 होगा जो अधिकतम int मान है। तो टी-एसक्यूएल में सबसे बड़ा डेटा प्रकार जिसका उपयोग किया जा सकता है bigint (2 ^ 63) है। बेशक आप वर्कर प्रकार का उपयोग कर सकते हैं, लेकिन जब मैं बहुत सारी भूमिकाएं लेता हूं तो मैं जॉन डाउनी के समाधान का उपयोग करना पसंद करता हूं।
जोड़ा लेखक Maksim Vi., स्रोत

जिस तरह से मैं आमतौर पर कोडिंग अनुमति प्रणाली के बारे में जाता हूं, इसमें 6 टेबल होते हैं।

  • उपयोगकर्ता - यह बहुत सरल है यह आपकी सामान्य उपयोगकर्ता तालिका
    • है
  • समूह - यह आपके विभागों का समानार्थी होगा
  • भूमिकाएं - यह एक तालिका है जिसमें आम तौर पर मानव पठनीय नाम और विवरण
    • सहित सभी अनुमतियां होती हैं
  • Users_have_Groups - यह एक से अधिक तालिका है जो उपयोगकर्ता के समूह से संबंधित है
  • Users_have_Roles - किसी अन्य उपयोगकर्ता को कौन सी भूमिकाएं आवंटित की जाती हैं, इसकी एक से अधिक से अधिक तालिका
  • Group_have_Roles - प्रत्येक समूह की भूमिकाओं की अंतिम-से-कई तालिकाएं

किसी उपयोगकर्ता सत्र की शुरुआत में आप कुछ तर्क चलाएंगे जो उन्होंने जो भी भूमिका निभाई है, या तो निर्देशिका या समूह के माध्यम से। फिर आप उन सुरक्षा भूमिकाओं के रूप में उन भूमिकाओं के खिलाफ कोड करते हैं।

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

0
जोड़ा
स्रोत