Microsoft Teams

Copied!
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
83
84
"""Read Microsoft Teams channel-message metadata with app-only Microsoft Graph OAuth."""

import json

import requests
from functions.api import UserFacingError, function
from functions.sources import get_source

SOURCE_ALIAS = "<source_alias>"
TENANT_ID = "<tenant_id>"
CLIENT_ID = "<client_id>"
TEAM_ID = "<team_id>"
CHANNEL_ID = "<channel_id>"
TOKEN_URL = f"https://login.microsoftonline.com/{TENANT_ID}/oauth2/v2.0/token"
MESSAGES_URL = (
    f"https://graph.microsoft.com/v1.0/teams/{TEAM_ID}/channels/"
    f"{CHANNEL_ID}/messages"
)


@function(sources=[SOURCE_ALIAS])
def list_channel_messages() -> str:
    """Return stable, non-content metadata for recent messages in the fixed channel."""
    source = get_source(SOURCE_ALIAS)
    session = requests.Session()
    proxy_uri = source.get_https_proxy_uri()
    if proxy_uri:
        session.proxies.update({"http": proxy_uri, "https": proxy_uri})

    token_response = session.post(
        TOKEN_URL,
        data={
            "client_id": CLIENT_ID,
            "client_secret": source.get_secret("OAuthClientSecret"),
            "scope": "https://graph.microsoft.com/.default",
            "grant_type": "client_credentials",
        },
        timeout=30,
    )
    if not token_response.ok:
        raise UserFacingError(
            f"Microsoft token exchange failed with HTTP {token_response.status_code}."
        )
    access_token = token_response.json().get("access_token")
    if not access_token:
        raise UserFacingError("Microsoft token response did not contain an access token.")

    response = session.get(
        MESSAGES_URL,
        params={"$top": 20},
        headers={"Authorization": f"Bearer {access_token}"},
        timeout=30,
    )
    if not response.ok:
        raise UserFacingError(
            f"Microsoft Graph message read failed with HTTP {response.status_code}."
        )

    messages = []
    for message in response.json().get("value", []):
        body = message.get("body") or {}
        messages.append(
            {
                "id": message.get("id"),
                "replyToId": message.get("replyToId"),
                "etag": message.get("etag"),
                "createdDateTime": message.get("createdDateTime"),
                "lastModifiedDateTime": message.get("lastModifiedDateTime"),
                "deletedDateTime": message.get("deletedDateTime"),
                "messageType": message.get("messageType"),
                "importance": message.get("importance"),
                "locale": message.get("locale"),
                "contentType": body.get("contentType"),
                "webUrl": message.get("webUrl"),
            }
        )

    return json.dumps(
        {
            "httpStatus": response.status_code,
            "messageCount": len(messages),
            "messages": messages,
        }
    )

Copied!
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
83
84
85
86
87
88
89
90
91
92
93
import {
    ExternalSystems,
    Function,
    UserFacingError,
} from "@foundry/functions-api";
import {
    MicrosoftTeamsSource,
} from "@foundry/external-systems/sources";

const TENANT_ID = "<tenant_id>";
const CLIENT_ID = "<client_id>";
const TEAM_ID = "<team_id>";
const CHANNEL_ID = "<channel_id>";
const TOKEN_URL = `https://login.microsoftonline.com/${TENANT_ID}/oauth2/v2.0/token`;
const MESSAGES_URL = `https://graph.microsoft.com/v1.0/teams/${TEAM_ID}/channels/${encodeURIComponent(CHANNEL_ID)}/messages?$top=20`;

interface TokenResponse {
    access_token?: string;
}

interface ChannelMessage {
    id?: string;
    replyToId?: string;
    etag?: string;
    createdDateTime?: string;
    lastModifiedDateTime?: string;
    deletedDateTime?: string;
    messageType?: string;
    importance?: string;
    locale?: string;
    body?: { contentType?: string };
    webUrl?: string;
}

interface ChannelMessagesResponse {
    value?: ChannelMessage[];
}

export class TeamsGraphFunctions {
    @ExternalSystems({ sources: [MicrosoftTeamsSource] })
    @Function()
    public async listChannelMessages(): Promise<string> {
        const tokenResponse = await MicrosoftTeamsSource.fetch(TOKEN_URL, {
            method: "POST",
            headers: { "Content-Type": "application/x-www-form-urlencoded" },
            body: new URLSearchParams({
                client_id: CLIENT_ID,
                client_secret: MicrosoftTeamsSource.getSecret("OAuthClientSecret"),
                scope: "https://graph.microsoft.com/.default",
                grant_type: "client_credentials",
            }).toString(),
        });
        if (!tokenResponse.ok) {
            throw new UserFacingError(
                `Microsoft token exchange failed with HTTP ${tokenResponse.status}.`,
            );
        }
        const tokenPayload = await tokenResponse.json() as TokenResponse;
        if (!tokenPayload.access_token) {
            throw new UserFacingError("Microsoft token response did not contain an access token.");
        }

        const response = await MicrosoftTeamsSource.fetch(MESSAGES_URL, {
            method: "GET",
            headers: { Authorization: `Bearer ${tokenPayload.access_token}` },
        });
        if (!response.ok) {
            throw new UserFacingError(
                `Microsoft Graph message read failed with HTTP ${response.status}.`,
            );
        }

        const payload = await response.json() as ChannelMessagesResponse;
        const messages = (payload.value ?? []).map((message) => ({
            id: message.id,
            replyToId: message.replyToId,
            etag: message.etag,
            createdDateTime: message.createdDateTime,
            lastModifiedDateTime: message.lastModifiedDateTime,
            deletedDateTime: message.deletedDateTime,
            messageType: message.messageType,
            importance: message.importance,
            locale: message.locale,
            contentType: message.body?.contentType,
            webUrl: message.webUrl,
        }));
        return JSON.stringify({
            httpStatus: response.status,
            messageCount: messages.length,
            messages,
        });
    }
}

Copied!
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import { UserFacingError } from "@osdk/functions";
import { getFetch, getSource } from "@palantir/functions-sources";

const APP_ONLY_SOURCE_RID = "<source_rid>";
const TENANT_ID = "<tenant_id>";
const CLIENT_ID = "<client_id>";
const TEAM_ID = "<team_id>";
const CHANNEL_ID = "<channel_id>";
const TOKEN_URL = `https://login.microsoftonline.com/${TENANT_ID}/oauth2/v2.0/token`;
const MESSAGES_URL = `https://graph.microsoft.com/v1.0/teams/${TEAM_ID}/channels/${encodeURIComponent(CHANNEL_ID)}/messages?$top=20`;

export const config = {
    sources: [APP_ONLY_SOURCE_RID],
};

interface TokenResponse {
    access_token?: string;
}

interface ChannelMessage {
    id?: string;
    replyToId?: string;
    etag?: string;
    createdDateTime?: string;
    lastModifiedDateTime?: string;
    deletedDateTime?: string;
    messageType?: string;
    importance?: string;
    locale?: string;
    body?: { contentType?: string };
    webUrl?: string;
}

interface ChannelMessagesResponse {
    value?: ChannelMessage[];
}

/** Returns stable, non-content metadata for recent messages in the fixed channel. */
export default async function listChannelMessages(): Promise<string> {
    const source = await getSource({ rid: APP_ONLY_SOURCE_RID });
    const clientSecret = source.secrets.OAuthClientSecret;
    if (!clientSecret) {
        throw new UserFacingError("Microsoft Teams source is missing OAuthClientSecret.");
    }
    const sourceFetch = await getFetch(source);
    const tokenResponse = await sourceFetch(TOKEN_URL, {
        method: "POST",
        headers: { "Content-Type": "application/x-www-form-urlencoded" },
        body: new URLSearchParams({
            client_id: CLIENT_ID,
            client_secret: clientSecret,
            scope: "https://graph.microsoft.com/.default",
            grant_type: "client_credentials",
        }).toString(),
    });
    if (!tokenResponse.ok) {
        throw new UserFacingError(
            `Microsoft token exchange failed with HTTP ${tokenResponse.status}.`,
        );
    }

    const tokenPayload = (await tokenResponse.json()) as TokenResponse;
    if (!tokenPayload.access_token) {
        throw new UserFacingError("Microsoft token response did not contain an access token.");
    }

    const response = await sourceFetch(MESSAGES_URL, {
        method: "GET",
        headers: { Authorization: `Bearer ${tokenPayload.access_token}` },
    });
    if (!response.ok) {
        throw new UserFacingError(
            `Microsoft Graph message read failed with HTTP ${response.status}.`,
        );
    }

    const payload = (await response.json()) as ChannelMessagesResponse;
    const messages = (payload.value ?? []).map((message) => ({
        id: message.id,
        replyToId: message.replyToId,
        etag: message.etag,
        createdDateTime: message.createdDateTime,
        lastModifiedDateTime: message.lastModifiedDateTime,
        deletedDateTime: message.deletedDateTime,
        messageType: message.messageType,
        importance: message.importance,
        locale: message.locale,
        contentType: message.body?.contentType,
        webUrl: message.webUrl,
    }));
    return JSON.stringify({
        httpStatus: response.status,
        messageCount: messages.length,
        messages,
    });
}

Copied!
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
import { getFetch, getSource } from "@palantir/functions-sources";

const DELEGATED_SOURCE_RID = "<source_rid>";
const TEAM_ID = "<team_id>";
const CHANNEL_ID = "<channel_id>";
const MESSAGES_URL = `https://graph.microsoft.com/v1.0/teams/${TEAM_ID}/channels/${encodeURIComponent(CHANNEL_ID)}/messages`;

export const config = {
    sources: [DELEGATED_SOURCE_RID],
};

interface PostedMessageResponse {
    id?: string;
    webUrl?: string;
}

interface GraphErrorResponse {
    error?: {
        code?: string;
        message?: string;
    };
}

/** Posts one message and returns only sanitized status and identifiers. */
export default async function sendChannelMessage(text: string): Promise<string> {
    const content = text.trim();
    if (!content) {
        return JSON.stringify({
            httpStatus: null,
            errorCode: "InvalidInput",
            errorMessage: "Message text must not be empty.",
        });
    }

    const source = await getSource({ rid: DELEGATED_SOURCE_RID });
    const credentials = await source.sessionCredentials?.get();
    if (!credentials || credentials.type !== "oauth" || !credentials.accessToken) {
        return JSON.stringify({
            httpStatus: null,
            errorCode: "DelegatedOAuthUnavailable",
            errorMessage: "Delegated Microsoft Graph OAuth is unavailable.",
        });
    }

    const sourceFetch = await getFetch(source);
    const response = await sourceFetch(MESSAGES_URL, {
        method: "POST",
        headers: {
            Authorization: `Bearer ${credentials.accessToken}`,
            "Content-Type": "application/json",
        },
        body: JSON.stringify({ body: { content } }),
    });
    if (!response.ok) {
        let errorCode: string | undefined;
        let errorMessage = `Microsoft Graph returned HTTP ${response.status}.`;
        try {
            const payload = (await response.json()) as GraphErrorResponse;
            errorCode = payload.error?.code;
            errorMessage = payload.error?.message?.slice(0, 1000) ?? errorMessage;
        } catch {
            // Keep the bounded, status-only error when Graph does not return JSON.
        }
        return JSON.stringify({
            httpStatus: response.status,
            errorCode,
            errorMessage,
        });
    }

    const message = (await response.json()) as PostedMessageResponse;
    return JSON.stringify({
        httpStatus: response.status,
        messageId: message.id,
        webUrl: message.webUrl,
    });
}