@pnp/cli-microsoft365 10.0.0-beta.a868b81 → 10.0.0-beta.b184dfb

package/dist/m365/teams/commands/meeting/meeting-transcript-get.js

@@ -0,0 +1,152 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TeamsMeetingTranscriptGetCommand_instances, _TeamsMeetingTranscriptGetCommand_initTelemetry, _TeamsMeetingTranscriptGetCommand_initOptions, _TeamsMeetingTranscriptGetCommand_initValidators, _TeamsMeetingTranscriptGetCommand_initOptionSets;
+import auth from '../../../../Auth.js';
+import request from '../../../../request.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import fs from 'fs';
+import path from 'path';
+class TeamsMeetingTranscriptGetCommand extends GraphCommand {
+    get name() {
+        return commands.MEETING_TRANSCRIPT_GET;
+    }
+    get description() {
+        return 'Downloads a transcript for a given meeting';
+    }
+    constructor() {
+        super();
+        _TeamsMeetingTranscriptGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[this.resource].accessToken);
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving transcript for the given meeting...`);
+            }
+            let requestUrl = `${this.resource}/beta/`;
+            if (isAppOnlyAccessToken) {
+                if (!args.options.userId && !args.options.userName && !args.options.email) {
+                    throw `The option 'userId', 'userName' or 'email' is required when retrieving meeting transcript using app only permissions`;
+                }
+                requestUrl += 'users/';
+                if (args.options.userId) {
+                    requestUrl += args.options.userId;
+                }
+                else if (args.options.userName) {
+                    requestUrl += args.options.userName;
+                }
+                else if (args.options.email) {
+                    if (this.verbose) {
+                        await logger.logToStderr(`Getting user ID for user with email '${args.options.email}'.`);
+                    }
+                    const userId = await entraUser.getUserIdByEmail(args.options.email);
+                    requestUrl += userId;
+                }
+            }
+            else {
+                if (args.options.userId || args.options.userName || args.options.email) {
+                    throw `The options 'userId', 'userName', and 'email' cannot be used while retrieving meeting transcript using delegated permissions`;
+                }
+                requestUrl += `me`;
+            }
+            requestUrl += `/onlineMeetings/${args.options.meetingId}/transcripts/${args.options.id}`;
+            if (args.options.outputFile) {
+                requestUrl += '/content?$format=text/vtt';
+            }
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: args.options.outputFile ? 'stream' : 'json'
+            };
+            const meetingTranscript = await request.get(requestOptions);
+            if (meetingTranscript) {
+                if (args.options.outputFile) {
+                    // Not possible to use async/await for this promise
+                    await new Promise((resolve, reject) => {
+                        const writer = fs.createWriteStream(args.options.outputFile);
+                        meetingTranscript.data.pipe(writer);
+                        writer.on('error', err => {
+                            reject(err);
+                        });
+                        writer.on('close', async () => {
+                            const filePath = args.options.outputFile;
+                            if (this.verbose) {
+                                await logger.logToStderr(`File saved to path ${filePath}`);
+                            }
+                            return resolve();
+                        });
+                    });
+                }
+                else {
+                    await logger.log(meetingTranscript);
+                }
+            }
+            else {
+                throw `The specified meeting transcript was not found`;
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_TeamsMeetingTranscriptGetCommand_instances = new WeakSet(), _TeamsMeetingTranscriptGetCommand_initTelemetry = function _TeamsMeetingTranscriptGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            email: typeof args.options.email !== 'undefined',
+            outputFile: typeof args.options.outputFile !== 'undefined'
+        });
+    });
+}, _TeamsMeetingTranscriptGetCommand_initOptions = function _TeamsMeetingTranscriptGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --userId [userId]'
+    }, {
+        option: '-n, --userName [userName]'
+    }, {
+        option: '--email [email]'
+    }, {
+        option: '-m, --meetingId <meetingId>'
+    }, {
+        option: '-i, --id <id>'
+    }, {
+        option: '-f, --outputFile [outputFile]'
+    });
+}, _TeamsMeetingTranscriptGetCommand_initValidators = function _TeamsMeetingTranscriptGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid Guid`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid user principal name (UPN)`;
+        }
+        if (args.options.email && !validation.isValidUserPrincipalName(args.options.email)) {
+            return `${args.options.email} is not a valid email`;
+        }
+        if (args.options.outputFile && !fs.existsSync(path.dirname(args.options.outputFile))) {
+            return 'Specified path where to save the file does not exits';
+        }
+        return true;
+    });
+}, _TeamsMeetingTranscriptGetCommand_initOptionSets = function _TeamsMeetingTranscriptGetCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['userId', 'userName', 'email'],
+        runsWhen: (args) => args.options.userId || args.options.userName || args.options.email
+    });
+};
+export default new TeamsMeetingTranscriptGetCommand();
+//# sourceMappingURL=meeting-transcript-get.js.map

package/dist/m365/teams/commands/tab/tab-list.js

@@ -29,9 +29,11 @@ class TeamsTabListCommand extends GraphCommand {
         const endpoint = `${this.resource}/v1.0/teams/${args.options.teamId}/channels/${formatting.encodeQueryParameter(args.options.channelId)}/tabs?$expand=teamsApp`;
         try {
             const items = await odata.getAllItems(endpoint);
-            items.forEach(i => {
-                i.teamsAppTabId = i.teamsApp.id;
-            });
+            if (args.options.output !== 'json') {
+                items.forEach(i => {
+                    i.teamsAppTabId = i.teamsApp.id;
+                });
+            }
             await logger.log(items);
         }
         catch (err) {

package/dist/m365/teams/commands/team/team-get.js

@@ -5,11 +5,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _TeamsTeamGetCommand_instances, _TeamsTeamGetCommand_initTelemetry, _TeamsTeamGetCommand_initOptions, _TeamsTeamGetCommand_initValidators, _TeamsTeamGetCommand_initOptionSets;
 import request from '../../../../request.js';
-import { entraGroup } from '../../../../utils/entraGroup.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
+import { teams } from '../../../../utils/teams.js';
 class TeamsTeamGetCommand extends GraphCommand {
     get name() {
         return commands.TEAM_GET;
@@ -25,28 +25,23 @@ class TeamsTeamGetCommand extends GraphCommand {
         __classPrivateFieldGet(this, _TeamsTeamGetCommand_instances, "m", _TeamsTeamGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _TeamsTeamGetCommand_instances, "m", _TeamsTeamGetCommand_initOptionSets).call(this);
     }
-    async getTeamId(args) {
-        if (args.options.id) {
-            return args.options.id;
-        }
-        const group = await entraGroup.getGroupByDisplayName(args.options.name);
-        if (group.resourceProvisioningOptions.indexOf('Team') === -1) {
-            throw 'The specified team does not exist in the Microsoft Teams';
-        }
-        return group.id;
-    }
     async commandAction(logger, args) {
         try {
-            const teamId = await this.getTeamId(args);
-            const requestOptions = {
-                url: `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(teamId)}`,
-                headers: {
-                    accept: 'application/json;odata.metadata=none'
-                },
-                responseType: 'json'
-            };
-            const res = await request.get(requestOptions);
-            await logger.log(res);
+            let team;
+            if (args.options.id) {
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/teams/${formatting.encodeQueryParameter(args.options.id)}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                team = await request.get(requestOptions);
+            }
+            else {
+                team = await teams.getTeamByDisplayName(args.options.name);
+            }
+            await logger.log(team);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);

package/dist/m365/teams/commands.js

@@ -32,6 +32,7 @@ export default {
     MEETING_LIST: `${prefix} meeting list`,
     MEETING_ATTENDANCEREPORT_GET: `${prefix} meeting attendancereport get`,
     MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
+    MEETING_TRANSCRIPT_GET: `${prefix} meeting transcript get`,
     MEETING_TRANSCRIPT_LIST: `${prefix} meeting transcript list`,
     MEMBERSETTINGS_LIST: `${prefix} membersettings list`,
     MEMBERSETTINGS_SET: `${prefix} membersettings set`,

package/dist/m365/viva/commands/engage/Community.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Community.js.map

package/dist/m365/viva/commands/engage/engage-community-list.js

@@ -0,0 +1,28 @@
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class VivaEngageCommunityListCommand extends GraphCommand {
+    get name() {
+        return commands.ENGAGE_COMMUNITY_LIST;
+    }
+    get description() {
+        return 'Lists all Viva Engage communities';
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'privacy'];
+    }
+    async commandAction(logger) {
+        if (this.verbose) {
+            await logger.logToStderr('Getting all Viva Engage communities...');
+        }
+        try {
+            const results = await odata.getAllItems(`${this.resource}/v1.0/employeeExperience/communities`);
+            await logger.log(results);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new VivaEngageCommunityListCommand();
+//# sourceMappingURL=engage-community-list.js.map

package/dist/m365/viva/commands/engage/engage-community-user-list.js

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import { zod } from '../../../../utils/zod.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { validation } from '../../../../utils/validation.js';
+import { vivaEngage } from '../../../../utils/vivaEngage.js';
+import { odata } from '../../../../utils/odata.js';
+const options = globalOptionsZod
+    .extend({
+    communityId: z.string().optional(),
+    communityDisplayName: zod.alias('n', z.string().optional()),
+    entraGroupId: z.string()
+        .refine(name => validation.isValidGuid(name), name => ({
+        message: `'${name}' is not a valid GUID.`
+    })).optional(),
+    role: zod.alias('r', z.enum(['Admin', 'Member']).optional())
+})
+    .strict();
+class VivaEngageCommunityUserListCommand extends GraphCommand {
+    get name() {
+        return commands.ENGAGE_COMMUNITY_USER_LIST;
+    }
+    get description() {
+        return 'Lists all users within a specified Microsoft 365 Viva Engage community';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => [options.communityId, options.communityDisplayName, options.entraGroupId].filter(x => x !== undefined).length === 1, {
+            message: 'Specify either communityId, communityDisplayName, or entraGroupId, but not multiple.'
+        })
+            .refine(options => options.communityId || options.communityDisplayName || options.entraGroupId, {
+            message: 'Specify at least one of communityId, communityDisplayName, or entraGroupId.'
+        });
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'userPrincipalName', 'roles'];
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr('Getting list of users in community...');
+            }
+            let entraGroupId = args.options.entraGroupId;
+            if (args.options.communityDisplayName) {
+                const community = await vivaEngage.getCommunityByDisplayName(args.options.communityDisplayName, ['groupId']);
+                entraGroupId = community.groupId;
+            }
+            if (args.options.communityId) {
+                const community = await vivaEngage.getCommunityById(args.options.communityId, ['groupId']);
+                entraGroupId = community.groupId;
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/groups/${entraGroupId}/members`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const members = await odata.getAllItems(requestOptions);
+            requestOptions.url = `${this.resource}/v1.0/groups/${entraGroupId}/owners`;
+            const owners = await odata.getAllItems(requestOptions);
+            const extendedMembers = members.map(m => {
+                return {
+                    ...m,
+                    roles: ['Member']
+                };
+            });
+            const extendedOwners = owners.map(o => {
+                return {
+                    ...o,
+                    roles: ['Admin']
+                };
+            });
+            let users = [];
+            if (args.options.role) {
+                if (args.options.role === 'Member') {
+                    users = users.concat(extendedMembers);
+                }
+                if (args.options.role === 'Admin') {
+                    users = users.concat(extendedOwners);
+                }
+            }
+            else {
+                users = extendedOwners.concat(extendedMembers);
+            }
+            await logger.log(users);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new VivaEngageCommunityUserListCommand();
+//# sourceMappingURL=engage-community-user-list.js.map

package/dist/m365/viva/commands.js

@@ -3,6 +3,8 @@ export default {
     CONNECTIONS_APP_CREATE: `${prefix} connections app create`,
     ENGAGE_COMMUNITY_ADD: `${prefix} engage community add`,
     ENGAGE_COMMUNITY_GET: `${prefix} engage community get`,
+    ENGAGE_COMMUNITY_LIST: `${prefix} engage community list`,
+    ENGAGE_COMMUNITY_USER_LIST: `${prefix} engage community user list`,
     ENGAGE_GROUP_LIST: `${prefix} engage group list`,
     ENGAGE_GROUP_USER_ADD: `${prefix} engage group user add`,
     ENGAGE_GROUP_USER_REMOVE: `${prefix} engage group user remove`,

package/dist/request.js

@@ -4,6 +4,7 @@ import auth, { Auth } from './Auth.js';
 import { app } from './utils/app.js';
 import { formatting } from './utils/formatting.js';
 import { timings } from './cli/timings.js';
+import { timersUtil } from './utils/timersUtil.js';
 class Request {
     set debug(debug) {
         // if the value to set is the same as current value return early to avoid
@@ -125,76 +126,60 @@ class Request {
         options.method = 'HEAD';
         return this.execute(options);
     }
-    execute(options, resolve, reject) {
+    async execute(options) {
         const start = process.hrtime.bigint();
         if (!this._logger) {
-            return Promise.reject('Logger not set on the request object');
+            throw 'Logger not set on the request object';
         }
         this.updateRequestForCloudType(options, auth.connection.cloudType);
-        return new Promise((_resolve, _reject) => {
-            (() => {
-                if (options.headers && options.headers['x-anonymous']) {
-                    return Promise.resolve('');
-                }
-                else {
-                    const url = options.headers && options.headers['x-resource'] ? options.headers['x-resource'] : options.url;
-                    const resource = Auth.getResourceFromUrl(url);
-                    return auth.ensureAccessToken(resource, this._logger, this._debug);
-                }
-            })()
-                .then((accessToken) => {
-                if (options.headers) {
-                    if (options.headers['x-anonymous']) {
-                        delete options.headers['x-anonymous'];
-                    }
-                    if (options.headers['x-resource']) {
-                        delete options.headers['x-resource'];
-                    }
-                    if (accessToken !== '') {
-                        options.headers.authorization = `Bearer ${accessToken}`;
-                    }
-                }
-                const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
-                if (proxyUrl) {
-                    options.proxy = this.createProxyConfigFromUrl(proxyUrl);
+        try {
+            let accessToken = '';
+            if (options.headers && options.headers['x-anonymous']) {
+                accessToken = '';
+            }
+            else {
+                const url = options.headers && options.headers['x-resource'] ? options.headers['x-resource'] : options.url;
+                const resource = Auth.getResourceFromUrl(url);
+                accessToken = await auth.ensureAccessToken(resource, this._logger, this._debug);
+            }
+            if (options.headers) {
+                if (options.headers['x-anonymous']) {
+                    delete options.headers['x-anonymous'];
                 }
-                return this.req(options);
-            })
-                .then((res) => {
-                if (resolve) {
-                    resolve((options.responseType === 'stream' || options.fullResponse) ? res : res.data);
+                if (options.headers['x-resource']) {
+                    delete options.headers['x-resource'];
                 }
-                else {
-                    const end = process.hrtime.bigint();
-                    timings.api.push(Number(end - start));
-                    _resolve((options.responseType === 'stream' || options.fullResponse) ? res : res.data);
+                if (accessToken !== '') {
+                    options.headers.authorization = `Bearer ${accessToken}`;
                 }
-            }, async (error) => {
-                if (error && error.response &&
-                    (error.response.status === 429 ||
-                        error.response.status === 503)) {
-                    let retryAfter = parseInt(error.response.headers['retry-after'] || '10');
-                    if (isNaN(retryAfter)) {
-                        retryAfter = 10;
-                    }
-                    if (this._debug) {
-                        await this._logger.log(`Request throttled. Waiting ${retryAfter}sec before retrying...`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    setTimeout(async () => { this.execute(options, resolve || _resolve, reject || _reject); }, retryAfter * 1000);
+            }
+            const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
+            if (proxyUrl) {
+                options.proxy = this.createProxyConfigFromUrl(proxyUrl);
+            }
+            const res = await this.req(options);
+            const end = process.hrtime.bigint();
+            timings.api.push(Number(end - start));
+            return options.responseType === 'stream' || options.fullResponse ?
+                res :
+                res.data;
+        }
+        catch (error) {
+            const end = process.hrtime.bigint();
+            timings.api.push(Number(end - start));
+            if (error && error.response && (error.response.status === 429 || error.response.status === 503)) {
+                let retryAfter = parseInt(error.response.headers['retry-after'] || '10');
+                if (isNaN(retryAfter)) {
+                    retryAfter = 10;
                 }
-                else {
-                    if (reject) {
-                        reject(error);
-                    }
-                    else {
-                        const end = process.hrtime.bigint();
-                        timings.api.push(Number(end - start));
-                        _reject(error);
-                    }
+                if (this._debug) {
+                    await this._logger.log(`Request throttled. Waiting ${retryAfter} sec before retrying...`);
                 }
-            });
-        });
+                await timersUtil.setTimeout(retryAfter * 1000);
+                return this.execute(options);
+            }
+            throw error;
+        }
     }
     updateRequestForCloudType(options, cloudType) {
         const url = new URL(options.url);

package/dist/telemetryRunner.js

@@ -8,7 +8,7 @@ try {
     const data = JSON.parse(input);
     const { commandName, properties, exception, shell, session } = data;
     appInsights.commonProperties.shell = shell;
-    appInsights.context.tags['ai.session.id'] = session;
+    appInsights.context.tags[appInsights.context.keys.sessionId] = session;
     if (exception) {
         appInsights.trackException({
             exception
@@ -20,7 +20,7 @@ try {
             properties
         });
     }
-    appInsights.flush();
+    await appInsights.flush();
 }
 catch { }
 //# sourceMappingURL=telemetryRunner.js.map