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

package/dist/m365/spo/commands/folder/folder-sharinglink-clear.js

@@ -0,0 +1,111 @@
+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 _SpoFolderSharingLinkClearCommand_instances, _SpoFolderSharingLinkClearCommand_initTelemetry, _SpoFolderSharingLinkClearCommand_initOptions, _SpoFolderSharingLinkClearCommand_initOptionSets, _SpoFolderSharingLinkClearCommand_initValidators, _SpoFolderSharingLinkClearCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import { spo } from '../../../../utils/spo.js';
+import { odata } from '../../../../utils/odata.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { drive } from '../../../../utils/drive.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import request from '../../../../request.js';
+import commands from '../../commands.js';
+class SpoFolderSharingLinkClearCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_CLEAR;
+    }
+    get description() {
+        return 'Removes all sharing links of a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkClearCommand_instances.add(this);
+        this.allowedScopes = ['anonymous', 'users', 'organization'];
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkClearCommand_instances, "m", _SpoFolderSharingLinkClearCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const clearSharingLinks = async () => {
+            if (this.verbose) {
+                await logger.logToStderr(`Clearing sharing links from folder ${args.options.folderId || args.options.folderUrl} for ${args.options.scope ? `${args.options.scope} scope` : 'all scopes'}`);
+            }
+            try {
+                const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
+                const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+                const folderUrl = new URL(absoluteFolderUrl);
+                const siteId = await spo.getSiteId(args.options.webUrl);
+                const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
+                const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
+                let requestUrl = `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions?$filter=Link ne null`;
+                if (args.options.scope) {
+                    requestUrl += ` and Link/Scope eq '${args.options.scope}'`;
+                }
+                const sharingLinks = await odata.getAllItems(requestUrl);
+                for (const sharingLink of sharingLinks) {
+                    const requestOptions = {
+                        url: `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions/${sharingLink.id}`,
+                        headers: {
+                            accept: 'application/json;odata.metadata=none'
+                        }
+                    };
+                    await request.delete(requestOptions);
+                }
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await clearSharingLinks();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to clear sharing links from folder ${args.options.folderUrl || args.options.folderId}? for ${args.options.scope ? `${args.options.scope} scope` : 'all scopes'}` });
+            if (result) {
+                await clearSharingLinks();
+            }
+        }
+    }
+}
+_SpoFolderSharingLinkClearCommand_instances = new WeakSet(), _SpoFolderSharingLinkClearCommand_initTelemetry = function _SpoFolderSharingLinkClearCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            webUrl: typeof args.options.webUrl !== 'undefined',
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            folderId: typeof args.options.folderId !== 'undefined',
+            scope: typeof args.options.scope !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _SpoFolderSharingLinkClearCommand_initOptions = function _SpoFolderSharingLinkClearCommand_initOptions() {
+    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--folderUrl [folderUrl]' }, { option: '--folderId [folderId]' }, {
+        option: '--scope [scope]',
+        autocomplete: this.allowedScopes
+    }, { option: '-f, --force' });
+}, _SpoFolderSharingLinkClearCommand_initOptionSets = function _SpoFolderSharingLinkClearCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderUrl', 'folderId'] });
+}, _SpoFolderSharingLinkClearCommand_initValidators = function _SpoFolderSharingLinkClearCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID`;
+        }
+        if (args.options.scope && !this.allowedScopes.some(scope => scope === args.options.scope)) {
+            return `'${args.options.scope}' is not a valid scope. Allowed values are: ${this.allowedScopes.join(',')}`;
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkClearCommand_initTypes = function _SpoFolderSharingLinkClearCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderUrl', 'folderId', 'scope');
+    this.types.boolean.push('force');
+};
+export default new SpoFolderSharingLinkClearCommand();
+//# sourceMappingURL=folder-sharinglink-clear.js.map

package/dist/m365/spo/commands/folder/folder-sharinglink-remove.js

@@ -0,0 +1,95 @@
+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 _SpoFolderSharingLinkRemoveCommand_instances, _SpoFolderSharingLinkRemoveCommand_initTelemetry, _SpoFolderSharingLinkRemoveCommand_initOptions, _SpoFolderSharingLinkRemoveCommand_initOptionSets, _SpoFolderSharingLinkRemoveCommand_initValidators, _SpoFolderSharingLinkRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import { spo } from '../../../../utils/spo.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { drive } from '../../../../utils/drive.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import request from '../../../../request.js';
+import commands from '../../commands.js';
+class SpoFolderSharingLinkRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_REMOVE;
+    }
+    get description() {
+        return 'Removes a sharing link from a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkRemoveCommand_instances, "m", _SpoFolderSharingLinkRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeSharingLink = async () => {
+            if (this.verbose) {
+                await logger.logToStderr(`Removing sharing link of folder ${args.options.folderId || args.options.folderUrl} with id ${args.options.id}...`);
+            }
+            try {
+                const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
+                const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+                const folderUrl = new URL(absoluteFolderUrl);
+                const siteId = await spo.getSiteId(args.options.webUrl);
+                const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
+                const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
+                const requestOptions = {
+                    url: `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions/${args.options.id}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                return request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeSharingLink();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove sharing link ${args.options.id} of folder ${args.options.folderUrl || args.options.folderId}?` });
+            if (result) {
+                await removeSharingLink();
+            }
+        }
+    }
+}
+_SpoFolderSharingLinkRemoveCommand_instances = new WeakSet(), _SpoFolderSharingLinkRemoveCommand_initTelemetry = function _SpoFolderSharingLinkRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            folderId: typeof args.options.folderId !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _SpoFolderSharingLinkRemoveCommand_initOptions = function _SpoFolderSharingLinkRemoveCommand_initOptions() {
+    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--folderUrl [folderUrl]' }, { option: '--folderId [folderId]' }, { option: '-i, --id <id>' }, { option: '-f, --force' });
+}, _SpoFolderSharingLinkRemoveCommand_initOptionSets = function _SpoFolderSharingLinkRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderUrl', 'folderId'] });
+}, _SpoFolderSharingLinkRemoveCommand_initValidators = function _SpoFolderSharingLinkRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID`;
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkRemoveCommand_initTypes = function _SpoFolderSharingLinkRemoveCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderUrl', 'folderId', 'id');
+    this.types.boolean.push('force');
+};
+export default new SpoFolderSharingLinkRemoveCommand();
+//# sourceMappingURL=folder-sharinglink-remove.js.map

package/dist/m365/spo/commands/list/list-webhook-list.js

@@ -49,13 +49,8 @@ class SpoListWebhookListCommand extends SpoCommand {
                 res.forEach(w => {
                     w.clientState = w.clientState || '';
                 });
-                await logger.log(res);
-            }
-            else {
-                if (this.verbose) {
-                    await logger.logToStderr('No webhooks found');
-                }
             }
+            await logger.log(res);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);

package/dist/m365/spo/commands/listitem/listitem-attachment-list.js

@@ -50,14 +50,7 @@ class SpoListItemAttachmentListCommand extends SpoCommand {
         };
         try {
             const attachmentFiles = await request.get(requestOptions);
-            if (attachmentFiles.AttachmentFiles && attachmentFiles.AttachmentFiles.length > 0) {
-                await logger.log(attachmentFiles.AttachmentFiles);
-            }
-            else {
-                if (this.verbose) {
-                    await logger.logToStderr('No attachments found');
-                }
-            }
+            await logger.log(attachmentFiles.AttachmentFiles);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);

package/dist/m365/spo/commands/page/page-list.js

@@ -48,8 +48,8 @@ class SpoPageListCommand extends SpoCommand {
                     return p;
                 });
                 pages.filter(p => p.ListItemAllFields).forEach(page => delete page.ListItemAllFields.ID);
-                await logger.log(pages);
             }
+            await logger.log(pages);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);

package/dist/m365/spo/commands/page/page-remove.js

@@ -3,10 +3,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _SpoPageRemoveCommand_instances, _SpoPageRemoveCommand_initOptions, _SpoPageRemoveCommand_initValidators;
+var _SpoPageRemoveCommand_instances, _SpoPageRemoveCommand_initTelemetry, _SpoPageRemoveCommand_initOptions, _SpoPageRemoveCommand_initValidators, _SpoPageRemoveCommand_initTypes;
 import { cli } from '../../../../cli/cli.js';
 import request from '../../../../request.js';
-import { spo } from '../../../../utils/spo.js';
+import { formatting } from '../../../../utils/formatting.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
@@ -21,15 +21,17 @@ class SpoPageRemoveCommand extends SpoCommand {
     constructor() {
         super();
         _SpoPageRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoPageRemoveCommand_instances, "m", _SpoPageRemoveCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoPageRemoveCommand_instances, "m", _SpoPageRemoveCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoPageRemoveCommand_instances, "m", _SpoPageRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoPageRemoveCommand_instances, "m", _SpoPageRemoveCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         if (args.options.force) {
             await this.removePage(logger, args);
         }
         else {
-            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove the page '${args.options.name}'?` });
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove page '${args.options.name}'?` });
             if (result) {
                 await this.removePage(logger, args);
             }
@@ -37,44 +39,63 @@ class SpoPageRemoveCommand extends SpoCommand {
     }
     async removePage(logger, args) {
         try {
-            let requestDigest = '';
-            let pageName = args.options.name;
-            const reqDigest = await spo.getRequestDigest(args.options.webUrl);
-            requestDigest = reqDigest.FormDigestValue;
-            if (!pageName.endsWith('.aspx')) {
+            // Remove leading slashes from the page name (page can be nested in folders)
+            let pageName = urlUtil.removeLeadingSlashes(args.options.name);
+            if (!pageName.toLowerCase().endsWith('.aspx')) {
                 pageName += '.aspx';
             }
             if (this.verbose) {
                 await logger.logToStderr(`Removing page ${pageName}...`);
             }
+            const filePath = `${urlUtil.getServerRelativeSiteUrl(args.options.webUrl)}/SitePages/${pageName}`;
             const requestOptions = {
-                url: `${args.options
-                    .webUrl}/_api/web/GetFileByServerRelativePath(DecodedUrl='${urlUtil.getServerRelativeSiteUrl(args.options.webUrl)}/sitepages/${pageName}')`,
+                url: `${args.options.webUrl}/_api/web/GetFileByServerRelativePath(DecodedUrl='${formatting.encodeQueryParameter(filePath)}')`,
                 headers: {
-                    'X-RequestDigest': requestDigest,
-                    'X-HTTP-Method': 'DELETE',
-                    'content-type': 'application/json;odata=nometadata',
                     accept: 'application/json;odata=nometadata'
                 },
                 responseType: 'json'
             };
-            await request.post(requestOptions);
+            if (args.options.bypassSharedLock) {
+                requestOptions.headers.Prefer = 'bypass-shared-lock';
+            }
+            if (args.options.recycle) {
+                requestOptions.url += '/Recycle';
+                await request.post(requestOptions);
+            }
+            else {
+                await request.delete(requestOptions);
+            }
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
         }
     }
 }
-_SpoPageRemoveCommand_instances = new WeakSet(), _SpoPageRemoveCommand_initOptions = function _SpoPageRemoveCommand_initOptions() {
+_SpoPageRemoveCommand_instances = new WeakSet(), _SpoPageRemoveCommand_initTelemetry = function _SpoPageRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            force: !!args.options.force,
+            recycle: !!args.options.recycle,
+            bypassSharedLock: !!args.options.bypassSharedLock
+        });
+    });
+}, _SpoPageRemoveCommand_initOptions = function _SpoPageRemoveCommand_initOptions() {
     this.options.unshift({
+        option: '-u, --webUrl <webUrl>'
+    }, {
         option: '-n, --name <name>'
     }, {
-        option: '-u, --webUrl <webUrl>'
+        option: '--recycle'
+    }, {
+        option: '--bypassSharedLock'
     }, {
         option: '-f, --force'
     });
 }, _SpoPageRemoveCommand_initValidators = function _SpoPageRemoveCommand_initValidators() {
     this.validators.push(async (args) => validation.isValidSharePointUrl(args.options.webUrl));
+}, _SpoPageRemoveCommand_initTypes = function _SpoPageRemoveCommand_initTypes() {
+    this.types.string.push('name', 'webUrl');
+    this.types.boolean.push('force', 'bypassSharedLock', 'recycle');
 };
 export default new SpoPageRemoveCommand();
 //# sourceMappingURL=page-remove.js.map

package/dist/m365/spo/commands/page/page-template-list.js

@@ -30,9 +30,7 @@ class SpoPageTemplateListCommand extends SpoCommand {
         }
         try {
             const res = await odata.getAllItems(`${args.options.webUrl}/_api/sitepages/pages/templates`);
-            if (res && res.length > 0) {
-                await logger.log(res);
-            }
+            await logger.log(res);
         }
         catch (err) {
             // The API returns a 404 when no templates are created on the site collection

package/dist/m365/spo/commands/site/SiteAdmin.js

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

package/dist/m365/spo/commands/site/site-admin-add.js

@@ -0,0 +1,252 @@
+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 _SpoSiteAdminAddCommand_instances, _SpoSiteAdminAddCommand_initTelemetry, _SpoSiteAdminAddCommand_initOptions, _SpoSiteAdminAddCommand_initValidators, _SpoSiteAdminAddCommand_initOptionSets, _SpoSiteAdminAddCommand_initTypes;
+import config from '../../../../config.js';
+import request from '../../../../request.js';
+import { entraGroup } from '../../../../utils/entraGroup.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { spo } from '../../../../utils/spo.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoSiteAdminAddCommand extends SpoCommand {
+    get name() {
+        return commands.SITE_ADMIN_ADD;
+    }
+    get description() {
+        return 'Adds a user or group as a site collection administrator';
+    }
+    constructor() {
+        super();
+        _SpoSiteAdminAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminAddCommand_instances, "m", _SpoSiteAdminAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminAddCommand_instances, "m", _SpoSiteAdminAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminAddCommand_instances, "m", _SpoSiteAdminAddCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminAddCommand_instances, "m", _SpoSiteAdminAddCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminAddCommand_instances, "m", _SpoSiteAdminAddCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const loginNameToAdd = await this.getCorrectLoginName(args.options);
+            if (args.options.asAdmin) {
+                await this.callActionAsAdmin(logger, args, loginNameToAdd);
+                return;
+            }
+            await this.callAction(logger, args, loginNameToAdd);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async callActionAsAdmin(logger, args, loginNameToAdd) {
+        if (this.verbose) {
+            await logger.logToStderr('Adding site administrator as an administrator...');
+        }
+        const adminUrl = await spo.getSpoAdminUrl(logger, this.debug);
+        const siteId = await this.getSiteIdBasedOnUrl(args.options.siteUrl, logger);
+        const siteAdmins = (await this.getSiteAdmins(adminUrl, siteId)).map(u => u.loginName);
+        siteAdmins.push(loginNameToAdd);
+        await this.setSiteAdminsAsAdmin(adminUrl, siteId, siteAdmins);
+        if (args.options.primary) {
+            await this.setPrimaryAdminAsAdmin(adminUrl, siteId, loginNameToAdd);
+        }
+    }
+    async getSiteIdBasedOnUrl(siteUrl, logger) {
+        const siteGraphId = await spo.getSiteId(siteUrl, logger, this.verbose);
+        const match = siteGraphId.match(/,([a-f0-9\-]{36}),/i);
+        if (!match) {
+            throw `Site with URL ${siteUrl} not found`;
+        }
+        return match[1];
+    }
+    async getSiteAdmins(adminUrl, siteId) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPO.Tenant/GetSiteAdministrators?siteId='${siteId}'`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            }
+        };
+        const response = await request.post(requestOptions);
+        const responseContent = JSON.parse(response);
+        return responseContent.value;
+    }
+    async getCorrectLoginName(options) {
+        if (options.userId || options.userName) {
+            const userPrincipalName = options.userName ? options.userName : await entraUser.getUpnByUserId(options.userId);
+            if (userPrincipalName) {
+                return `i:0#.f|membership|${userPrincipalName}`;
+            }
+            throw 'User not found.';
+        }
+        else {
+            const group = options.groupId ? await entraGroup.getGroupById(options.groupId) : await entraGroup.getGroupByDisplayName(options.groupName);
+            //for entra groups, M365 groups have an associated email and security groups don't
+            if (group?.mail) {
+                //M365 group is prefixed with c:0o.c|federateddirectoryclaimprovider
+                return `c:0o.c|federateddirectoryclaimprovider|${group.id}`;
+            }
+            else {
+                //security group is prefixed with c:0t.c|tenant
+                return `c:0t.c|tenant|${group?.id}`;
+            }
+        }
+    }
+    async setSiteAdminsAsAdmin(adminUrl, siteId, admins) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPOInternalUseOnly.Tenant/SetSiteSecondaryAdministrators`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            },
+            data: {
+                secondaryAdministratorsFieldsData: {
+                    siteId: siteId,
+                    secondaryAdministratorLoginNames: admins
+                }
+            }
+        };
+        return request.post(requestOptions);
+    }
+    async setPrimaryAdminAsAdmin(adminUrl, siteId, adminLogin) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPO.Tenant/sites('${siteId}')`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            },
+            data: {
+                Owner: adminLogin,
+                SetOwnerWithoutUpdatingSecondaryAdmin: true
+            }
+        };
+        return request.patch(requestOptions);
+    }
+    async callAction(logger, args, loginNameToAdd) {
+        if (this.verbose) {
+            await logger.logToStderr('Adding site administrator...');
+        }
+        const ensuredUserData = await this.ensureUser(args, loginNameToAdd);
+        await this.setSiteAdmin(args.options.siteUrl, loginNameToAdd);
+        if (args.options.primary) {
+            const siteId = await this.getSiteId(args.options.siteUrl);
+            const previousPrimaryOwner = await this.getSiteOwnerLoginName(args.options.siteUrl);
+            await this.setPrimaryOwnerLoginFromSite(logger, args.options.siteUrl, siteId, ensuredUserData);
+            await this.setSiteAdmin(args.options.siteUrl, previousPrimaryOwner);
+        }
+    }
+    async ensureUser(args, loginName) {
+        const requestOptions = {
+            url: `${args.options.siteUrl}/_api/web/ensureuser`,
+            headers: {
+                accept: 'application/json;odata=nometadata'
+            },
+            data: {
+                logonName: loginName
+            },
+            responseType: 'json'
+        };
+        return request.post(requestOptions);
+    }
+    async setSiteAdmin(siteUrl, loginName) {
+        const requestOptions = {
+            url: `${siteUrl}/_api/web/siteusers('${formatting.encodeQueryParameter(loginName)}')`,
+            headers: {
+                'accept': 'application/json',
+                'X-Http-Method': 'MERGE',
+                'If-Match': '*'
+            },
+            data: { IsSiteAdmin: true },
+            responseType: 'json'
+        };
+        return request.post(requestOptions);
+    }
+    async getSiteId(siteUrl) {
+        const requestOptions = {
+            url: `${siteUrl}/_api/site?$select=Id`,
+            headers: {
+                accept: 'application/json;odata=nometadata'
+            },
+            responseType: 'json'
+        };
+        const response = await request.get(requestOptions);
+        return response.Id;
+    }
+    async getSiteOwnerLoginName(siteUrl) {
+        const requestOptions = {
+            url: `${siteUrl}/_api/site/owner?$select=LoginName`,
+            headers: {
+                accept: 'application/json;odata=nometadata'
+            },
+            responseType: 'json'
+        };
+        const response = await request.get(requestOptions);
+        return response.LoginName;
+    }
+    async setPrimaryOwnerLoginFromSite(logger, siteUrl, siteId, loginName) {
+        const res = await spo.ensureFormDigest(siteUrl, logger, undefined, this.debug);
+        const body = `<Request xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}"><Actions><SetProperty Id="10" ObjectPathId="2" Name="Owner"><Parameter ObjectPathId="3" /></SetProperty></Actions><ObjectPaths><Property Id="2" ParentId="0" Name="Site" /><Identity Id="3" Name="6d452ba1-40a8-8000-e00d-46e1adaa12bf|740c6a0b-85e2-48a0-a494-e0f1759d4aa7:site:${siteId}:u:${loginName.Id}" /><StaticProperty Id="0" TypeId="{3747adcd-a3c3-41b9-bfab-4a64dd2f1e0a}" Name="Current" /></ObjectPaths></Request>`;
+        const requestOptions = {
+            url: `${siteUrl}/_vti_bin/client.svc/ProcessQuery`,
+            headers: {
+                'X-RequestDigest': res.FormDigestValue
+            },
+            data: body
+        };
+        return request.post(requestOptions);
+    }
+}
+_SpoSiteAdminAddCommand_instances = new WeakSet(), _SpoSiteAdminAddCommand_initTelemetry = function _SpoSiteAdminAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            groupId: typeof args.options.groupId !== 'undefined',
+            groupName: typeof args.options.groupName !== 'undefined',
+            primary: !!args.options.primary,
+            asAdmin: !!args.options.asAdmin
+        });
+    });
+}, _SpoSiteAdminAddCommand_initOptions = function _SpoSiteAdminAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --siteUrl <siteUrl>'
+    }, {
+        option: '--userId [userId]'
+    }, {
+        option: '--userName [userName]'
+    }, {
+        option: '--groupId [groupId]'
+    }, {
+        option: '--groupName [groupName]'
+    }, {
+        option: '--primary'
+    }, {
+        option: '--asAdmin'
+    });
+}, _SpoSiteAdminAddCommand_initValidators = function _SpoSiteAdminAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId &&
+            !validation.isValidGuid(args.options.userId)) {
+            return `'${args.options.userId}' is not a valid GUID for option 'userId'`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `'${args.options.userName}' is not a valid 'userName'`;
+        }
+        if (args.options.groupId &&
+            !validation.isValidGuid(args.options.groupId)) {
+            return `'${args.options.groupId}' is not a valid GUID for option 'groupId'`;
+        }
+        return validation.isValidSharePointUrl(args.options.siteUrl);
+    });
+}, _SpoSiteAdminAddCommand_initOptionSets = function _SpoSiteAdminAddCommand_initOptionSets() {
+    this.optionSets.push({ options: ['userId', 'userName', 'groupId', 'groupName'] });
+}, _SpoSiteAdminAddCommand_initTypes = function _SpoSiteAdminAddCommand_initTypes() {
+    this.types.string.push('siteUrl', 'userId', 'userName', 'groupId', 'groupName');
+    this.types.boolean.push('primary', 'asAdmin');
+};
+export default new SpoSiteAdminAddCommand();
+//# sourceMappingURL=site-admin-add.js.map