@pnp/cli-microsoft365 7.5.0 → 7.6.0-beta.480812d

package/dist/m365/entra/commands/user/user-remove.js

@@ -29,6 +29,7 @@ class EntraUserRemoveCommand extends GraphCommand {
         __classPrivateFieldGet(this, _EntraUserRemoveCommand_instances, "m", _EntraUserRemoveCommand_initOptionSets).call(this);
     }
     async commandAction(logger, args) {
+        await this.showDeprecationWarning(logger, aadCommands.USER_REMOVE, commands.USER_REMOVE);
         if (this.verbose) {
             await logger.logToStderr(`Removing user '${args.options.id || args.options.userName}'...`);
         }

package/dist/m365/entra/commands/user/user-set.js

@@ -35,6 +35,7 @@ class EntraUserSetCommand extends GraphCommand {
         __classPrivateFieldGet(this, _EntraUserSetCommand_instances, "m", _EntraUserSetCommand_initOptionSets).call(this);
     }
     async commandAction(logger, args) {
+        await this.showDeprecationWarning(logger, aadCommands.USER_SET, commands.USER_SET);
         try {
             if (args.options.currentPassword) {
                 if (args.options.id && args.options.id !== accessToken.getUserIdFromAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken)) {

package/dist/m365/entra/commands/user/user-signin-list.js

@@ -31,6 +31,7 @@ class EntraUserSigninListCommand extends GraphCommand {
         return ['id', 'userPrincipalName', 'appId', 'appDisplayName', 'createdDateTime'];
     }
     async commandAction(logger, args) {
+        await this.showDeprecationWarning(logger, aadCommands.USER_SIGNIN_LIST, commands.USER_SIGNIN_LIST);
         try {
             let endpoint = `${this.resource}/v1.0/auditLogs/signIns`;
             let filter = "";

package/dist/m365/outlook/commands/message/message-remove.js

@@ -0,0 +1,113 @@
+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 _OutlookMessageRemoveCommand_instances, _OutlookMessageRemoveCommand_initTelemetry, _OutlookMessageRemoveCommand_initOptions, _OutlookMessageRemoveCommand_initValidators, _OutlookMessageRemoveCommand_initTypes;
+import auth from '../../../../Auth.js';
+import request from '../../../../request.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { cli } from '../../../../cli/cli.js';
+import { validation } from '../../../../utils/validation.js';
+import { formatting } from '../../../../utils/formatting.js';
+class OutlookMessageRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.MESSAGE_REMOVE;
+    }
+    get description() {
+        return 'Permanently removes a specific message from a mailbox';
+    }
+    constructor() {
+        super();
+        _OutlookMessageRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _OutlookMessageRemoveCommand_instances, "m", _OutlookMessageRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+        let principalUrl = '';
+        if (isAppOnlyAccessToken) {
+            if (!args.options.userId && !args.options.userName) {
+                throw `The option 'userId' or 'userName' is required when removing a message using application permissions.`;
+            }
+            if (args.options.userId && args.options.userName) {
+                throw `Both options 'userId' and 'userName' cannot be used together when removing a message using application permissions.`;
+            }
+        }
+        else {
+            if (args.options.userId && args.options.userName) {
+                throw `Both options 'userId' and 'userName' cannot be used together when removing a message using delegated permissions.`;
+            }
+        }
+        if (args.options.userId || args.options.userName) {
+            principalUrl += `users/${args.options.userId || formatting.encodeQueryParameter(args.options.userName)}`;
+        }
+        else {
+            principalUrl += 'me';
+        }
+        const removeMessage = async () => {
+            try {
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing message with id '${args.options.id}' using ${isAppOnlyAccessToken ? 'application' : 'delegated'} permissions.`);
+                }
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/${principalUrl}/messages/${args.options.id}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    }
+                };
+                await request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeMessage();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove message with id '${args.options.id}'?` });
+            if (result) {
+                await removeMessage();
+            }
+        }
+    }
+}
+_OutlookMessageRemoveCommand_instances = new WeakSet(), _OutlookMessageRemoveCommand_initTelemetry = function _OutlookMessageRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _OutlookMessageRemoveCommand_initOptions = function _OutlookMessageRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id <id>'
+    }, {
+        option: '--userId [userId]'
+    }, {
+        option: '--userName [userName]'
+    }, {
+        option: '-f, --force'
+    });
+}, _OutlookMessageRemoveCommand_initValidators = function _OutlookMessageRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `Value '${args.options.userId}' is not a valid GUID for option 'userId'.`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `Value '${args.options.userName}' is not a valid user principal name for option 'userName'.`;
+        }
+        return true;
+    });
+}, _OutlookMessageRemoveCommand_initTypes = function _OutlookMessageRemoveCommand_initTypes() {
+    this.types.string.push('id', 'userId', 'userName');
+    this.types.boolean.push('force');
+};
+export default new OutlookMessageRemoveCommand();
+//# sourceMappingURL=message-remove.js.map

package/dist/m365/outlook/commands.js

@@ -4,6 +4,7 @@ export default {
     MESSAGE_GET: `${prefix} message get`,
     MESSAGE_LIST: `${prefix} message list`,
     MESSAGE_MOVE: `${prefix} message move`,
+    MESSAGE_REMOVE: `${prefix} message remove`,
     REPORT_MAILACTIVITYCOUNTS: `${prefix} report mailactivitycounts`,
     REPORT_MAILACTIVITYUSERCOUNTS: `${prefix} report mailactivityusercounts`,
     REPORT_MAILACTIVITYUSERDETAIL: `${prefix} report mailactivityuserdetail`,

package/dist/m365/pp/commands/managementapp/managementapp-add.js

@@ -58,16 +58,16 @@ class PpManagementAppAddCommand extends PowerPlatformCommand {
             },
             responseType: 'json'
         };
-        const aadApps = await request.get((requestOptions));
-        if (aadApps.value.length === 0) {
+        const entraApps = await request.get((requestOptions));
+        if (entraApps.value.length === 0) {
             const applicationIdentifier = objectId ? `ID ${objectId}` : `name ${name}`;
-            throw `No Azure AD application registration with ${applicationIdentifier} found`;
+            throw `No Microsoft Entra application registration with ${applicationIdentifier} found`;
         }
-        if (aadApps.value.length === 1 && aadApps.value[0].appId) {
-            return aadApps.value[0].appId;
+        if (entraApps.value.length === 1 && entraApps.value[0].appId) {
+            return entraApps.value[0].appId;
         }
-        const resultAsKeyValuePair = formatting.convertArrayToHashTable('appId', aadApps.value);
-        const result = await cli.handleMultipleResultsFound(`Multiple Azure AD application registration with name '${name}' found.`, resultAsKeyValuePair);
+        const resultAsKeyValuePair = formatting.convertArrayToHashTable('appId', entraApps.value);
+        const result = await cli.handleMultipleResultsFound(`Multiple Microsoft Entra application registrations with name '${name}' found.`, resultAsKeyValuePair);
         return result.appId;
     }
 }

package/dist/m365/purview/commands/threatassessment/threatassessment-add.js

@@ -0,0 +1,123 @@
+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 _PurviewThreatAssessmentAddCommand_instances, _PurviewThreatAssessmentAddCommand_initTelemetry, _PurviewThreatAssessmentAddCommand_initOptions, _PurviewThreatAssessmentAddCommand_initValidators, _PurviewThreatAssessmentAddCommand_initOptionSets;
+import request from '../../../../request.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import auth from '../../../../Auth.js';
+import fs from 'fs';
+import path from 'path';
+class PurviewThreatAssessmentAddCommand extends GraphCommand {
+    get name() {
+        return commands.THREATASSESSMENT_ADD;
+    }
+    get description() {
+        return 'Create a threat assessment';
+    }
+    constructor() {
+        super();
+        _PurviewThreatAssessmentAddCommand_instances.add(this);
+        this.allowedTypes = ['file', 'url'];
+        this.allowedExpectedAssessments = ['block', 'unblock'];
+        this.allowedCategories = ['spam', 'phishing', 'malware'];
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentAddCommand_instances, "m", _PurviewThreatAssessmentAddCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[this.resource].accessToken)) {
+                throw 'This command currently does not support app only permissions.';
+            }
+            if (this.verbose) {
+                await logger.logToStderr(`Adding threat assessment of type ${args.options.type} with expected assessment ${args.options.expectedAssessment} and category ${args.options.category}`);
+            }
+            const requestBody = {
+                expectedAssessment: args.options.expectedAssessment,
+                category: args.options.category,
+                url: args.options.url,
+                contentData: args.options.path && fs.readFileSync(args.options.path).toString('base64'),
+                fileName: args.options.path && path.basename(args.options.path)
+            };
+            switch (args.options.type) {
+                case 'file':
+                    requestBody['@odata.type'] = '#microsoft.graph.fileAssessmentRequest';
+                    break;
+                case 'url':
+                    requestBody['@odata.type'] = '#microsoft.graph.urlAssessmentRequest';
+                    break;
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/informationProtection/threatAssessmentRequests`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                data: requestBody,
+                responseType: 'json'
+            };
+            const response = await request.post(requestOptions);
+            await logger.log(response);
+        }
+        catch (err) {
+            this.handleRejectedODataPromise(err);
+        }
+    }
+}
+_PurviewThreatAssessmentAddCommand_instances = new WeakSet(), _PurviewThreatAssessmentAddCommand_initTelemetry = function _PurviewThreatAssessmentAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            path: typeof args.options.path !== 'undefined',
+            url: typeof args.options.url !== 'undefined'
+        });
+    });
+}, _PurviewThreatAssessmentAddCommand_initOptions = function _PurviewThreatAssessmentAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-t, --type <type>',
+        autocomplete: this.allowedTypes
+    }, {
+        option: '-e, --expectedAssessment <expectedAssessment>',
+        autocomplete: this.allowedExpectedAssessments
+    }, {
+        option: '-c, --category <category>',
+        autocomplete: this.allowedCategories
+    }, {
+        option: '-p, --path [path]'
+    }, {
+        option: '-u, --url [url]'
+    });
+}, _PurviewThreatAssessmentAddCommand_initValidators = function _PurviewThreatAssessmentAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (!this.allowedTypes.some(type => type === args.options.type)) {
+            return `${args.options.type} is not an allowed type. Allowed types are ${this.allowedTypes.join('|')}`;
+        }
+        if (!this.allowedExpectedAssessments.some(expectedAssessment => expectedAssessment === args.options.expectedAssessment)) {
+            return `${args.options.expectedAssessment} is not an allowed expected assessment. Allowed expected assessments are ${this.allowedExpectedAssessments.join('|')}`;
+        }
+        if (!this.allowedCategories.some(category => category === args.options.category)) {
+            return `${args.options.category} is not an allowed category. Allowed categories are ${this.allowedCategories.join('|')}`;
+        }
+        if (args.options.path && !fs.existsSync(args.options.path)) {
+            return `File '${args.options.path}' not found. Please provide a valid path to the file.`;
+        }
+        return true;
+    });
+}, _PurviewThreatAssessmentAddCommand_initOptionSets = function _PurviewThreatAssessmentAddCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['path'],
+        runsWhen: (args) => {
+            return args.options.type === 'file';
+        }
+    }, {
+        options: ['url'],
+        runsWhen: (args) => {
+            return args.options.type === 'url';
+        }
+    });
+};
+export default new PurviewThreatAssessmentAddCommand();
+//# sourceMappingURL=threatassessment-add.js.map

package/dist/m365/purview/commands/threatassessment/threatassessment-list.js

@@ -0,0 +1,104 @@
+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 _PurviewThreatAssessmentListCommand_instances, _a, _PurviewThreatAssessmentListCommand_initTelemetry, _PurviewThreatAssessmentListCommand_initOptions, _PurviewThreatAssessmentListCommand_initValidators;
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class PurviewThreatAssessmentListCommand extends GraphCommand {
+    get name() {
+        return commands.THREATASSESSMENT_LIST;
+    }
+    get description() {
+        return 'Get a list of threat assessments';
+    }
+    defaultProperties() {
+        return ['id', 'type', 'category'];
+    }
+    constructor() {
+        super();
+        _PurviewThreatAssessmentListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentListCommand_instances, "m", _PurviewThreatAssessmentListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentListCommand_instances, "m", _PurviewThreatAssessmentListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _PurviewThreatAssessmentListCommand_instances, "m", _PurviewThreatAssessmentListCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        if (this.verbose) {
+            logger.logToStderr('Retrieving a list of threat assessments');
+        }
+        try {
+            const filter = this.getFilterQuery(args.options);
+            const items = await odata.getAllItems(`${this.resource}/v1.0/informationProtection/threatAssessmentRequests${filter}`, 'minimal');
+            let itemsToReturn = [];
+            switch (args.options.type) {
+                case 'mail':
+                    itemsToReturn = items.filter(item => item['@odata.type'] === '#microsoft.graph.mailAssessmentRequest');
+                    break;
+                case 'emailFile':
+                    itemsToReturn = items.filter(item => item['@odata.type'] === '#microsoft.graph.emailFileAssessmentRequest');
+                    break;
+                default:
+                    itemsToReturn = items;
+                    break;
+            }
+            for (const item of itemsToReturn) {
+                item['type'] = this.getConvertedType(item['@odata.type']);
+                delete item['@odata.type'];
+            }
+            await logger.log(itemsToReturn);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    // Content type is not equal to type. 
+    // Threat assessments of type emailFile have contentType mail as well.
+    // This function gets the correct filter URL to be able to query the least amount of data
+    getFilterQuery(options) {
+        if (options.type === undefined) {
+            return '';
+        }
+        if (options.type === 'emailFile') {
+            return `?$filter=contentType eq 'mail'`;
+        }
+        return `?$filter=contentType eq '${options.type}'`;
+    }
+    getConvertedType(type) {
+        switch (type) {
+            case '#microsoft.graph.mailAssessmentRequest':
+                return 'mail';
+            case '#microsoft.graph.fileAssessmentRequest':
+                return 'file';
+            case '#microsoft.graph.emailFileAssessmentRequest':
+                return 'emailFile';
+            case '#microsoft.graph.urlAssessmentRequest':
+                return 'url';
+            default:
+                return 'Unknown';
+        }
+    }
+}
+_a = PurviewThreatAssessmentListCommand, _PurviewThreatAssessmentListCommand_instances = new WeakSet(), _PurviewThreatAssessmentListCommand_initTelemetry = function _PurviewThreatAssessmentListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            type: typeof args.options.type !== 'undefined'
+        });
+    });
+}, _PurviewThreatAssessmentListCommand_initOptions = function _PurviewThreatAssessmentListCommand_initOptions() {
+    this.options.unshift({
+        option: '-t, --type [type]',
+        autocomplete: _a.allowedTypes
+    });
+}, _PurviewThreatAssessmentListCommand_initValidators = function _PurviewThreatAssessmentListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.type && _a.allowedTypes.indexOf(args.options.type) < 0) {
+            return `${args.options.type} is not a valid type. Allowed values are ${_a.allowedTypes.join(', ')}`;
+        }
+        return true;
+    });
+};
+PurviewThreatAssessmentListCommand.allowedTypes = ['mail', 'file', 'emailFile', 'url'];
+export default new PurviewThreatAssessmentListCommand();
+//# sourceMappingURL=threatassessment-list.js.map

package/dist/m365/purview/commands.js

@@ -18,6 +18,8 @@ export default {
     SENSITIVITYLABEL_GET: `${prefix} sensitivitylabel get`,
     SENSITIVITYLABEL_LIST: `${prefix} sensitivitylabel list`,
     SENSITIVITYLABEL_POLICYSETTINGS_LIST: `${prefix} sensitivitylabel policysettings list`,
-    THREATASSESSMENT_GET: `${prefix} threatassessment get`
+    THREATASSESSMENT_ADD: `${prefix} threatassessment add`,
+    THREATASSESSMENT_GET: `${prefix} threatassessment get`,
+    THREATASSESSMENT_LIST: `${prefix} threatassessment list`
 };
 //# sourceMappingURL=commands.js.map

package/dist/m365/spfx/commands/project/DeployWorkflow.js

@@ -53,4 +53,115 @@ export const workflow = {
         }
     }
 };
+export const pipeline = {
+    name: "Deploy Solution",
+    trigger: {
+        branches: {
+            include: [
+                "main"
+            ]
+        }
+    },
+    pool: {
+        vmImage: "ubuntu-latest"
+    },
+    variables: [
+        {
+            name: "CertificateBase64Encoded",
+            value: ""
+        },
+        {
+            name: "CertificateSecureFileId",
+            value: ""
+        },
+        {
+            name: "CertificatePassword",
+            value: ""
+        },
+        {
+            name: "EntraAppId",
+            value: ""
+        },
+        {
+            name: "UserName",
+            value: ""
+        },
+        {
+            name: "Password",
+            value: ""
+        },
+        {
+            name: "TenantId",
+            value: ""
+        },
+        {
+            name: "SharePointBaseUrl",
+            value: ""
+        },
+        {
+            name: "PackageName",
+            value: ""
+        },
+        {
+            name: "SiteAppCatalogUrl",
+            value: ""
+        }
+    ],
+    stages: [
+        {
+            stage: "Build_and_Deploy",
+            jobs: [
+                {
+                    job: "Build_and_Deploy",
+                    steps: [
+                        {
+                            task: "NodeTool@0",
+                            displayName: "Use Node.js",
+                            inputs: {
+                                versionSpec: "18.x"
+                            }
+                        },
+                        {
+                            task: "Npm@1",
+                            displayName: "Run npm install",
+                            inputs: {
+                                command: "install"
+                            }
+                        },
+                        {
+                            task: "Gulp@0",
+                            displayName: "Gulp bundle",
+                            inputs: {
+                                gulpFile: "./gulpfile.js",
+                                targets: "bundle",
+                                arguments: "--ship"
+                            }
+                        },
+                        {
+                            task: "Gulp@0",
+                            displayName: "Gulp package",
+                            inputs: {
+                                targets: "package-solution",
+                                arguments: "--ship"
+                            }
+                        },
+                        {
+                            task: "Npm@1",
+                            displayName: "Install CLI for Microsoft 365",
+                            inputs: {
+                                command: "custom",
+                                verbose: false,
+                                customCommand: "install -g @pnp/cli-microsoft365"
+                            }
+                        },
+                        {
+                            script: "\n{{login}} \nm365 spo set --url '$(SharePointBaseUrl)' \n{{addApp}} \n{{deploy}}\n",
+                            displayName: "CLI for Microsoft 365 Deploy App"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+};
 //# sourceMappingURL=DeployWorkflow.js.map