WinHTTP on kenji.blog

Comment publier un message sur Slack à l'aide de Slack App + OAuth2

Wed, 16 Jul 2025 23:36:27 +0900

✅ Méthode de publication à l’aide d’un jeton d’accès (Slack Web API)

Le “OAuth Token” (comme xoxb-…) de Slack est une clé pour publier des messages à l’aide de l’ API Web de Slack. Dans ce cas, contrairement à un Webhook, vous effectuez une requête POST vers le point de terminaison API Slack avec un en-tête Authorization: Bearer.

🔑 Prérequis nécessaires

Vous devez inclure chat:write dans les portées OAuth de l’application Slack :

Procédure de configuration

Accédez à https://api.slack.com/apps
Créez une application ou sélectionnez une application existante
Sous “OAuth & Permissions” > Scopes → Ajoutez chat:write
Cliquez sur “Install to Workspace” ou “Reinstall” et obtenez l’Access Token (ex : xoxb-xxxxxxxxxx)

💻 Code C++ (Publication sur l’API Slack avec WinHTTP)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostSlackMessage(const std::wstring& accessToken, const std::string& channel, const std::string& text) {
 const wchar_t* host = L"slack.com";
 const wchar_t* path = L"/api/chat.postMessage";

 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 if (!hSession) return false;

 HINTERNET hConnect = WinHttpConnect(hSession, host, INTERNET_DEFAULT_HTTPS_PORT, 0);
 if (!hConnect) return false;

 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", path,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 // En-têtes Authorization et Content-Type
 std::wstring headers = L"Content-Type: application/json\r\n";
 headers += L"Authorization: Bearer " + accessToken + L"\r\n";

 // Corps JSON
 std::string body = R"({"channel":")" + channel + R"(","text":")" + text + R"("})";

 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 (DWORD)-1,
 (LPVOID)body.c_str(),
 body.length(),
 body.length(),
 0);

 if (!result || !WinHttpReceiveResponse(hRequest, NULL)) {
 std::cerr << "Erreur d'envoi\n";
 return false;
 }

 // Vérification du code d'état
 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring token = L"xoxb-votre_jeton_d_acces"; // Jeton d'accès
 std::string channel = "ID_DU_CANAL_ou_#general"; // Ex : "#general" ou "C0123456789"
 std::string message = "Test de publication sur Slack depuis C++ !";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "Publication réussie !\n";
 } else {
 std::cerr << "Échec de la publication.\n";
 }

 return 0;
}

📌 Comment obtenir l’ID du canal

Utiliser uniquement le nom du canal (ex : #general) peut provoquer une erreur. La méthode fiable consiste à utiliser l’ID trouvé dans l’URL de la page du canal Slack.

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑Cette partie est l'ID du canal

✅ À propos des types de jetons (Supplément)

Format du jeton	Utilisation	Exemple
`xoxb-...`	Bot Token (Recommandé)	Publier, modifier, supprimer
`xoxp-...`	User Token (Non recommandé)	Opérations non liées aux bots
Refresh Token	Pour le renouvellement de jeton à long terme	Normalement non utilisé

📝 Résumé

Pour publier sur Slack depuis C++, la méthode Slack Web API + Bearer Token est fiable
Utilisez le point de terminaison chat.postMessage avec HTTPS POST
Le jeton doit être envoyé dans l’en-tête Bearer
La spécification de l’ID pour le canal est fiable

Comment publier un message sur Slack en C++ (API Win32 + WinHTTP) 【Support Webhook】

Wed, 16 Jul 2025 19:42:56 +0900

Comment publier un message sur Slack en C++ (API Win32 + WinHTTP) 【Support Webhook】

Je veux publier un message sur Slack depuis le C++. C’est très courant en Node.js ou en Python, mais les cas d’utilisation de « C++ × API Win32 × WinHTTP » sont rares.

Dans cet article, je vais expliquer étape par étape, de manière claire, comment envoyer un message à Slack depuis le C++ en utilisant une URL Webhook.

✅ Flux global

Pour publier sur Slack, suivez ces étapes :

Obtenir l’URL Webhook (clé API) de Slack
Envoyer une requête POST en utilisant WinHTTP
Construire le corps du message au format JSON
Vérifier le résultat et c’est terminé !

🔑 Étape 1 : Comment obtenir l’URL Webhook de Slack

Sur Slack, vous pouvez facilement publier des messages à partir de services externes en utilisant une fonctionnalité appelée Incoming Webhooks.

Procédure d’obtention

Accédez à https://api.slack.com/apps
Cliquez sur Create New App
Sélectionnez From scratch, choisissez un nom d’application et l’espace de travail cible
Dans le menu de gauche, sélectionnez « Incoming Webhooks » et activez-le
Cliquez sur « Add New Webhook to Workspace » et sélectionnez un canal
Copiez l’URL générée (ex : https://hooks.slack.com/services/xxx/yyy/zzz)

Cette URL fonctionne comme une clé API.

💻 Étape 2 : Envoyer un message à Slack avec du code C++

Technologies utilisées

API Win32
WinHTTP (bibliothèque standard)
Message au format JSON

Code d’exemple (Publication sur Slack)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostToSlack(const std::wstring& webhookUrl, const std::string& messageJson) {
 // Décomposition de l'URL
 URL_COMPONENTS urlComp{};
 wchar_t hostName[256];
 wchar_t urlPath[1024];

 urlComp.dwStructSize = sizeof(urlComp);
 urlComp.lpszHostName = hostName;
 urlComp.dwHostNameLength = _countof(hostName);
 urlComp.lpszUrlPath = urlPath;
 urlComp.dwUrlPathLength = _countof(urlPath);

 if (!WinHttpCrackUrl(webhookUrl.c_str(), 0, 0, &urlComp)) {
 std::wcerr << L"Échec de la décomposition de l'URL\n";
 return false;
 }

 // Session HTTP et connexion
 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 HINTERNET hConnect = WinHttpConnect(hSession, hostName, urlComp.nPort, 0);
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", urlPath,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 std::wstring headers = L"Content-Type: application/json\r\n";
 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 -1,
 (LPVOID)messageJson.c_str(),
 messageJson.length(),
 messageJson.length(),
 0);

 if (!result) {
 std::cerr << "Échec de la requête d'envoi\n";
 return false;
 }

 WinHttpReceiveResponse(hRequest, NULL);

 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 // Libération des ressources
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring webhookUrl = L"https://hooks.slack.com/services/xxx/yyy/zzz"; // Remplacez par votre Webhook

 std::string message = R"({
 "text": "Hello from C++ :rocket:",
 "username": "C++ Bot",
 "icon_emoji": ":robot_face:"
 })";

 if (PostToSlack(webhookUrl, message)) {
 std::cout << "Publication réussie !\n";
 } else {
 std::cerr << "Échec de la publication.\n";
 }

 return 0;
}

🧪 Personnalisation du message JSON

Dans les Webhooks de Slack, vous pouvez inclure les paramètres suivants :

1
2
3
4
5
6


{
 "text": "Contenu de la notification",
 "username": "Nom du bot",
 "icon_emoji": ":rocket:",
 "channel": "#Nom du canal souhaité"
}

📌 Remarques supplémentaires

Assurez-vous de spécifier "application/json" pour Content-Type
L’URL Webhook est passée telle quelle en tant que wstring (l’encodage URL n’est pas nécessaire)
N’oubliez pas WINHTTP_FLAG_SECURE car il s’agit d’une communication HTTPS

🎉 Bonus : Exemple de vérification de publication sur Slack

Cela s’affichera ainsi sur Slack :

1
2


[C++ Bot]
Hello from C++ :rocket:

✍️ Résumé

Élément	Contenu
Méthode de publication	Webhook (Incoming Webhooks)
Bibliothèque réseau	WinHTTP
Format des données	JSON
Paramètres utilisables	text, username, icon_emoji, channel, etc.

Même vous qui pensiez que l’intégration Slack en C++ était difficile, vous pouvez intégrer un bot de notification dès aujourd’hui !

🚀 Prochainement ?

Si vous êtes intéressé, la prochaine fois :

Pièces jointes de fichiers
Interface utilisateur avec des boutons
Manipulation flexible de l’API avec Slack App + OAuth2

Je peux également présenter une intégration Slack un peu plus avancée !

Comment publier un message dans Microsoft Teams depuis C++ (WinHTTP + Graph API)

Mon, 14 Jul 2025 23:40:15 +0900

Comment publier un message dans Microsoft Teams depuis C++ (WinHTTP + Graph API)

Vous souhaitez publier automatiquement dans une conversation Microsoft Teams —
C’est là que l’ API Microsoft Graph s’avère utile.
Dans cet article, nous présenterons un exemple de code C++ utilisant WinHTTP et les étapes de configuration d’authentification API nécessaires étape par étape.

🔧 Préparation requise (Configuration de l’authentification de l’API Microsoft Graph)

1. Inscription de l’application sur le portail Azure

Tout d’abord, pour utiliser l’API Microsoft Graph, vous devez enregistrer une application sur Azure.

Accédez au Portail Azure
Microsoft Entra ID > + Ajouter > Inscriptions d’applications > Nouvelle inscription
Entrez un nom d’application arbitraire et cliquez sur “S’inscrire”

2. Ajouter des autorisations d’API

Allez dans le menu de gauche “Autorisations de l’API”
Microsoft Graph > Sélectionner les autorisations, recherchez les portées ci-dessous et cliquez sur Mettre à jour les autorisations

Chat.ReadWrite
User.Read

※ Si vous souhaitez publier sur un canal, ChannelMessage.Send est également requis

3. Notez l’ID client et l’ID locataire

Gardez une trace des deux éléments suivants affichés dans l’onglet “Vue d’ensemble” :

ID d’application (client)
ID de répertoire (locataire)

4. Créer un secret client

Allez dans l’onglet “Certificats et secrets”
“Nouveau secret client” > définissez une date d’expiration et cliquez sur “Ajouter”
Assurez-vous de noter la valeur (secret) affichée à ce moment-là

🔐 Obtention du jeton d’accès (OAuth2)

Nous utiliserons le flux client_credentials pour l’obtention.
Exécutez la commande ci-dessous avec curl pour obtenir le jeton d’accès.

1
2
3
4
5
6
7


curl -X POST ^
 https://login.microsoftonline.com/{ID_locataire}/oauth2/v2.0/token ^
 -H "Content-Type: application/x-www-form-urlencoded" ^
 -d "client_id={ID_client}" ^
 -d "scope=https%3A%2F%2Fgraph.microsoft.com%2F.default" ^
 -d "client_secret={Secret_client}" ^
 -d "grant_type=client_credentials"

Exemple de réponse

1
2
3
4
5
6


{
 "token_type":"Bearer",
 "expires_in":3599,
 "ext_expires_in":3599,
 "access_token": "eyJ0eXAiOiJKV1QiLCJub... (omis)"
}

Utilisez cet access_token pour appeler l’API Microsoft Graph.

💬 Exemple C++ pour publier dans une conversation Teams

Voici un exemple C++ qui utilise WinHTTP pour publier dans une conversation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <windows.h>
#include <winhttp.h>
#include <iostream>
#include <string>

#pragma comment(lib, "winhttp.lib")

void PostToTeamsChat(const std::wstring& accessToken, const std::wstring& chatId, const std::wstring& message) {
 HINTERNET hSession = WinHttpOpen(L"TeamsPoster/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);

 HINTERNET hConnect = WinHttpConnect(hSession, L"graph.microsoft.com", INTERNET_DEFAULT_HTTPS_PORT, 0);

 std::wstring endpoint = L"/v1.0/chats/" + chatId + L"/messages";
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", endpoint.c_str(), NULL,
 WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);

 std::wstring jsonBody = L"{\"body\": {\"content\": \"" + message + L"\"}}";
 std::wstring headers = L"Authorization: Bearer " + accessToken + L"\r\nContent-Type: application/json\r\n";

 BOOL bResult = WinHttpSendRequest(hRequest,
 headers.c_str(), (DWORD)-1L,
 (LPVOID)jsonBody.c_str(), (DWORD)(jsonBody.length() * sizeof(wchar_t)),
 (DWORD)(jsonBody.length() * sizeof(wchar_t)), 0);

 if (bResult)
 WinHttpReceiveResponse(hRequest, NULL);

 DWORD dwSize = 0;
 WinHttpQueryDataAvailable(hRequest, &dwSize);

 if (dwSize > 0) {
 std::wstring response(dwSize / sizeof(wchar_t), 0);
 DWORD dwDownloaded = 0;
 WinHttpReadData(hRequest, &response[0], dwSize, &dwDownloaded);
 std::wcout << L"Response: " << response << std::endl;
 }

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);
}

int main() {
 std::wstring access;
 std::wstring chatId = L"19:";
 std::wstring message = L"Hello from C++!";
 std::wcout << L"Enter your access token: ";
 std::getline(std::wcin, access);
 std::wcout << L"Enter chat ID: ";
 std::getline(std::wcin, chatId);
 PostToTeamsChat(access, chatId, message);
 return 0;
}

🔍 Comment obtenir l’ID de conversation

L’ID de conversation peut être vérifié avec GET /v1.0/me/chats.

1
2
3
4


curl -X GET ^
 https://graph.microsoft.com/v1.0/me/chats ^
 -H "Authorization: Bearer {access_token}" ^
 -H "Content-Type: application/json"

Exemple de réponse

1
2
3
4
5
6
7
8
9


{
 "value": [
 {
 "id": "19:abc123xyz@thread.v2",
 "topic": null,
 "chatType": "oneOnOne"
 }
 ]
}

📌 Points d’attention

Cet exemple est une implémentation minimale. En production :
- Gestion de l’expiration des jetons
- Vérification des certificats HTTPS
- Amélioration de la gestion des erreurs
Les publications de canal utilisent teams/{team-id}/channels/{channel-id}/messages.
L’envoi de pièces jointes nécessite un traitement multipart ou l’API Graph Drive.

Résumé

📎 Résumé

Fonctionnalité	Aperçu
Graph API	API officielle pour interagir avec Teams
Inscription de l’application	Procédures d’authentification requises sur Azure
Jeton d’accès	Obtenu via OAuth2 et utilisé pour les requêtes
Implémentation C++	Appelle l’API Graph en utilisant WinHTTP

🚀 Prochaines étapes

Pour des exemples plus avancés, les éléments suivants sont également possibles :

Publication sur un canal d’équipe (/teams/{team-id}/channels/...)
Publication avec pièces jointes
Basculement entre les comptes bot et les comptes utilisateurs
Implémentation C++ complète, y compris l’obtention de jetons

N’hésitez pas à commenter si vous avez des demandes !