C# ਵਿੱਚ ਈਮੇਲ ਭੇਜਣ ਲਈ ਗ੍ਰਾਫ API ਐਕਸੈਸ ਟੋਕਨਾਂ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ ਅਤੇ ਵਰਤਣਾ ਹੈ

ਮਾਈਕਰੋਸਾਫਟ ਗ੍ਰਾਫ API ਲਈ ਸਟ੍ਰੀਮਲਾਈਨਿੰਗ ਐਕਸੈਸ ਟੋਕਨ ਰੀਟਰੀਵਲ

ਕੀ ਤੁਸੀਂ ਕਦੇ ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਤੋਂ ਹਰ ਰੋਜ਼ ਹੱਥੀਂ ਪਹੁੰਚ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਅਸੁਵਿਧਾ ਦਾ ਸਾਹਮਣਾ ਕੀਤਾ ਹੈ? ਇਹ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਤੁਸੀਂ Microsoft Graph API ਦੁਆਰਾ ਈਮੇਲ ਭੇਜਣ ਲਈ ਆਟੋਮੇਸ਼ਨ 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਵਾਲੀ ਇੱਕ ਵਿਅਸਤ ਟੀਮ ਦਾ ਹਿੱਸਾ ਹੋ। ਦਸਤੀ ਪ੍ਰਕਿਰਿਆ ਤੇਜ਼ੀ ਨਾਲ ਉਤਪਾਦਕਤਾ ਵਿੱਚ ਇੱਕ ਰੁਕਾਵਟ ਬਣ ਸਕਦੀ ਹੈ. 🤔

ਇਸ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ, ਮੈਂ ਇੱਕ Azure ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਜੋ ਮੇਰੀ ਟੀਮ ਲਈ ਆਪਣੇ ਆਪ ਐਕਸੈਸ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਇਹ ਹੱਲ ਦੁਹਰਾਉਣ ਵਾਲੇ ਕੰਮਾਂ ਦੀ ਲੋੜ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰ ਕੋਈ ਟੋਕਨ ਪ੍ਰਬੰਧਨ ਦੀ ਬਜਾਏ ਆਪਣੇ ਮੁੱਖ ਕੰਮ 'ਤੇ ਧਿਆਨ ਦੇ ਸਕਦਾ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਨੂੰ ਬਹੁਤ ਜ਼ਰੂਰੀ ਕੈਫੀਨ ਬੂਸਟ ਦੇਣ ਵਰਗਾ ਹੈ! ☕

ਹਾਲਾਂਕਿ, ਜ਼ਿਆਦਾਤਰ ਵਿਕਾਸ ਯਾਤਰਾਵਾਂ ਦੀ ਤਰ੍ਹਾਂ, ਇਹ ਇਸਦੀਆਂ ਚੁਣੌਤੀਆਂ ਤੋਂ ਬਿਨਾਂ ਨਹੀਂ ਸੀ। ਸਫਲਤਾਪੂਰਵਕ ਇੱਕ ਟੋਕਨ ਤਿਆਰ ਕਰਨ ਦੇ ਬਾਵਜੂਦ, ਮੈਂ ਇੱਕ ਰੋਡ ਬਲਾਕ ਮਾਰਿਆ: ਮੇਰੇ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਟੋਕਨ ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਤੋਂ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ। ਇਸ ਅਚਾਨਕ ਅੰਤਰ ਨੇ ਇਸਦੀ ਵੈਧਤਾ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਾਰੇ ਕਈ ਸਵਾਲ ਖੜੇ ਕੀਤੇ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਉਸ ਕੋਡ ਨੂੰ ਸਾਂਝਾ ਕਰਾਂਗਾ ਜੋ ਮੈਂ ਵਰਤਿਆ ਹੈ, ਮੈਨੂੰ ਆਈਆਂ ਸਮੱਸਿਆਵਾਂ, ਅਤੇ ਸਮੱਸਿਆ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨ ਲਈ ਮੈਂ ਚੁੱਕੇ ਕਦਮਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਾਂਗਾ। ਭਾਵੇਂ ਤੁਸੀਂ ਸਮਾਨ ਕਾਰਜਸ਼ੀਲਤਾ ਬਣਾ ਰਹੇ ਹੋ ਜਾਂ Azure ਅਤੇ Graph API ਬਾਰੇ ਉਤਸੁਕ ਹੋ, ਇਹ ਗਾਈਡ ਤੁਹਾਨੂੰ ਅਮਲੀ ਸੂਝ ਅਤੇ ਸੰਬੰਧਿਤ ਉਦਾਹਰਣਾਂ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਲੈ ਕੇ ਜਾਵੇਗੀ। ਆਓ ਅੰਦਰ ਡੁਬਕੀ ਕਰੀਏ! 🚀

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
FormUrlEncodedContent	ਇਹ C# ਕਮਾਂਡ ਐਪਲੀਕੇਸ਼ਨ/x-www-form-urlencoded ਫਾਰਮੈਟ ਵਿੱਚ ਏਨਕੋਡ ਕੀਤੇ ਡੇਟਾ ਦੇ ਨਾਲ POST ਬੇਨਤੀਆਂ ਲਈ ਇੱਕ ਬੇਨਤੀ ਬਾਡੀ ਬਣਾਉਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਉਹਨਾਂ API ਨੂੰ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਿਆਂ ਨੂੰ ਪਾਸ ਕਰਨਾ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਇਸ ਫਾਰਮੈਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
HttpResponseMessage	C# ਵਿੱਚ ਇੱਕ HTTP ਬੇਨਤੀ ਤੋਂ ਪ੍ਰਾਪਤ ਜਵਾਬ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਸਰਵਰ ਦੇ ਜਵਾਬ ਦੀ ਸਥਿਤੀ, ਸਿਰਲੇਖ ਅਤੇ ਸਮੱਗਰੀ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
EnsureSuccessStatusCode	ਇੱਕ ਢੰਗ ਜੋ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ HTTP ਜਵਾਬ ਸਥਿਤੀ ਕੋਡ ਸਫਲ ਹੈ (2xx). ਜੇ ਨਹੀਂ, ਤਾਂ ਇਹ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਗਲਤੀ ਨੂੰ ਸਿੱਧਾ ਹੈਂਡਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
JsonConvert.DeserializeObject<T>	ਇਹ Newtonsoft.Json ਵਿਧੀ JSON ਸਤਰ ਨੂੰ C# ਵਸਤੂਆਂ ਜਾਂ ਡਾਇਨਾਮਿਕ ਕਿਸਮਾਂ ਵਿੱਚ ਪਾਰਸ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। API ਜਵਾਬਾਂ ਤੋਂ ਐਕਸੈਸ ਟੋਕਨ ਕੱਢਣ ਲਈ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ।
os.getenv	ਇੱਕ ਪਾਈਥਨ ਵਿਧੀ ਜੋ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ। ਕਲਾਇੰਟ ਆਈਡੀ ਅਤੇ ਭੇਦ ਵਰਗੇ ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਤੱਕ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਪਹੁੰਚ ਕਰਨ ਲਈ ਇਹ ਜ਼ਰੂਰੀ ਹੈ।
requests.post	HTTP POST ਬੇਨਤੀਆਂ ਭੇਜਣ ਲਈ ਪਾਈਥਨ ਵਿਧੀ। ਇਸਦੀ ਵਰਤੋਂ ਇੱਥੇ ਲੋੜੀਂਦੇ ਪੇਲੋਡ ਦੇ ਨਾਲ Microsoft Graph API ਟੋਕਨ ਐਂਡਪੁਆਇੰਟ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
raise Exception	ਗਲਤੀਆਂ ਹੋਣ 'ਤੇ ਅਪਵਾਦਾਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਵਧਾਉਣ ਲਈ ਪਾਈਥਨ ਕਮਾਂਡ। API ਜਵਾਬ ਸਫਲ ਨਾ ਹੋਣ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਇਸਦੀ ਵਰਤੋਂ ਗਲਤੀ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
Environment.GetEnvironmentVariable	ਇਹ C# ਢੰਗ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ ਲਿਆਉਂਦਾ ਹੈ। ਇਹ ਸਰੋਤ ਕੋਡ ਵਿੱਚ ਹਾਰਡਕੋਡ ਕੀਤੇ ਬਿਨਾਂ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦਾ ਇੱਕ ਸੁਰੱਖਿਅਤ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
dynamic	ਇੱਕ C# ਕੀਵਰਡ ਜੋ ਆਬਜੈਕਟ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਜਿਸਦੀ ਕਿਸਮ ਰਨਟਾਈਮ ਤੇ ਹੱਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਣਪਛਾਤੇ ਢਾਂਚੇ ਦੇ ਨਾਲ JSON ਜਵਾਬਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਉਪਯੋਗੀ।
httpClient.PostAsync	ਅਸਿੰਕ੍ਰੋਨਸ HTTP POST ਬੇਨਤੀਆਂ ਭੇਜਣ ਲਈ ਇੱਕ C# ਵਿਧੀ। ਇਹ ਇੱਥੇ ਮਾਈਕਰੋਸਾਫਟ ਆਈਡੈਂਟਿਟੀ ਦੇ ਟੋਕਨ ਐਂਡਪੁਆਇੰਟ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਗ੍ਰਾਫ API ਟੋਕਨ ਪ੍ਰਾਪਤੀ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਅਨੁਕੂਲ ਬਣਾਉਣਾ

ਮਾਈਕਰੋਸਾਫਟ ਗ੍ਰਾਫ API ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਈਮੇਲ ਭੇਜਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨ ਲਈ, ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਇਹ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ C# ਵਿੱਚ ਕਲਾਇੰਟ ਕ੍ਰੈਡੈਂਸ਼ੀਅਲ ਫਲੋ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਐਕਸੈਸ ਟੋਕਨ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਸਰਵਰ-ਸਾਈਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਜਾਂ ਸੇਵਾਵਾਂ, ਜਿਵੇਂ ਕਿ Azure ਫੰਕਸ਼ਨ, ਜਿੱਥੇ ਕਿਸੇ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਬਣਾਉਂਦੇ ਹੋ। ਸਕ੍ਰਿਪਟ ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ `ClientId`, `ClientSecret`, ਅਤੇ `TenantId`। ਇਹ ਸਰੋਤ ਕੋਡ ਵਿੱਚ ਹਾਰਡਕੋਡ ਕੀਤੇ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਤੋਂ ਬਚ ਕੇ ਸੁਰੱਖਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।

ਹੱਲ ਦਾ ਕੋਰ `FormUrlEncodedContent` ਕਲਾਸ ਦੇ ਦੁਆਲੇ ਘੁੰਮਦਾ ਹੈ, ਜੋ ਪ੍ਰਮਾਣੀਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਫਾਰਮੈਟ ਵਿੱਚ ਬੇਨਤੀ ਪੇਲੋਡ ਬਣਾਉਂਦਾ ਹੈ। ਇੱਕ ਵਾਰ ਪੇਲੋਡ ਤਿਆਰ ਹੋਣ 'ਤੇ, 'httpClient.PostAsync' ਵਿਧੀ Microsoft ਪਛਾਣ ਟੋਕਨ ਐਂਡਪੁਆਇੰਟ ਨੂੰ HTTP POST ਬੇਨਤੀ ਭੇਜਦੀ ਹੈ। ਇਹ ਕਾਲ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਐਪ ਪ੍ਰੋਗਰਾਮੈਟਿਕ ਤੌਰ 'ਤੇ ਇੱਕ ਵੈਧ ਟੋਕਨ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸਦੀ ਵਰਤੋਂ ਫਿਰ ਈਮੇਲ ਭੇਜਣ ਜਾਂ ਡੇਟਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ Microsoft Graph API ਵਰਗੇ ਸਰੋਤਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਪਾਈਥਨ ਉਦਾਹਰਨ ਟੋਕਨ ਪ੍ਰਾਪਤੀ ਲਈ ਇੱਕ ਹਲਕਾ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਕੇ C# ਸਕ੍ਰਿਪਟ ਦੀ ਪੂਰਤੀ ਕਰਦੀ ਹੈ। `os.getenv` ਵਿਧੀ ਦਾ ਲਾਭ ਉਠਾ ਕੇ, ਇਹ ਸੰਵੇਦਨਸ਼ੀਲ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਵਾਤਾਵਰਣ ਤੋਂ ਸਿੱਧਾ ਖਿੱਚਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ C# ਸਕ੍ਰਿਪਟ। 'requests.post' ਫੰਕਸ਼ਨ ਟੋਕਨ ਐਂਡਪੁਆਇੰਟ ਕਾਲ ਕਰਦਾ ਹੈ, ਪਾਇਥਨ ਨਾਲ ਵਧੇਰੇ ਜਾਣੂ ਡਿਵੈਲਪਰਾਂ ਲਈ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਦੋਵਾਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਪ੍ਰਮਾਣੀਕਰਨ ਅਸਫਲਤਾਵਾਂ ਜਾਂ API ਤਰੁੱਟੀਆਂ ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਪਾਈਥਨ ਵਿੱਚ `response.EnsureSuccessStatusCode` (C#) ਅਤੇ ਸਪਸ਼ਟ ਅਪਵਾਦ ਉਭਾਰਨ (`ਅਪਵਾਦ ਵਧਾਓ`) ਦੇ ਨਾਲ ਮਜ਼ਬੂਤ ​​​​ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਸ਼ਾਮਲ ਹੈ।

ਇਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਅਸਲ-ਜੀਵਨ ਉਦਾਹਰਨ ਇੱਕ ਟੀਮ ਸੂਚਨਾ ਪ੍ਰਣਾਲੀ ਹੋਵੇਗੀ ਜੋ ਟੀਮ ਦੇ ਮੈਂਬਰਾਂ ਨੂੰ ਨਾਜ਼ੁਕ ਘਟਨਾਵਾਂ, ਜਿਵੇਂ ਕਿ ਆਗਾਮੀ ਸਮਾਂ-ਸੀਮਾਵਾਂ ਜਾਂ ਸੇਵਾ ਬੰਦ ਹੋਣ ਬਾਰੇ ਈਮੇਲ ਭੇਜਦੀ ਹੈ। ਟੋਕਨਾਂ ਨੂੰ ਹੱਥੀਂ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਰੋਜ਼ਾਨਾ ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਵਿੱਚ ਲੌਗਇਨ ਕਰਨ ਦੀ ਬਜਾਏ, ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦੀਆਂ ਹਨ, ਮਨੁੱਖੀ ਗਲਤੀ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ ਅਤੇ ਕੁਸ਼ਲਤਾ ਵਧਾਉਂਦੀਆਂ ਹਨ। 🚀 ਇਹ ਆਟੋਮੇਸ਼ਨ ਨਾ ਸਿਰਫ਼ ਸਮੇਂ ਦੀ ਬੱਚਤ ਕਰਦਾ ਹੈ ਬਲਕਿ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਿਸਟਮ ਨਿਰਵਿਘਨ ਕੰਮ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਛੁੱਟੀ ਦੇ ਸਮੇਂ ਦੌਰਾਨ ਵੀ। ਭਾਵੇਂ ਤੁਸੀਂ C# ਨੂੰ ਐਂਟਰਪ੍ਰਾਈਜ਼-ਪੱਧਰ ਦੇ ਹੱਲਾਂ ਨਾਲ ਏਕੀਕਰਣ ਲਈ ਚੁਣਦੇ ਹੋ ਜਾਂ ਇਸਦੀ ਸਰਲਤਾ ਲਈ ਪਾਈਥਨ, ਦੋਵੇਂ ਪਹੁੰਚ ਮੁੱਖ ਸਮੱਸਿਆ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹੱਲ ਕਰਦੇ ਹਨ। 😊

// Import necessary namespaces
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Collections.Generic;
using Newtonsoft.Json;
using Microsoft.Extensions.Logging;
namespace GraphApiTokenFetcher
{
    public class TokenService
    {
        private static readonly HttpClient httpClient = new HttpClient();
        // Fetch access token using Client Credentials flow
        public static async Task<string> GetGraphAccessTokenAsync(ILogger log)
        {
            try
            {
                // Retrieve environment variables
                var clientId = Environment.GetEnvironmentVariable("ClientId");
                var clientSecret = Environment.GetEnvironmentVariable("ClientSecret");
                var tenantId = Environment.GetEnvironmentVariable("TenantId");
                var tokenEndpoint = $"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token";
                // Prepare the request body
                var body = new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("client_id", clientId),
                    new KeyValuePair<string, string>("scope", "https://graph.microsoft.com/.default"),
                    new KeyValuePair<string, string>("client_secret", clientSecret),
                    new KeyValuePair<string, string>("grant_type", "client_credentials")
                });
                // Make the HTTP POST request
                HttpResponseMessage response = await httpClient.PostAsync(tokenEndpoint, body);
                response.EnsureSuccessStatusCode();
                // Read and parse the response
                string responseContent = await response.Content.ReadAsStringAsync();
                var tokenResult = JsonConvert.DeserializeObject<dynamic>(responseContent);
                return tokenResult.access_token;
            }
            catch (Exception ex)
            {
                log.LogError($"Error fetching Graph API token: {ex.Message}");
                throw;
            }
        }
    }
}

# Import required libraries
import os
import requests
import json
# Function to fetch access token
def get_graph_access_token():
    client_id = os.getenv("ClientId")
    client_secret = os.getenv("ClientSecret")
    tenant_id = os.getenv("TenantId")
    token_endpoint = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
    # Prepare request payload
    payload = {
        "client_id": client_id,
        "client_secret": client_secret,
        "scope": "https://graph.microsoft.com/.default",
        "grant_type": "client_credentials"
    }
    # Send the POST request
    response = requests.post(token_endpoint, data=payload)
    if response.status_code == 200:
        return response.json().get("access_token")
    else:
        raise Exception(f"Failed to retrieve token: {response.text}")
# Retrieve and print token
if __name__ == "__main__":
    try:
        token = get_graph_access_token()
        print("Access Token:", token)
    except Exception as e:
        print("Error:", str(e))

ਗ੍ਰਾਫ API ਟੋਕਨ ਪ੍ਰਮਾਣਿਕਤਾ ਵਿੱਚ ਚੁਣੌਤੀਆਂ ਨੂੰ ਪਾਰ ਕਰਨਾ

Microsoft Graph API ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇੱਕ ਨਾਜ਼ੁਕ ਚੁਣੌਤੀ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਜੋ ਪਹੁੰਚ ਟੋਕਨ ਦੀ ਵੈਧਤਾ ਅਤੇ ਦਾਇਰੇ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੁੰਦਾ ਹੈ। ਜਦੋਂ ਕਿ ਕਲਾਇੰਟ ਕ੍ਰੈਡੈਂਸ਼ੀਅਲਸ ਪ੍ਰਵਾਹ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸਿੱਧਾ ਹੈ, ਇਸਦੀ ਉਪਯੋਗਤਾ Azure AD ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦਿੱਤੀਆਂ ਗਈਆਂ ਅਨੁਮਤੀਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। ਇੱਕ ਆਮ ਨਿਗਰਾਨੀ API ਅਨੁਮਤੀਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੌਂਫਿਗਰ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੋ ਰਹੀ ਹੈ, ਜਿਸ ਨਾਲ ਈਮੇਲ ਭੇਜਣ ਜਾਂ ਹੋਰ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਟੋਕਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵੇਲੇ ਗਲਤੀਆਂ ਹੋ ਰਹੀਆਂ ਹਨ।

ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਵਿਚਾਰ ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਬਨਾਮ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੇ ਟੋਕਨਾਂ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੇ ਟੋਕਨਾਂ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ ਹੈ। ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਟੋਕਨਾਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਉਪਭੋਗਤਾ ਦੇ ਸੰਦਰਭ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ ਅਨੁਮਤੀਆਂ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕਲਾਇੰਟ ਪ੍ਰਮਾਣ ਪੱਤਰ ਪ੍ਰਵਾਹ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਟੋਕਨ ਐਪਲੀਕੇਸ਼ਨ-ਸਕੋਪਡ ਹੁੰਦੇ ਹਨ। ਇਹ ਅੰਤਰ ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਉਂ ਵਾਪਸ ਕੀਤੇ ਟੋਕਨ ਮੇਲ ਨਹੀਂ ਖਾਂਦੇ, ਭਾਵੇਂ ਅੰਡਰਲਾਈੰਗ ਸੰਰਚਨਾਵਾਂ ਸਮਾਨ ਲੱਗਦੀਆਂ ਹੋਣ।

ਇਹਨਾਂ ਅੰਤਰਾਂ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਤਸਦੀਕ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਕੋਲ Azure ਪੋਰਟਲ ਵਿੱਚ ਲੋੜੀਂਦੀਆਂ Mail.Send ਜਾਂ ਇਸਦੇ ਬਰਾਬਰ ਦੀ ਸੌਂਪੀ ਗਈ ਇਜਾਜ਼ਤ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, [JWT.io](https://jwt.io) ਵਰਗੇ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੀਕੋਡ ਕੀਤੇ ਟੋਕਨ ਪੇਲੋਡ ਦਾ ਮੁਆਇਨਾ ਕਰਨਾ ਗੁੰਮ ਜਾਂ ਗਲਤ ਦਾਅਵਿਆਂ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ `scp` (ਸਕੋਪ) ਜਾਂ `ਰੋਲ`। ਇੱਕ ਅਸਲ-ਸੰਸਾਰ ਦ੍ਰਿਸ਼ ਜਿੱਥੇ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੋਵੇਗਾ ਕਲਾਇੰਟ ਸੂਚਨਾਵਾਂ ਲਈ ਬਲਕ ਈਮੇਲ ਡਿਲੀਵਰੀ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨਾ। ਸਹੀ ਸੰਰਚਨਾ ਦੇ ਬਿਨਾਂ, ਸਿਸਟਮ ਉਤਪਾਦਨ ਦੇ ਦੌਰਾਨ ਅਸਫਲ ਹੋ ਸਕਦਾ ਹੈ, ਗਾਹਕ ਸੰਚਾਰ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਕਦਮ ਚੁੱਕਣਾ ਸਹਿਜ ਏਕੀਕਰਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਹੱਲ ਵਿੱਚ ਭਰੋਸੇਯੋਗਤਾ ਬਣਾਉਂਦਾ ਹੈ। 😊

1. ਮੇਰਾ ਟੋਕਨ ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਤੋਂ ਮੇਲ ਕਿਉਂ ਨਹੀਂ ਖਾਂਦਾ?
2. ਪ੍ਰੋਗ੍ਰਾਮਿਕ ਤੌਰ 'ਤੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਟੋਕਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ , ਜੋ ਗ੍ਰਾਫ ਐਕਸਪਲੋਰਰ ਦੇ ਉਪਭੋਗਤਾ-ਆਧਾਰਿਤ ਟੋਕਨਾਂ ਦੇ ਉਲਟ, ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਅਨੁਮਤੀਆਂ ਨੂੰ ਸਕੋਪ ਕਰਦਾ ਹੈ।
3. ਦੀ ਭੂਮਿਕਾ ਕੀ ਹੈ ਟੋਕਨ ਬੇਨਤੀਆਂ ਵਿੱਚ ਪੈਰਾਮੀਟਰ?
4. ਦ API ਪਹੁੰਚ ਪੱਧਰ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ , ਸਹੀ ਪਹੁੰਚ ਅਨੁਮਤੀਆਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ।
5. ਮੈਂ ਐਕਸੈਸ ਟੋਕਨ ਨੂੰ ਕਿਵੇਂ ਡੀਕੋਡ ਕਰ ਸਕਦਾ ਹਾਂ?
6. ਵਰਗੇ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਦਾਅਵਿਆਂ ਲਈ ਤੁਹਾਡੇ ਟੋਕਨ ਦੇ ਪੇਲੋਡ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਜਿਵੇਂ ਕਿ `scp` ਜਾਂ `ਰੋਲ`, ਇਜਾਜ਼ਤਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ।
7. ਮੇਰੇ ਟੋਕਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਮੈਨੂੰ "ਬੁਰਾ ਬੇਨਤੀ" ਜਵਾਬ ਕਿਉਂ ਮਿਲ ਰਿਹਾ ਹੈ?
8. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੀ ਐਪ ਦੀ ਲੋੜ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ) Azure AD ਵਿੱਚ ਕੌਂਫਿਗਰ ਕੀਤਾ ਗਿਆ ਅਤੇ ਪ੍ਰਸ਼ਾਸਕ ਦੀ ਸਹਿਮਤੀ ਦਿੱਤੀ ਗਈ।
9. ਕੀ ਮੈਂ ਟੋਕਨ ਨੂੰ ਆਪਣੇ ਆਪ ਰਿਫ੍ਰੈਸ਼ ਕਰ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ?
10. ਹਾਂ, ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਇੱਕ ਨਵਾਂ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਜਦੋਂ ਇਹ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਿਆਦ ਪੁੱਗ ਜਾਂਦੀ ਹੈ , ਦਸਤੀ ਦਖਲ ਦੀ ਲੋੜ ਨੂੰ ਬਾਈਪਾਸ.

ਲਈ ਟੋਕਨ ਪ੍ਰਾਪਤੀ ਨੂੰ ਆਟੋਮੈਟਿਕ ਕਰਕੇ , ਡਿਵੈਲਪਰ ਸਮਾਂ ਬਚਾ ਸਕਦੇ ਹਨ ਅਤੇ ਸੁਰੱਖਿਅਤ, ਗਲਤੀ-ਮੁਕਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹਨ। ਇਹ ਵਿਧੀ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਸਰਵਰ-ਸਾਈਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਦਸਤੀ ਦਖਲ ਤੋਂ ਬਿਨਾਂ ਸਰੋਤਾਂ ਤੱਕ ਭਰੋਸੇਯੋਗ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। 😊

ਟੋਕਨ ਸਕੋਪ, ਅਨੁਮਤੀਆਂ, ਅਤੇ ਉਪਭੋਗਤਾ ਅਤੇ ਐਪ ਟੋਕਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ ਸਫਲਤਾ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇਹਨਾਂ ਸੂਝਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਭਰੋਸੇ ਨਾਲ ਕੁਸ਼ਲ ਵਰਕਫਲੋ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ, ਰੁਕਾਵਟਾਂ ਨੂੰ ਘੱਟ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੁਹਾਡੀ ਟੀਮ ਜਾਂ ਸੰਗਠਨ ਲਈ ਉਤਪਾਦਕਤਾ ਵਧਾ ਸਕਦੇ ਹੋ।