Azure AD सेटअप और Microsoft Graph प्रमाणन

Aspose.Email for Java Microsoft Graph के साथ पूर्ण एकीकरण प्रदान करता है, जिससे डेवलपर्स Microsoft 365 खातों से संदेश, संपर्क, कैलेंडर और कार्य प्रबंधित कर सकते हैं। यह गाइड आपको Azure AD एप्लिकेशन बनाने और प्रमाणीकरण को कॉन्फ़िगर करने के माध्यम से Aspose.Email के साथ कोडिंग शुरू करने में मदद करता है GraphClient.

Aspose.Email के साथ Microsoft Graph API का उपयोग करने से पहले, आपको Azure Active Directory (Azure AD) में एक एप्लिकेशन पंजीकृत करना होगा और प्रमाणीकरण को कॉन्फ़िगर करना होगा। यह पेज निम्नलिखित को कवर करता है:

  • Azure AD एप्लिकेशन (प्रोजेक्ट) बनाना।

  • आवश्यक Microsoft Graph अनुमतियों को असाइन करना।

  • क्रेडेंशियल्स उत्पन्न करना (क्लाइंट ID, क्लाइंट सीक्रेट, टेनेन्ट ID)।

  • जावा में Aspose.Email टोकन प्रोवाइडर्स का उपयोग करके प्रमाणित करना।

एक बार पूरा हो जाने पर, आप अपने जावा एप्लिकेशन से Microsoft Graph के साथ इंटरैक्ट करने के लिए तैयार होंगे।

1. Azure AD एप्लिकेशन बनाएं

Azure पोर्टल में अपना एप्लिकेशन पंजीकृत करने के लिए इस चरणों का पालन करें:

  1. साइन इन करें Azure पोर्टल.
  2. Azure Active Directory → App Registrations → New Registration पर जाएँ।

todo:image_alt_text

  1. अपने एप्लिकेशन के लिए Name दर्ज करें (जैसे, AsposeEmailGraphApp)।
  2. समर्थित अकाउंट प्रकार चुनें:
    • सिंगल टेनेंट (यदि केवल आपका संगठन इसे उपयोग करेगा)
    • मल्टीटेनेंट (यदि कई संस्थाओं को एक्सेस चाहिए)
  3. वैकल्पिक रूप से, एक Redirect URI सेट करें (इंटरैक्टिव या वेब प्रमाणन के लिए आवश्यक)।
  4. Register पर क्लिक करें।

todo:image_alt_text

2. क्लाइंट सीक्रेट बनाएं

  1. पंजीकरण के बाद, Certificates & Secrets → New Client Secret पर जाएँ।
  2. एक विवरण और समाप्ति अवधि जोड़ें।

todo:image_alt_text

  1. उत्पन्न सीक्रेट मान की कॉपी करें - आप इसे फिर नहीं देख पाएँगे।

क्लाइंट सीक्रेट को सुरक्षित रखें; यह कन्फिडेंशियल क्लाइंट प्रमाणन के लिए आवश्यक है।

आपको नया पंजीकृत एप्लिकेशन ब्लेड दिखना चाहिए।

todo:image_alt_text

3. Microsoft Graph अनुमतियों को कॉन्फ़िगर करें

  1. API Permissions → Add a Permission → Microsoft Graph पर जाएँ।
  2. परिस्थिति के अनुसार अनुमतियों का प्रकार चुनें: Delegated या Application।
  3. Aspose.Email संचालन के लिए आवश्यक अनुमतियाँ जोड़ें:
    • Contacts.ReadWrite – संपर्क प्रबंधन के लिए
    • Calendars.ReadWrite – कैलेंडर प्रबंधन के लिए
    • Mail.ReadWrite – संदेश पढ़ने और भेजने के लिए
    • Tasks.ReadWrite – कार्यों का प्रबंधन करने के लिए
  4. यदि आवश्यक हो तो Grant Admin Consent पर क्लिक करें।

todo:image_alt_text

4. पब्लिक क्लाइंट फ्लो की अनुमति दें

निर्दिष्ट करें कि एप्लिकेशन पब्लिक क्लाइंट है या नहीं। उन ऐप्स के लिए उपयुक्त जो टोकन ग्रांट फ्लो का उपयोग करते हैं और रीडायरेक्ट URI नहीं इस्तेमाल करते।

todo:image_alt_text

5. Microsoft Graph प्रमाणीकरण

Aspose.Email में समर्थित प्रमाणीकरण विधियाँ

| टोकन प्रोवाइडर | उपयोग केस | | ——————————– | ————————————————————————————— | | AzureConfidentialTokenProvider | कन्फिडेंशियल क्लाइंट (क्लाइंट ID + सीक्रेट) सर्वर-साइड ऐप्स के लिए | | AzureROPCConfiguration | रिसोर्स ओनर पासवर्ड क्रेडेंशियल्स (यूज़रनेम + पासवर्ड) गैर-इंटरैक्टिव परिदृश्यों के लिए | | AzurePublicTokenProvider | पब्लिक क्लाइंट (इंटरैक्टिव लॉगिन) | | AzureTokenProviderBase | कस्टम ऑथेंटिकेशन इम्प्लीमेंटेशन के लिए बेस क्लास |

गुप्त क्लाइंट का उपयोग करके प्रमाणित करें

उपयोग करें AzureConfidentialTokenProvider प्रमाणित करने के लिए जब आपके पास क्लाइंट ID, क्लाइंट सीक्रेट, और टेनेन्ट ID हों:

AzureConfidentialTokenProvider provider = new AzureConfidentialTokenProvider(
    tenantId,
    clientId,
    clientSecret
);

IGraphClient client = GraphClient.getClient(provider, tenantId);
client.setResource(ResourceType.Users);
client.setResourceId(username);
client.setEndpoint("https://graph.microsoft.com");

यह एक पूरी तरह प्रमाणित IGraphClient सेट करता है जो Microsoft Graph के साथ संवाद करने के लिए तैयार है।

ROPC (उपयोगकर्ता नाम और पासवर्ड) से प्रमाणित करें

जब आपके पास यूज़रनेम और पासवर्ड हो, ऐसे परिदृश्यों में उपयोग करें AzureROPCConfiguration:

AzureROPCConfiguration ropcConfig = new AzureROPCConfiguration(
    tenantId,
    clientId,
    clientSecret,
    username,
    password
);

IGraphClient client = GraphClient.getClient(ropcConfig, tenantId);
client.setResource(ResourceType.Users);
client.setResourceId(username);
client.setEndpoint("https://graph.microsoft.com");

Microsoft Graph के लिए कस्टम टोकन प्रोवाइडर

Aspose.Email for Java Microsoft Graph के साथ इस माध्यम से एकीकृत होती है IGraphClient इंटरफ़ेस। अनुरोधों को प्रमाणित करने के लिए, इसका कार्यान्वयन ITokenProvider आवश्यक है। अधिकांश डेवलपर्स अंतर्निहित प्रमाणीकरण प्रोवाइडर का उपयोग करेंगे, लेकिन कुछ परिस्थितियों में आप अपना खुद का प्रोवाइडर बनाना चाह सकते हैं, जैसे कि Resource Owner Password Credentials (ROPC) प्रवाह के साथ काम करते समय।

1. AzureROPCTokenProvider का उपयोग करके ITokenProvider लागू करें

यह क्लास एक कार्यान्वयन प्रदान करती है ITokenProvider Azure Resource Owner Password Credentials (ROPC) प्रवाह का उपयोग करके। निम्नलिखित उदाहरण केवल प्रदर्शन के लिये है। प्रोडक्शन में, हम क्लाइंट क्रेडेंशियल्स या PKCE के साथ ऑथराइज़ेशन कोड जैसी अधिक सुरक्षित प्रवाहों का उपयोग करने की सलाह देते हैं।

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * Azure resource owner password credential (ROPC) token provider
 * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth-ropc
 * https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-authenticate-an-ews-application-by-using-oauth
 * https://portal.azure.com
 * https://developer.microsoft.com/en-us/graph/graph-explorer/#
 * token parser https://jwt.io
 * </p>
 */
class AzureROPCTokenProvider implements ITokenProvider {

    private static final String GRANT_TYPE = "password";

    private final String clientId;
    private final String clientSecret;
    private final String userName;
    private final String password;
    private final String tenant;
    private final String scope;

    private OAuthToken token;

    public AzureROPCTokenProvider(String tenant, String clientId, String clientSecret,
                                  String userName, String password, String[] scopeAr) {
        this.tenant = tenant;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.userName = userName;
        this.password = password;
        this.scope = joinToStr(scopeAr, " ");
    }

    public synchronized OAuthToken getAccessToken(boolean ignoreExistingToken) {
        if (this.token != null && !this.token.getExpired() && !ignoreExistingToken)
            return this.token;
        token = null;

        Map<String, String> tokenArgs = getToken();

        java.util.Calendar c = java.util.Calendar.getInstance();
        c.add(java.util.Calendar.SECOND, Integer.parseInt(tokenArgs.get("expires_in")));
        token = new OAuthToken(tokenArgs.get("access_token"), TokenType.AccessToken, c.getTime());
        return token;
    }

    public final OAuthToken getAccessToken() {
        return getAccessToken(false);
    }

    public void dispose() {
    }

    private String getEncodedParameters() {
        return "client_id=" + urlEncode(clientId) + "&scope=" + urlEncode(scope) + "&username=" + urlEncode(userName)
                + "&password=" + urlEncode(password) + "&grant_type="
                + urlEncode(GRANT_TYPE);
    }

    private String getUri() {
        if (tenant == null || tenant.trim().isEmpty())
            return "https://login.microsoftonline.com/common/oauth2/v2.0/token";
        else
            return "https://login.microsoftonline.com/" + tenant + "/oauth2/v2.0/token";
    }

    private Map<String, String> getToken() {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL(getUri()).openConnection();
            connection.setRequestMethod("POST");

            byte[] requestData = getEncodedParameters().getBytes(StandardCharsets.UTF_8);

            connection.setUseCaches(false);
            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", "" + requestData.length);

            final OutputStream st = connection.getOutputStream();
            try {
                st.write(requestData, 0, requestData.length);
            } finally {
                st.flush();
                st.close();
            }

            connection.connect();

            if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
                throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" +
                        connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
                        + readInputStream(connection.getErrorStream()));
            }

            String responseText = readInputStream(connection.getInputStream());

            Map<String, String> result = new HashMap<>();
            String[] fromJsonToKeyValue = responseText.replace("{", "").replace("}", "")
                    .replace("\"", "").replace("\r", "")
                    .replace("\n", "").split(",");
            for (String keyValue : fromJsonToKeyValue) {
                String[] pair = keyValue.split(":");
                String name = pair[0].trim().toLowerCase();
                String value = urlDecode(pair[1].trim());
                result.put(name, value);
            }

            return result;
        } catch (IOException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlDecode(String value) {
        try {
            return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String readInputStream(InputStream is) {
        if (is == null)
            return "";

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder result = new StringBuilder();
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
        } catch (IOException e) {
            // ignore
        }
        return result.toString();
    }

    static String joinToStr(String[] arr, String sep) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i > 0)
                sb.append(sep);
            sb.append(arr[i]);
        }
        return sb.toString();
    }
}

2. ITokenProvider ऑब्जेक्ट बनाएं

यह IGraphClient इंटरफ़ेस अनुरोध बनाने, उन्हें Microsoft Graph को भेजने और प्रतिक्रियाओं को संभालने के लिए ज़िम्मेदार है। एक instance बनाने के लिए IGraphClient, आपको इसका कार्यान्वयन प्रदान करना होगा ITokenProvider. टोकन प्रोवाइडर वैध OAuth एक्सेस टोकन प्रदान करके अनुरोधों को प्रमाणित करता है।

निम्नलिखित कोड नमूना दर्शाता है कि कैसे एक बुनियादी इनलाइन कार्यान्वयन बनाया जा सकता है ITokenProvider इंटरफ़ेस, जो Microsoft Graph अनुरोधों को प्रमाणित करने के लिए आवश्यक है:

ITokenProvider tokenProvider = new ITokenProvider() {
    Date expirationDate = null;

    @Override
    public void dispose() {
        // Clean up resources if necessary
    }

    @Override
    public OAuthToken getAccessToken(boolean ignoreExistingToken) {
        // Retrieve an OAuth access token.
        // If ignoreExistingToken is true, always request a new token.
        // Otherwise, return the existing token if it is valid, or request a new one.
        return null;
    }

    @Override
    public OAuthToken getAccessToken() {
        // Return a valid OAuth token.
        // If no valid token exists, request a new one.
        return new OAuthToken("token", expirationDate);
    }
};

3. कस्टम टोकन प्रोवाइडर का उपयोग करना

एक बार ITokenProvider सेटअप हो जाने पर, आप बना सकते हैं एक GraphClient इंस्टेंस। यह क्लाइंट Microsoft Graph को कॉल करने पर प्रमाणन के लिए प्रदान किए गए टोकन प्रोवाइडर का उपयोग करेगा।

ITokenProvider provider = new AzureROPCTokenProvider(
        tenantId,
        clientId,
        clientSecret,
        userName,
        password,
        new String[] {"https://graph.microsoft.com/.default"}
);

IGraphClient client = GraphClient.getClient(provider, tenantId);
client.setResource(ResourceType.Users);
client.setResourceId(userName);
client.setEndpoint("https://graph.microsoft.com");

// Now you can call Microsoft Graph APIs
var folders = client.listFolders(null);
for (GraphFolderInfo folder : folders) {
    System.out.println(folder.getDisplayName());
}

क्लाइंट बनाने और प्रमाणित करने के बाद, आप Microsoft Graph सेवाओं को अनुरोध भेजना शुरू कर सकते हैं।

Aspose.Email for Java के साथ Microsoft Graph में कार्य प्रबंधित करें