@pnp/cli-microsoft365 7.7.0-beta.d874bca → 7.8.0-beta.3152fc7

package/dist/m365/spfx/commands/spfx-doctor.js

@@ -19,14 +19,6 @@ var PackageSearchMode;
     PackageSearchMode[PackageSearchMode["GlobalOnly"] = 1] = "GlobalOnly";
     PackageSearchMode[PackageSearchMode["LocalAndGlobal"] = 2] = "LocalAndGlobal";
 })(PackageSearchMode || (PackageSearchMode = {}));
-/**
- * Is the particular check optional or required
- */
-var OptionalOrRequired;
-(function (OptionalOrRequired) {
-    OptionalOrRequired[OptionalOrRequired["Optional"] = 0] = "Optional";
-    OptionalOrRequired[OptionalOrRequired["Required"] = 1] = "Required";
-})(OptionalOrRequired || (OptionalOrRequired = {}));
 /**
  * Should the method continue or fail on a rejected Promise
  */
@@ -47,7 +39,7 @@ var SharePointVersion;
 })(SharePointVersion || (SharePointVersion = {}));
 class SpfxDoctorCommand extends BaseProjectCommand {
     get allowedOutputs() {
-        return ['text'];
+        return ['text', 'json'];
     }
     get name() {
         return commands.DOCTOR;
@@ -585,6 +577,8 @@ class SpfxDoctorCommand extends BaseProjectCommand {
                 }
             }
         };
+        this.output = '';
+        this.resultsObject = [];
         __classPrivateFieldGet(this, _SpfxDoctorCommand_instances, "m", _SpfxDoctorCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpfxDoctorCommand_instances, "m", _SpfxDoctorCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpfxDoctorCommand_instances, "m", _SpfxDoctorCommand_initValidators).call(this);
@@ -593,168 +587,265 @@ class SpfxDoctorCommand extends BaseProjectCommand {
         if (!args.options.output) {
             args.options.output = 'text';
         }
+        this.output = args.options.output;
         this.projectRootPath = this.getProjectRoot(process.cwd());
-        await logger.log(' ');
-        await logger.log('CLI for Microsoft 365 SharePoint Framework doctor');
-        await logger.log('Verifying configuration of your system for working with the SharePoint Framework');
-        await logger.log(' ');
+        this.logger = logger;
+        await this.logMessage(' ');
+        await this.logMessage('CLI for Microsoft 365 SharePoint Framework doctor');
+        await this.logMessage('Verifying configuration of your system for working with the SharePoint Framework');
+        await this.logMessage(' ');
         let spfxVersion = '';
         let prerequisites;
-        const fixes = [];
         try {
-            spfxVersion = args.options.spfxVersion ?? await this.getSharePointFrameworkVersion(logger);
+            spfxVersion = args.options.spfxVersion ?? await this.getSharePointFrameworkVersion();
             if (!spfxVersion) {
-                await logger.log(formatting.getStatus(CheckStatus.Failure, `SharePoint Framework`));
+                await this.logMessage(formatting.getStatus(CheckStatus.Failure, `SharePoint Framework`));
+                this.resultsObject.push({
+                    check: 'SharePoint Framework',
+                    passed: false,
+                    message: `SharePoint Framework not found`
+                });
                 throw `SharePoint Framework not found`;
             }
             prerequisites = this.versions[spfxVersion];
             if (!prerequisites) {
-                await logger.log(formatting.getStatus(CheckStatus.Failure, `SharePoint Framework v${spfxVersion}`));
-                throw `spfx doctor doesn't support SPFx v${spfxVersion} at this moment`;
+                const message = `spfx doctor doesn't support SPFx v${spfxVersion} at this moment`;
+                this.resultsObject.push({
+                    check: 'SharePoint Framework',
+                    passed: true,
+                    version: spfxVersion,
+                    message: message
+                });
+                await this.logMessage(formatting.getStatus(CheckStatus.Failure, `SharePoint Framework v${spfxVersion}`));
+                throw message;
+            }
+            else {
+                this.resultsObject.push({
+                    check: 'SharePoint Framework',
+                    passed: true,
+                    version: spfxVersion,
+                    message: `SharePoint Framework v${spfxVersion} valid.`
+                });
             }
             if (args.options.spfxVersion) {
-                await this.checkSharePointFrameworkVersion(args.options.spfxVersion, fixes, logger);
+                await this.checkSharePointFrameworkVersion(args.options.spfxVersion);
             }
             else {
                 // spfx was detected and if we are here, it means that we support it
-                await logger.log(formatting.getStatus(CheckStatus.Success, `SharePoint Framework v${spfxVersion}`));
+                const message = `SharePoint Framework v${spfxVersion}`;
+                this.resultsObject.push({
+                    check: 'SharePoint Framework',
+                    passed: true,
+                    version: spfxVersion,
+                    message: message
+                });
+                await this.logMessage(formatting.getStatus(CheckStatus.Success, message));
             }
-            await this.checkSharePointCompatibility(spfxVersion, prerequisites, args, fixes, logger);
-            await this.checkNodeVersion(prerequisites, fixes, logger);
-            await this.checkYo(prerequisites, fixes, logger);
-            await this.checkGulp(fixes, logger);
-            await this.checkGulpCli(prerequisites, fixes, logger);
-            await this.checkTypeScript(fixes, logger);
-            if (fixes.length > 0) {
-                await logger.log(' ');
-                await logger.log('Recommended fixes:');
-                await logger.log(' ');
-                for (const f of fixes) {
-                    await logger.log(`- ${f}`);
-                }
-                await logger.log(' ');
+            await this.checkSharePointCompatibility(spfxVersion, prerequisites, args);
+            await this.checkNodeVersion(prerequisites);
+            await this.checkYo(prerequisites);
+            await this.checkGulp();
+            await this.checkGulpCli(prerequisites);
+            await this.checkTypeScript();
+            if (this.resultsObject.some(y => y.fix !== undefined)) {
+                await this.logMessage('Recommended fixes:');
+                await this.logMessage(' ');
+                for (const f of this.resultsObject.filter(y => y.fix !== undefined)) {
+                    await this.logMessage(`- ${f.fix}`);
+                }
+                await this.logMessage(' ');
             }
         }
         catch (err) {
-            await logger.log(' ');
-            if (fixes.length > 0) {
-                await logger.log('Recommended fixes:');
-                await logger.log(' ');
-                for (const f of fixes) {
-                    await logger.log(`- ${f}`);
-                }
-                await logger.log(' ');
+            await this.logMessage(' ');
+            if (this.resultsObject.some(y => y.fix !== undefined)) {
+                await this.logMessage('Recommended fixes:');
+                await this.logMessage(' ');
+                for (const f of this.resultsObject.filter(y => y.fix !== undefined)) {
+                    await this.logMessage(`- ${f.fix}`);
+                }
+                await this.logMessage(' ');
+            }
+            if (this.output === 'text') {
+                this.handleRejectedPromise(err);
             }
-            this.handleRejectedPromise(err);
+        }
+        finally {
+            if (args.options.output === 'json' && this.resultsObject.length > 0) {
+                await logger.log(this.resultsObject);
+            }
+        }
+    }
+    async logMessage(message) {
+        if (this.output === 'json') {
+            await this.logger.logToStderr(message);
+        }
+        else {
+            await this.logger.log(message);
         }
     }
-    async checkSharePointCompatibility(spfxVersion, prerequisites, args, fixes, logger) {
+    async checkSharePointCompatibility(spfxVersion, prerequisites, args) {
         if (args.options.env) {
             const sp = this.spVersionStringToEnum(args.options.env);
             if ((prerequisites.sp & sp) === sp) {
-                await logger.log(formatting.getStatus(CheckStatus.Success, `Supported in ${SharePointVersion[sp]}`));
+                const message = `Supported in ${SharePointVersion[sp]}`;
+                this.resultsObject.push({
+                    check: 'env',
+                    passed: true,
+                    message: message,
+                    version: args.options.env
+                });
+                await this.logMessage(formatting.getStatus(CheckStatus.Success, message));
                 return;
             }
-            await logger.log(formatting.getStatus(CheckStatus.Failure, `Not supported in ${SharePointVersion[sp]}`));
-            fixes.push(`Use SharePoint Framework v${(sp === SharePointVersion.SP2016 ? '1.1' : '1.4.1')}`);
+            const fix = `Use SharePoint Framework v${(sp === SharePointVersion.SP2016 ? '1.1' : '1.4.1')}`;
+            const message = `Not supported in ${SharePointVersion[sp]}`;
+            this.resultsObject.push({
+                check: 'env',
+                passed: false,
+                fix: fix,
+                message: message,
+                version: args.options.env
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
             throw `SharePoint Framework v${spfxVersion} is not supported in ${SharePointVersion[sp]}`;
         }
     }
-    async checkNodeVersion(prerequisites, fixes, logger) {
+    async checkNodeVersion(prerequisites) {
         const nodeVersion = this.getNodeVersion();
-        this.checkStatus('Node', nodeVersion, prerequisites.node, OptionalOrRequired.Required, fixes, logger);
+        this.checkStatus('Node', nodeVersion, prerequisites.node);
     }
-    async checkSharePointFrameworkVersion(spfxVersionRequested, fixes, logger) {
-        let spfxVersionDetected = await this.getSPFxVersionFromYoRcFile(logger);
+    async checkSharePointFrameworkVersion(spfxVersionRequested) {
+        let spfxVersionDetected = await this.getSPFxVersionFromYoRcFile();
         if (!spfxVersionDetected) {
-            spfxVersionDetected = await this.getPackageVersion('@microsoft/generator-sharepoint', PackageSearchMode.GlobalOnly, HandlePromise.Continue, logger);
+            spfxVersionDetected = await this.getPackageVersion('@microsoft/generator-sharepoint', PackageSearchMode.GlobalOnly, HandlePromise.Continue);
         }
         const versionCheck = {
             range: spfxVersionRequested,
             fix: `npm i -g @microsoft/generator-sharepoint@${spfxVersionRequested}`
         };
         if (spfxVersionDetected) {
-            this.checkStatus(`SharePoint Framework`, spfxVersionDetected, versionCheck, OptionalOrRequired.Required, fixes, logger);
+            this.checkStatus(`SharePoint Framework`, spfxVersionDetected, versionCheck);
         }
         else {
-            await logger.log(formatting.getStatus(CheckStatus.Failure, `SharePoint Framework v${spfxVersionRequested} not found`));
-            fixes.push(versionCheck.fix);
+            const message = `SharePoint Framework v${spfxVersionRequested} not found`;
+            this.resultsObject.push({
+                check: 'SharePoint Framework',
+                passed: false,
+                version: spfxVersionRequested,
+                message: message,
+                fix: versionCheck.fix
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
         }
     }
-    async checkYo(prerequisites, fixes, logger) {
-        const yoVersion = await this.getPackageVersion('yo', PackageSearchMode.GlobalOnly, HandlePromise.Continue, logger);
+    async checkYo(prerequisites) {
+        const yoVersion = await this.getPackageVersion('yo', PackageSearchMode.GlobalOnly, HandlePromise.Continue);
         if (yoVersion) {
-            this.checkStatus('yo', yoVersion, prerequisites.yo, OptionalOrRequired.Required, fixes, logger);
+            this.checkStatus('yo', yoVersion, prerequisites.yo);
         }
         else {
-            await logger.log(formatting.getStatus(CheckStatus.Failure, `yo not found`));
-            fixes.push(prerequisites.yo.fix);
+            const message = 'yo not found';
+            this.resultsObject.push({
+                check: 'yo',
+                passed: false,
+                message: message,
+                fix: prerequisites.yo.fix
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
         }
     }
-    async checkGulpCli(prerequisites, fixes, logger) {
-        const gulpCliVersion = await this.getPackageVersion('gulp-cli', PackageSearchMode.GlobalOnly, HandlePromise.Continue, logger);
+    async checkGulpCli(prerequisites) {
+        const gulpCliVersion = await this.getPackageVersion('gulp-cli', PackageSearchMode.GlobalOnly, HandlePromise.Continue);
         if (gulpCliVersion) {
-            this.checkStatus('gulp-cli', gulpCliVersion, prerequisites.gulpCli, OptionalOrRequired.Required, fixes, logger);
+            this.checkStatus('gulp-cli', gulpCliVersion, prerequisites.gulpCli);
         }
         else {
-            await logger.log(formatting.getStatus(CheckStatus.Failure, `gulp-cli not found`));
-            fixes.push(prerequisites.gulpCli.fix);
+            const message = 'gulp-cli not found';
+            this.resultsObject.push({
+                check: 'gulp-cli',
+                passed: false,
+                message: message,
+                fix: prerequisites.gulpCli.fix
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
         }
     }
-    async checkGulp(fixes, logger) {
-        const gulpVersion = await this.getPackageVersion('gulp', PackageSearchMode.GlobalOnly, HandlePromise.Continue, logger);
+    async checkGulp() {
+        const gulpVersion = await this.getPackageVersion('gulp', PackageSearchMode.GlobalOnly, HandlePromise.Continue);
         if (gulpVersion) {
-            await logger.log(formatting.getStatus(CheckStatus.Failure, `gulp should be removed`));
-            fixes.push('npm un -g gulp');
+            const message = 'gulp should be removed';
+            const fix = 'npm un -g gulp';
+            this.resultsObject.push({
+                check: 'gulp',
+                passed: false,
+                version: gulpVersion,
+                message: message,
+                fix: fix
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
         }
     }
-    async checkTypeScript(fixes, logger) {
-        const typeScriptVersion = await this.getPackageVersion('typescript', PackageSearchMode.LocalOnly, HandlePromise.Continue, logger);
+    async checkTypeScript() {
+        const typeScriptVersion = await this.getPackageVersion('typescript', PackageSearchMode.LocalOnly, HandlePromise.Continue);
         if (typeScriptVersion) {
-            await logger.log(formatting.getStatus(CheckStatus.Failure, `typescript v${typeScriptVersion} installed in the project`));
-            fixes.push('npm un typescript');
+            const fix = 'npm un typescript';
+            const message = `typescript v${typeScriptVersion} installed in the project`;
+            this.resultsObject.push({
+                check: 'typescript',
+                passed: false,
+                message: message,
+                fix: fix
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
         }
         else {
-            await logger.log(formatting.getStatus(CheckStatus.Success, `bundled typescript used`));
+            const message = 'bundled typescript used';
+            this.resultsObject.push({
+                check: 'typescript',
+                passed: true,
+                message: message
+            });
+            await this.logMessage(formatting.getStatus(CheckStatus.Success, message));
         }
     }
     spVersionStringToEnum(sp) {
         return SharePointVersion[sp.toUpperCase()];
     }
-    async getSPFxVersionFromYoRcFile(logger) {
+    async getSPFxVersionFromYoRcFile() {
         if (this.projectRootPath !== null) {
             const spfxVersion = this.getProjectVersion();
             if (spfxVersion) {
                 if (this.debug) {
-                    await logger.logToStderr(`SPFx version retrieved from .yo-rc.json file. Retrieved version: ${spfxVersion}`);
+                    await this.logger.logToStderr(`SPFx version retrieved from .yo-rc.json file. Retrieved version: ${spfxVersion}`);
                 }
                 return spfxVersion;
             }
         }
         return undefined;
     }
-    async getSharePointFrameworkVersion(logger) {
-        let spfxVersion = await this.getSPFxVersionFromYoRcFile(logger);
+    async getSharePointFrameworkVersion() {
+        let spfxVersion = await this.getSPFxVersionFromYoRcFile();
         if (spfxVersion) {
             return spfxVersion;
         }
         try {
-            spfxVersion = await this.getPackageVersion('@microsoft/sp-core-library', PackageSearchMode.LocalOnly, HandlePromise.Fail, logger);
+            spfxVersion = await this.getPackageVersion('@microsoft/sp-core-library', PackageSearchMode.LocalOnly, HandlePromise.Fail);
             if (this.debug) {
-                await logger.logToStderr(`Found @microsoft/sp-core-library@${spfxVersion}`);
+                await this.logger.logToStderr(`Found @microsoft/sp-core-library@${spfxVersion}`);
             }
             return spfxVersion;
         }
         catch {
             if (this.debug) {
-                await logger.logToStderr(`@microsoft/sp-core-library not found. Search for @microsoft/generator-sharepoint local or global...`);
+                await this.logger.logToStderr(`@microsoft/sp-core-library not found. Search for @microsoft/generator-sharepoint local or global...`);
             }
             try {
-                return await this.getPackageVersion('@microsoft/generator-sharepoint', PackageSearchMode.LocalAndGlobal, HandlePromise.Fail, logger);
+                return await this.getPackageVersion('@microsoft/generator-sharepoint', PackageSearchMode.LocalAndGlobal, HandlePromise.Fail);
             }
             catch (error) {
                 if (this.debug) {
-                    await logger.logToStderr('@microsoft/generator-sharepoint not found');
+                    await this.logger.logToStderr('@microsoft/generator-sharepoint not found');
                 }
                 if (error && error.indexOf('ENOENT') > -1) {
                     throw 'npm not found';
@@ -765,19 +856,19 @@ class SpfxDoctorCommand extends BaseProjectCommand {
             }
         }
     }
-    async getPackageVersion(packageName, searchMode, handlePromise, logger) {
+    async getPackageVersion(packageName, searchMode, handlePromise) {
         const args = ['ls', packageName, '--depth=0', '--json'];
         if (searchMode === PackageSearchMode.GlobalOnly) {
             args.push('-g');
         }
         let version;
         try {
-            version = await this.getPackageVersionFromNpm(args, logger);
+            version = await this.getPackageVersionFromNpm(args);
         }
         catch {
             if (searchMode === PackageSearchMode.LocalAndGlobal) {
                 args.push('-g');
-                version = await this.getPackageVersionFromNpm(args, logger);
+                version = await this.getPackageVersionFromNpm(args);
             }
             else {
                 version = '';
@@ -795,11 +886,11 @@ class SpfxDoctorCommand extends BaseProjectCommand {
             }
         }
     }
-    getPackageVersionFromNpm(args, logger) {
+    getPackageVersionFromNpm(args) {
         return new Promise(async (resolve, reject) => {
             const packageName = args[1];
             if (this.debug) {
-                await logger.logToStderr(`Executing npm: ${args.join(' ')}...`);
+                await this.logger.logToStderr(`Executing npm: ${args.join(' ')}...`);
             }
             child_process.exec(`npm ${args.join(' ')}`, (err, stdout) => {
                 if (err) {
@@ -825,14 +916,28 @@ class SpfxDoctorCommand extends BaseProjectCommand {
     getNodeVersion() {
         return process.version.substr(1);
     }
-    async checkStatus(what, versionFound, versionCheck, optionalOrRequired, fixes, logger) {
+    async checkStatus(what, versionFound, versionCheck) {
         if (versionFound) {
             if (satisfies(versionFound, versionCheck.range)) {
-                await logger.log(formatting.getStatus(CheckStatus.Success, `${what} v${versionFound}`));
+                const message = `${what} v${versionFound}`;
+                this.resultsObject.push({
+                    check: what,
+                    passed: true,
+                    message: message,
+                    version: versionFound
+                });
+                await this.logMessage(formatting.getStatus(CheckStatus.Success, message));
             }
             else {
-                await logger.log(formatting.getStatus(CheckStatus.Failure, `${what} v${versionFound} found, v${versionCheck.range} required`));
-                fixes.push(versionCheck.fix);
+                const message = `${what} v${versionFound} found, v${versionCheck.range} required`;
+                this.resultsObject.push({
+                    check: what,
+                    passed: false,
+                    version: versionFound,
+                    message: message,
+                    fix: versionCheck.fix
+                });
+                await this.logMessage(formatting.getStatus(CheckStatus.Failure, message));
             }
         }
     }

package/dist/m365/spo/commands/listitem/listitem-set.js

@@ -4,8 +4,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _SpoListItemSetCommand_instances, _SpoListItemSetCommand_initTelemetry, _SpoListItemSetCommand_initOptions, _SpoListItemSetCommand_initValidators, _SpoListItemSetCommand_initTypes, _SpoListItemSetCommand_initOptionSets;
-import os from 'os';
-import config from '../../../../config.js';
 import request from '../../../../request.js';
 import { basic } from '../../../../utils/basic.js';
 import { formatting } from '../../../../utils/formatting.js';
@@ -35,11 +33,9 @@ class SpoListItemSetCommand extends SpoCommand {
     }
     async commandAction(logger, args) {
         let contentTypeName = '';
-        let listId = '';
         try {
             let requestUrl = `${args.options.webUrl}/_api/web`;
             if (args.options.listId) {
-                listId = args.options.listId;
                 requestUrl += `/lists(guid'${formatting.encodeQueryParameter(args.options.listId)}')`;
             }
             else if (args.options.listTitle) {
@@ -49,20 +45,6 @@ class SpoListItemSetCommand extends SpoCommand {
                 const listServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.listUrl);
                 requestUrl += `/GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')`;
             }
-            if (args.options.systemUpdate && !args.options.listId) {
-                if (this.verbose) {
-                    await logger.logToStderr(`Getting list id...`);
-                }
-                const listRequestOptions = {
-                    url: `${requestUrl}?$select=Id`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
-                    },
-                    responseType: 'json'
-                };
-                const list = await request.get(listRequestOptions);
-                listId = list.Id;
-            }
             if (args.options.contentType) {
                 if (this.verbose) {
                     await logger.logToStderr(`Getting content types for list...`);
@@ -101,94 +83,10 @@ class SpoListItemSetCommand extends SpoCommand {
                     await logger.logToStderr(`using content type name: ${contentTypeName}`);
                 }
             }
-            let res = undefined;
-            if (args.options.systemUpdate) {
-                if (this.debug) {
-                    await logger.logToStderr(`getting request digest for systemUpdate request`);
-                }
-                res = await spo.getRequestDigest(args.options.webUrl);
-            }
-            if (this.verbose) {
-                await logger.logToStderr(`Updating item in list ${args.options.listId || args.options.listTitle || args.options.listUrl} in site ${args.options.webUrl}...`);
-            }
-            const formDigestValue = args.options.systemUpdate ? res['FormDigestValue'] : '';
-            let objectIdentity = '';
-            if (args.options.systemUpdate) {
-                objectIdentity = await this.requestObjectIdentity(args.options.webUrl, logger, formDigestValue);
-            }
-            const additionalContentType = (args.options.systemUpdate && args.options.contentType && contentTypeName !== '') ? `
-          <Method Name="ParseAndSetFieldValue" Id="1" ObjectPathId="147">
-            <Parameters>
-              <Parameter Type="String">ContentType</Parameter>
-              <Parameter Type="String">${contentTypeName}</Parameter>
-            </Parameters>
-          </Method>`
-                : ``;
-            const requestBody = args.options.systemUpdate ?
-                `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009">
-          <Actions>
-            ${this.mapRequestBody(args.options).join('')}${additionalContentType}
-            <Method Name="SystemUpdate" Id="2" ObjectPathId="147" />
-          </Actions>
-          <ObjectPaths>
-            <Identity Id="147" Name="${objectIdentity}:list:${listId}:item:${args.options.id},1" />
-          </ObjectPaths>
-        </Request>`
-                : {
-                    formValues: this.mapRequestBody(args.options)
-                };
-            if (args.options.contentType && contentTypeName !== '' && !args.options.systemUpdate) {
-                if (this.debug) {
-                    await logger.logToStderr(`Specifying content type name [${contentTypeName}] in request body`);
-                }
-                requestBody.formValues.push({
-                    FieldName: 'ContentType',
-                    FieldValue: contentTypeName
-                });
-            }
-            const requestOptions = args.options.systemUpdate ?
-                {
-                    url: `${args.options.webUrl}/_vti_bin/client.svc/ProcessQuery`,
-                    headers: {
-                        'Content-Type': 'text/xml',
-                        'X-RequestDigest': formDigestValue
-                    },
-                    data: requestBody
-                } :
-                {
-                    url: `${requestUrl}/items(${args.options.id})/ValidateUpdateListItem()`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
-                    },
-                    data: requestBody,
-                    responseType: 'json'
-                };
-            const response = await request.post(requestOptions);
-            let itemId = 0;
-            if (args.options.systemUpdate) {
-                if (response.indexOf("ErrorMessage") > -1) {
-                    throw `Error occurred in systemUpdate operation - ${response}`;
-                }
-                else {
-                    itemId = Number(args.options.id);
-                }
-            }
-            else {
-                // Response is from /ValidateUpdateListItem POST call, perform get on updated item to get all field values
-                const fieldValues = response.value;
-                if (fieldValues.some(f => f.HasException)) {
-                    throw `Updating the items has failed with the following errors: ${os.EOL}${fieldValues.filter(f => f.HasException).map(f => { return `- ${f.FieldName} - ${f.ErrorMessage}`; }).join(os.EOL)}`;
-                }
-                itemId = fieldValues[0].ItemId;
-            }
-            const requestOptionsItems = {
-                url: `${requestUrl}/items(${itemId})`,
-                headers: {
-                    'accept': 'application/json;odata=nometadata'
-                },
-                responseType: 'json'
-            };
-            const item = await request.get(requestOptionsItems);
+            const properties = this.mapRequestBody(args.options);
+            const item = args.options.systemUpdate ?
+                await spo.systemUpdateListItem(requestUrl, args.options.id, logger, this.verbose, properties, contentTypeName)
+                : await spo.updateListItem(requestUrl, args.options.id, properties, contentTypeName);
             delete item.ID;
             await logger.log(item);
         }
@@ -197,7 +95,7 @@ class SpoListItemSetCommand extends SpoCommand {
         }
     }
     mapRequestBody(options) {
-        const requestBody = [];
+        const filteredData = {};
         const excludeOptions = [
             'listTitle',
             'listId',
@@ -216,57 +114,12 @@ class SpoListItemSetCommand extends SpoCommand {
             't',
             '_'
         ];
-        Object.keys(options).forEach(key => {
-            if (excludeOptions.indexOf(key) === -1) {
-                if (options.systemUpdate) {
-                    requestBody.push(`
-          <Method Name="ParseAndSetFieldValue" Id="1" ObjectPathId="147">
-            <Parameters>
-              <Parameter Type="String">${key}</Parameter>
-              <Parameter Type="String">${options[key].toString()}</Parameter>
-            </Parameters>
-          </Method>`);
-                }
-                else {
-                    requestBody.push({ FieldName: key, FieldValue: options[key].toString() });
-                }
+        for (const key of Object.keys(options)) {
+            if (!excludeOptions.includes(key)) {
+                filteredData[key] = options[key];
             }
-        });
-        return requestBody;
-    }
-    /**
-     * Requests web object identity for the current web.
-     * This request has to be send before we can construct the property bag request.
-     * The response data looks like:
-     * _ObjectIdentity_=<GUID>|<GUID>:site:<GUID>:web:<GUID>
-     * _ObjectType_=SP.Web
-     * ServerRelativeUrl=/sites/contoso
-     * The ObjectIdentity is needed to create another request to retrieve the property bag or set property.
-     * @param webUrl web url
-     * @param cmd command cmd
-     */
-    async requestObjectIdentity(webUrl, logger, formDigestValue) {
-        const requestOptions = {
-            url: `${webUrl}/_vti_bin/client.svc/ProcessQuery`,
-            headers: {
-                'X-RequestDigest': formDigestValue
-            },
-            data: `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><Query Id="1" ObjectPathId="5"><Query SelectAllProperties="false"><Properties><Property Name="ServerRelativeUrl" ScalarProperty="true" /></Properties></Query></Query></Actions><ObjectPaths><Property Id="5" ParentId="3" Name="Web" /><StaticProperty Id="3" TypeId="{3747adcd-a3c3-41b9-bfab-4a64dd2f1e0a}" Name="Current" /></ObjectPaths></Request>`
-        };
-        const response = await request.post(requestOptions);
-        if (this.debug) {
-            await logger.logToStderr('Attempt to get _ObjectIdentity_ key values');
-        }
-        const json = JSON.parse(response);
-        const contents = json.find(x => { return x['ErrorInfo']; });
-        if (contents && contents.ErrorInfo) {
-            throw contents.ErrorInfo.ErrorMessage || 'ClientSvc unknown error';
-        }
-        const identityObject = json.find(x => { return x['_ObjectIdentity_']; });
-        if (identityObject) {
-            return identityObject['_ObjectIdentity_'];
         }
-        throw 'Cannot proceed. _ObjectIdentity_ not found'; // this is not supposed to happen
+        return filteredData;
     }
 }
 _SpoListItemSetCommand_instances = new WeakSet(), _SpoListItemSetCommand_initTelemetry = function _SpoListItemSetCommand_initTelemetry() {