botbuilder/lib/teamsInfo.js

"use strict";
/**
 * @module botbuilder
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const botbuilder_core_1 = require("botbuilder-core");
const botframework_connector_1 = require("botframework-connector");
class TeamsInfo {
    static getTeamDetails(context, teamId) {
        return __awaiter(this, void 0, void 0, function* () {
            const t = teamId || this.getTeamId(context);
            if (!t) {
                throw new Error('This method is only valid within the scope of a MS Teams Team.');
            }
            return yield this.getTeamsConnectorClient(context).teams.fetchTeamDetails(t);
        });
    }
    static sendMessageToTeamsChannel(context, activity, teamsChannelId) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!context) {
                throw new Error("TurnContext cannot be null");
            }
            if (!activity) {
                throw new Error("Activity cannot be null");
            }
            if (!teamsChannelId || !teamsChannelId) {
                throw new Error("The teamsChannelId cannot be null or empty");
            }
            const convoParams = {
                isGroup: true,
                channelData: {
                    channel: {
                        id: teamsChannelId
                    }
                },
                activity: activity
            };
            const connectorClient = context.adapter.createConnectorClient(context.activity.serviceUrl);
            const conversationResourceResponse = yield connectorClient.conversations.createConversation(convoParams);
            const conversationReference = botbuilder_core_1.TurnContext.getConversationReference(context.activity);
            conversationReference.conversation.id = conversationResourceResponse.id;
            return [conversationReference, conversationResourceResponse.activityId];
        });
    }
    static getTeamChannels(context, teamId) {
        return __awaiter(this, void 0, void 0, function* () {
            const t = teamId || this.getTeamId(context);
            if (!t) {
                throw new Error('This method is only valid within the scope of a MS Teams Team.');
            }
            const channelList = yield this.getTeamsConnectorClient(context).teams.fetchChannelList(t);
            return channelList.conversations;
        });
    }
    static getMembers(context) {
        return __awaiter(this, void 0, void 0, function* () {
            const teamId = this.getTeamId(context);
            if (teamId) {
                return yield this.getTeamMembers(context, teamId);
            }
            else {
                const conversation = context.activity.conversation;
                const conversationId = conversation && conversation.id ? conversation.id : undefined;
                return yield this.getMembersInternal(this.getConnectorClient(context), conversationId);
            }
        });
    }
    static getPagedMembers(context, pageSize, continuationToken) {
        return __awaiter(this, void 0, void 0, function* () {
            const teamId = this.getTeamId(context);
            const options = {
                "continuationToken": continuationToken,
                "pageSize": pageSize
            };
            if (teamId) {
                return yield this.getPagedTeamMembers(context, teamId, pageSize, continuationToken);
            }
            else {
                const conversation = context.activity.conversation;
                const conversationId = conversation && conversation.id ? conversation.id : undefined;
                return yield this.getPagedMembersInternal(this.getConnectorClient(context), conversationId, options);
            }
        });
    }
    static getMember(context, userId) {
        return __awaiter(this, void 0, void 0, function* () {
            const teamId = this.getTeamId(context);
            if (teamId) {
                return yield this.getTeamMember(context, teamId, userId);
            }
            else {
                const conversation = context.activity.conversation;
                const conversationId = conversation && conversation.id ? conversation.id : undefined;
                return yield this.getMemberInternal(this.getConnectorClient(context), conversationId, userId);
            }
        });
    }
    static getTeamMembers(context, teamId) {
        return __awaiter(this, void 0, void 0, function* () {
            const t = teamId || this.getTeamId(context);
            if (!t) {
                throw new Error('This method is only valid within the scope of a MS Teams Team.');
            }
            return yield this.getMembersInternal(this.getConnectorClient(context), t);
        });
    }
    static getPagedTeamMembers(context, teamId, pageSize, continuationToken) {
        return __awaiter(this, void 0, void 0, function* () {
            const t = teamId || this.getTeamId(context);
            if (!t) {
                throw new Error('This method is only valid within the scope of a MS Teams Team.');
            }
            const options = {
                "continuationToken": continuationToken,
                "pageSize": pageSize
            };
            return yield this.getPagedMembersInternal(this.getConnectorClient(context), t, options);
        });
    }
    static getTeamMember(context, teamId, userId) {
        return __awaiter(this, void 0, void 0, function* () {
            const t = teamId || this.getTeamId(context);
            if (!t) {
                throw new Error('This method is only valid within the scope of a MS Teams Team.');
            }
            return yield this.getMemberInternal(this.getConnectorClient(context), t, userId);
        });
    }
    static getMembersInternal(connectorClient, conversationId) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!conversationId) {
                throw new Error('The getMembers operation needs a valid conversationId.');
            }
            const teamMembers = yield connectorClient.conversations.getConversationMembers(conversationId);
            teamMembers.forEach((member) => {
                member.aadObjectId = member.objectId;
            });
            return teamMembers;
        });
    }
    static getPagedMembersInternal(connectorClient, conversationId, options) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!conversationId) {
                throw new Error('The getPagedMembers operation needs a valid conversationId.');
            }
            const pagedMembersResult = yield connectorClient.conversations.getConversationPagedMembers(conversationId, options);
            const teamsPagedMembersResult = {
                "continuationToken": pagedMembersResult.continuationToken,
                "members": pagedMembersResult.members
            };
            return teamsPagedMembersResult;
        });
    }
    static getMemberInternal(connectorClient, conversationId, userId) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!conversationId) {
                throw new Error('The getMember operation needs a valid conversationId.');
            }
            if (!userId) {
                throw new Error('The getMember operation needs a valid conversationId.');
            }
            const teamMember = yield connectorClient.conversations.getConversationMember(conversationId, userId);
            return teamMember;
        });
    }
    static getTeamId(context) {
        if (!context) {
            throw new Error('Missing context parameter');
        }
        if (!context.activity) {
            throw new Error('Missing activity on context');
        }
        const channelData = context.activity.channelData;
        const team = channelData && channelData.team ? channelData.team : undefined;
        const teamId = team && typeof (team.id) === 'string' ? team.id : undefined;
        return teamId;
    }
    static getConnectorClient(context) {
        if (!context.adapter || !('createConnectorClient' in context.adapter)) {
            throw new Error('This method requires a connector client.');
        }
        return context.adapter.createConnectorClient(context.activity.serviceUrl);
    }
    static getTeamsConnectorClient(context) {
        const connectorClient = this.getConnectorClient(context);
        return new botframework_connector_1.TeamsConnectorClient(connectorClient.credentials, { baseUri: context.activity.serviceUrl });
    }
}
exports.TeamsInfo = TeamsInfo;
//# sourceMappingURL=teamsInfo.js.map