@kwiz/common/lib/cjs/utils/sharepoint.rest/file.folder.js

KWIZ common utilities and helpers for M365 platform

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CopyFile = exports.MoveFile = exports.CreateAppPage = exports.GetFolderItemInfo = exports.GetFileItemInfo = exports.GetFilePublishingStatus = exports.GetFileModerationStatus = exports.GetFileItemId = exports.GetFolder = exports.GetListFolders = exports.GetFileSize = exports.FileVersionToVersionId = exports.GetFileVersionHistory = exports.GetFileEx = exports.GetFile = exports.GetFileSync = exports.DeleteFile = exports.RecycleFile = exports.RejectFile = exports.ApproveFile = exports.UnpublishFile = exports.PublishFile = exports.UploadFile = exports.UploadFileSync = exports.GetFolderFiles = exports.DeleteFolder = exports.EnsureFolder = exports.EnsureFolderPath = void 0;
const exports_index_1 = require("../../exports-index");
const json_1 = require("../../helpers/json");
const typecheckers_1 = require("../../helpers/typecheckers");
const url_1 = require("../../helpers/url");
const rest_types_1 = require("../../types/rest.types");
const consolelogger_1 = require("../consolelogger");
const rest_1 = require("../rest");
const common_1 = require("./common");
const list_1 = require("./list");
const logger = consolelogger_1.ConsoleLogger.get("SharePoint.Rest.FileNFolder");
let existingFolders = [];
async function EnsureFolderPath(siteUrl, folderServerRelativeUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    //issue 7176
    folderServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(folderServerRelativeUrl, siteUrl);
    if (existingFolders.indexOf(folderServerRelativeUrl) >= 0) {
        return true;
    }
    let url = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFolderByServerRelativeUrl(serverRelativeUrl='${folderServerRelativeUrl}')?$select=exists`;
    let folder = await (0, rest_1.GetJson)(url);
    if (folder && folder.d.Exists) {
        existingFolders.push(folderServerRelativeUrl);
        return true;
    }
    else {
        let parts = folderServerRelativeUrl.split('/');
        if (parts.length > 1) {
            let parentFolder = parts.slice(0, parts.length - 1).join('/');
            //ensure parent
            let parent = await EnsureFolderPath(siteUrl, parentFolder);
            if (parent) {
                //create it
                let ensure = await EnsureFolder(siteUrl, parentFolder, parts[parts.length - 1]);
                if (ensure.Exists) {
                    existingFolders.push(folderServerRelativeUrl);
                    return true;
                }
            }
        }
    }
    return false;
}
exports.EnsureFolderPath = EnsureFolderPath;
function EnsureFolder(siteUrl, parentFolderServerRelativeUrl, folderName) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    parentFolderServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(parentFolderServerRelativeUrl, siteUrl);
    return (0, rest_1.GetJson)(`${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFolderByServerRelativeUrl(serverRelativeUrl='${parentFolderServerRelativeUrl}')/folders/add(url='${folderName}')`, null, { method: "POST", spWebUrl: siteUrl })
        .then(r => { return r.d; })
        .catch(() => { return { Exists: false }; });
}
exports.EnsureFolder = EnsureFolder;
function DeleteFolder(siteUrl, folderUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    folderUrl = (0, url_1.makeServerRelativeUrl)(folderUrl, siteUrl);
    var requestUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFolderByServerRelativeUrl(serverRelativeUrl='${folderUrl}')`;
    return (0, rest_1.GetJson)(requestUrl, null, {
        method: "POST",
        xHttpMethod: "DELETE"
    })
        .then(r => true)
        .catch((e) => false);
}
exports.DeleteFolder = DeleteFolder;
function GetFolderFiles(siteUrl, folderUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    folderUrl = (0, url_1.makeServerRelativeUrl)(folderUrl, siteUrl);
    var requestUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFolderByServerRelativeUrl(serverRelativeUrl='${folderUrl}')`
        + `/files?$select=Level,Exists,Name,ServerRelativeUrl,Title,TimeCreated,TimeLastModified,ListItemAllFields/OData__ModerationStatus&$expand=ListItemAllFields`;
    return (0, rest_1.GetJson)(requestUrl).then(r => {
        return r.d && r.d.results || [];
    }).catch(() => {
        return [];
    });
}
exports.GetFolderFiles = GetFolderFiles;
function UploadFileSync(siteUrl, folderServerRelativeUrl, fileName, fileContent) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    folderServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(folderServerRelativeUrl, siteUrl);
    let res = (0, rest_1.GetJsonSync)(`${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFolderByServerRelativeUrl(serverRelativeUrl='${folderServerRelativeUrl}')/files/add(url='${fileName}',overwrite=true)?$expand=ListItemAllFields`, fileContent, {
        method: 'POST',
        spWebUrl: siteUrl
    });
    return res.success && res.result && res.result.d ? res.result.d : { Exists: false };
}
exports.UploadFileSync = UploadFileSync;
async function UploadFile(siteUrl, folderServerRelativeUrl, fileName, fileContent, 
/** default options: { overwrite: true } */
options) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    options = options || { overwrite: true };
    folderServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(folderServerRelativeUrl, siteUrl);
    if (options && options.autoRename) {
        //get all files from this folder and find the next available name
        let files = await GetFolderFiles(siteUrl, folderServerRelativeUrl);
        let fileNames = files.map(f => f.Name.toLowerCase());
        let counter = 0;
        let originalName = fileName.split('.');
        originalName.splice(originalName.length - 1, 0, counter.toString());
        while (fileNames.includes(fileName.toLowerCase())) {
            counter++;
            originalName[originalName.length - 2] = counter.toString();
            fileName = originalName.join('.');
        }
    }
    return (0, rest_1.GetJson)(`${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFolderByServerRelativeUrl(serverRelativeUrl='${folderServerRelativeUrl}')/files/add(url='${fileName}'${options.overwrite ? ',overwrite=true' : ''})?$expand=ListItemAllFields`, fileContent, {
        method: 'POST',
        spWebUrl: siteUrl,
        allowCache: false,
        postCacheKey: null
    }) //Issue 6657 force set "POST" since we might send empty string as the value
        .then(r => { return r.d; })
        .catch(() => { return { Exists: false }; });
}
exports.UploadFile = UploadFile;
async function PublishFile(siteUrl, fileUrl, comment = "") {
    let result = await _moderateFile(siteUrl, fileUrl, "publish", comment);
    return result;
}
exports.PublishFile = PublishFile;
async function UnpublishFile(siteUrl, fileUrl, comment = "") {
    let result = await _moderateFile(siteUrl, fileUrl, "unpublish", comment);
    return result;
}
exports.UnpublishFile = UnpublishFile;
async function ApproveFile(siteUrl, fileUrl, comment = "") {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    let result = await _moderateFile(siteUrl, fileUrl, "approve", comment);
    return result;
}
exports.ApproveFile = ApproveFile;
async function RejectFile(siteUrl, fileUrl, comment = "") {
    let result = await _moderateFile(siteUrl, fileUrl, "deny", comment);
    return result;
}
exports.RejectFile = RejectFile;
async function _moderateFile(siteUrl, fileUrl, action, comment = "") {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    let fileServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(fileUrl, siteUrl);
    try {
        let hasComments = !(0, typecheckers_1.isNullOrEmptyString)(comment);
        let publishUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFileByServerRelativeUrl('${fileServerRelativeUrl}')/${action}${hasComments ? `(@a1)?@a1=%27${(0, url_1.encodeURIComponentEX)(comment, { singleQuoteMultiplier: 2 })}%27` : '()'}`;
        let publishResult = await (0, rest_1.GetJson)(publishUrl, null, {
            method: "POST",
            jsonMetadata: rest_types_1.jsonTypes.nometadata,
            includeDigestInPost: true
        });
        return !(0, typecheckers_1.isNullOrUndefined)(publishResult) && publishResult["odata.null"] === true;
    }
    catch {
    }
    return false;
}
function RecycleFile(siteUrl, fileServerRelativeUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl) + "/recycle()";
    return (0, rest_1.GetJson)(fileRestUrl, null, {
        method: "POST",
        headers: {
            "IF-MATCH": "*"
        }
    })
        .then(r => true)
        .catch((e) => false);
}
exports.RecycleFile = RecycleFile;
function DeleteFile(siteUrl, fileServerRelativeUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
    return (0, rest_1.GetJson)(fileRestUrl, null, {
        method: "POST",
        xHttpMethod: "DELETE"
    })
        .then(r => true)
        .catch((e) => false);
}
exports.DeleteFile = DeleteFile;
/** get the REST url for the site/_api/web/getfile....() */
function GetFileRestUrl(siteUrl, fileServerRelativeUrl) {
    fileServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(fileServerRelativeUrl, siteUrl);
    let fileRestUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/Web/getFileByServerRelativeUrl('${fileServerRelativeUrl}')`;
    return fileRestUrl;
}
function GetFileSync(siteUrl, fileServerRelativeUrl, responseType, options) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    let restOptions = (0, typecheckers_1.isNullOrUndefined)(options) || options.cache !== "long"
        ? { ...rest_1.shortLocalCache }
        : { ...rest_1.longLocalCache };
    if (options && options.cache === "nocache")
        restOptions.forceCacheUpdate = true;
    if (!(0, typecheckers_1.isNullOrUndefined)(responseType)) {
        restOptions.responseType = responseType;
    }
    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
    if (!restOptions.forceCacheUpdate && reloadCacheFileModifiedRecently(siteUrl, fileServerRelativeUrl)) {
        restOptions.forceCacheUpdate = true;
    }
    let response = (0, rest_1.GetJsonSync)(`${fileRestUrl}/$value`, null, restOptions);
    if (response && response.success)
        return {
            Exists: true,
            Content: response.result
        };
    else
        return {
            Exists: false
        };
}
exports.GetFileSync = GetFileSync;
/** @deprecated use GetFileEx */
function GetFile(siteUrl, fileServerRelativeUrl, allowCache, responseType) {
    return GetFileEx(siteUrl, fileServerRelativeUrl, { allowCache, responseType });
}
exports.GetFile = GetFile;
async function GetFileEx(siteUrl, fileServerRelativeUrl, options) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    options = options || {};
    let restOptions = { ...(options.allowCache === true ? rest_1.shortLocalCache : rest_1.noLocalCache), forceCacheUpdate: options.allowCache !== true };
    if (!(0, typecheckers_1.isNullOrUndefined)(options.responseType)) {
        restOptions.responseType = options.responseType;
    }
    let version = options.version;
    let versionPart = "";
    if ((0, typecheckers_1.isNumber)(version) && version > 0 || (0, typecheckers_1.isNotEmptyString)(version)) {
        //this end point does not work on MSAL claims
        // //get content of specific version
        // let fileSiteRelativeUrl = fileServerRelativeUrl.slice(siteUrl.length - 1);
        // let versionUrl = `${siteUrl}_vti_history/${FileVersionToVersionId(options.version)}${fileSiteRelativeUrl}`;
        // try {
        //     restOptions.jsonMetadata = jsonTypes.nometadata;
        //     let versionContent = await GetJson<T>(versionUrl, undefined, restOptions);
        //     return { Exists: isString(versionContent), Content: versionContent };
        // } catch (e) {
        //     return { Exists: false };
        // }
        versionPart = `/versions(${FileVersionToVersionId(options.version)})/`;
    }
    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
    if (!restOptions.forceCacheUpdate && reloadCacheFileModifiedRecently(siteUrl, fileServerRelativeUrl)) {
        restOptions.forceCacheUpdate = true;
    }
    return (0, rest_1.GetJson)(`${fileRestUrl}${versionPart}/$value`, null, restOptions).then(r => {
        return {
            Exists: true,
            Content: r
        };
    }).catch(() => {
        return {
            Exists: false
        };
    });
}
exports.GetFileEx = GetFileEx;
/** get file version history olders version first with correct check in comment, does NOT include current version */
async function GetFileVersionHistory(siteUrl, fileServerRelativeUrl, options) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    options = options || {};
    let restOptions = {
        allowCache: options.refreshCache !== true,
        jsonMetadata: rest_types_1.jsonTypes.nometadata
    };
    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
    if (!restOptions.forceCacheUpdate && reloadCacheFileModifiedRecently(siteUrl, fileServerRelativeUrl)) {
        restOptions.forceCacheUpdate = true;
    }
    try {
        const result = await (0, rest_1.GetJson)(`${fileRestUrl}/versions`, null, restOptions);
        //Created will come in as string
        result.value.forEach(v => v.Created = new Date(v.Created));
        return result.value;
    }
    catch (e) {
        logger.error((0, exports_index_1.GetError)(e));
    }
}
exports.GetFileVersionHistory = GetFileVersionHistory;
/** version: 1.5 >> version ID for history */
function FileVersionToVersionId(version) {
    try {
        if ((0, typecheckers_1.isNumber)(version))
            return version;
        const vSplit = version.split('.');
        const major = parseInt(vSplit[0], 10);
        const minor = parseInt(vSplit[1], 10);
        let versionId = (major * 512) + minor;
        return versionId;
    }
    catch (e) { }
    return null;
}
exports.FileVersionToVersionId = FileVersionToVersionId;
var $reloadCacheFileModifiedRecentlyFlagged = [];
function reloadCacheFileModifiedRecently(siteUrl, fileServerRelativeUrl) {
    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
    let key = fileRestUrl.toLowerCase();
    //only flag it once, first time it is requested...
    if (!$reloadCacheFileModifiedRecentlyFlagged.includes(key)) {
        try {
            $reloadCacheFileModifiedRecentlyFlagged.push(key);
            let fileInfo = (0, rest_1.GetJsonSync)(`${fileRestUrl}?$select=TimeLastModified`, null, {
                allowCache: true, //only allow in-memory cache for this
                jsonMetadata: rest_types_1.jsonTypes.nometadata
            });
            if (fileInfo.success && fileInfo.result) {
                let modified = new Date(fileInfo.result.TimeLastModified);
                let now = new Date();
                let difference = now.getTime() - modified.getTime();
                if (difference < 5 * 60 * 1000) {
                    //file has changed in the past 5 minutes - do not allow cache on it.
                    //happens when user uses classic app to change settings, the clear cache does not clear it on the main
                    //site URL ( support case - Issue 778 780 & 782 )
                    return true;
                }
            }
        }
        catch (e) { }
    }
    return false;
}
async function GetFileSize(siteUrl, fileServerRelativeUrlOrListId, itemIdOrAllowCache, allowCache) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    let requestUrl = "";
    if ((0, typecheckers_1.isNumber)(itemIdOrAllowCache) || (0, typecheckers_1.isNumeric)(itemIdOrAllowCache)) {
        requestUrl = (0, list_1.GetListRestUrl)(siteUrl, fileServerRelativeUrlOrListId) + `/items(${itemIdOrAllowCache})/File`;
    }
    else {
        allowCache = itemIdOrAllowCache === true;
        requestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrlOrListId);
    }
    let options = { allowCache: allowCache === true, jsonMetadata: rest_types_1.jsonTypes.nometadata };
    try {
        let result = await (0, rest_1.GetJson)(`${requestUrl}/Properties?$select=vti_x005f_filesize`, null, options);
        return result.vti_x005f_filesize;
    }
    catch (e) {
        return null;
    }
}
exports.GetFileSize = GetFileSize;
async function GetListFolders(siteUrl, listIdOrTitle) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    //switched to get request with no meta data - much faster.
    let url = (0, list_1.GetListRestUrl)(siteUrl, listIdOrTitle) + `/items?$Select=Folder/ServerRelativeUrl,Folder/Name&$filter=FSObjType eq 1&$expand=Folder`;
    let results = [];
    try {
        let requestResult = (await (0, rest_1.GetJson)(url, null, { allowCache: true, jsonMetadata: rest_types_1.jsonTypes.nometadata }));
        if ((0, typecheckers_1.isNotEmptyArray)(requestResult && requestResult.value)) {
            results = requestResult.value.map(f => ({
                Name: f.Folder.Name,
                ServerRelativeUrl: (0, url_1.normalizeUrl)(f.Folder.ServerRelativeUrl)
            }));
        }
    }
    catch (e) {
        //Issue 7543 throttled library with lots of items will fail so return empty array
        logger.error(`Could not get folders from ${listIdOrTitle}, check network for more infromation.`);
    }
    return results;
}
exports.GetListFolders = GetListFolders;
async function GetFolder(siteUrl, folderUrl, options = {}) {
    options = { includeFiles: false, includeFolders: false, allowCache: true, ...options };
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    try {
        let folderServerRelativeUrl = (0, url_1.makeServerRelativeUrl)(folderUrl, siteUrl);
        let restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getFolderByServerRelativeUrl('${(0, url_1.encodeURIComponentEX)(folderServerRelativeUrl)}')`;
        if (options.includeFiles === true || options.includeFolders === true) {
            let expand = [];
            if (options.includeFiles) {
                expand.push("Files");
            }
            if (options.includeFolders) {
                expand.push("Folders");
            }
            restUrl += `?$expand=${expand.join(",")}`;
        }
        const result = await (0, rest_1.GetJson)(restUrl, null, {
            ...(options.allowCache ? rest_1.mediumLocalCache : rest_1.noLocalCache),
            jsonMetadata: rest_types_1.jsonTypes.nometadata
        });
        return result;
    }
    catch {
    }
    return null;
}
exports.GetFolder = GetFolder;
async function GetFileItemId(siteUrl, fileServerRelativeUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    const restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getFileByServerRelativeUrl('${(0, url_1.encodeURIComponentEX)(fileServerRelativeUrl)}')/ListItemAllFields/id`;
    const result = await (0, rest_1.GetJson)(restUrl, null, { jsonMetadata: rest_types_1.jsonTypes.nometadata });
    return result.value;
}
exports.GetFileItemId = GetFileItemId;
async function GetFileModerationStatus(siteUrl, fileServerRelativeUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    const restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getFileByServerRelativeUrl('${(0, url_1.encodeURIComponentEX)(fileServerRelativeUrl)}')/ListItemAllFields/OData__ModerationStatus`;
    const result = await (0, rest_1.GetJson)(restUrl, null, { jsonMetadata: rest_types_1.jsonTypes.nometadata });
    return result.value;
}
exports.GetFileModerationStatus = GetFileModerationStatus;
async function GetFilePublishingStatus(siteUrl, fileServerRelativeUrl) {
    siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
    const restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getFileByServerRelativeUrl('${(0, url_1.encodeURIComponentEX)(fileServerRelativeUrl)}')/level`;
    const result = await (0, rest_1.GetJson)(restUrl, null, { jsonMetadata: rest_types_1.jsonTypes.nometadata });
    return result.value;
}
exports.GetFilePublishingStatus = GetFilePublishingStatus;
async function GetFileItemInfo(siteUrl, fileServerRelativeUrl) {
    try {
        siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
        const restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getFileByServerRelativeUrl('${(0, url_1.encodeURIComponentEX)(fileServerRelativeUrl)}')/ListItemAllFields`;
        const result = await (0, rest_1.GetJson)(restUrl, null, {
            jsonMetadata: rest_types_1.jsonTypes.verbose
        });
        const itemId = result.d.Id;
        const listId = result.d.__metadata.uri.split("'")[1];
        return { listId, itemId };
    }
    catch (e) {
        return null;
    }
}
exports.GetFileItemInfo = GetFileItemInfo;
async function GetFolderItemInfo(siteUrl, folderServerRelativeUrl) {
    try {
        siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
        const restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getFolderByServerRelativeUrl('${(0, url_1.encodeURIComponentEX)(folderServerRelativeUrl)}')/ListItemAllFields`;
        const result = await (0, rest_1.GetJson)(restUrl, null, { jsonMetadata: rest_types_1.jsonTypes.verbose });
        const itemId = result.d.Id;
        const listId = result.d.__metadata.uri.split("'")[1];
        return { listId, itemId };
    }
    catch (e) {
        return null;
    }
}
exports.GetFolderItemInfo = GetFolderItemInfo;
/** Creates a modern single app page and return its URL. if a file in that name exists, it will return one with (1) appended to it. */
async function CreateAppPage(siteUrl, info) {
    //read more: 
    //https://petelus.sharepoint.com/sites/CMSTest/_api/SitePages/Pages/CreateAppPage
    //https://spblog.net/post/2019/03/05/what-s-new-and-what-s-changed-in-sharepoint-online-rest-api-in-january-february-2019
    function getFileServerRelativeUrl(siteRelative) {
        const fileRelativeUrl = (0, url_1.makeServerRelativeUrl)(`${siteUrl}${siteRelative}`);
        return fileRelativeUrl;
    }
    let webPartDataAsJson = info.webPartDataAsJson;
    if ((0, typecheckers_1.isNullOrEmptyString)(webPartDataAsJson.instanceId))
        webPartDataAsJson.instanceId = (0, typecheckers_1.newGuid)();
    if ((0, typecheckers_1.isNullOrEmptyString)(webPartDataAsJson.dataVersion))
        webPartDataAsJson.dataVersion = "1.0";
    return logger.groupAsync("CreateAppPage", async (log) => {
        siteUrl = (0, common_1.GetSiteUrl)(siteUrl);
        const restUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/SitePages/Pages/CreateAppPage`;
        const result = await (0, rest_1.GetJson)(restUrl, (0, json_1.jsonStringify)({
            webPartDataAsJson: (0, json_1.jsonStringify)(webPartDataAsJson)
        }), { method: 'POST', jsonMetadata: rest_types_1.jsonTypes.nometadata });
        log(`created page`);
        log((0, json_1.jsonStringify)(result));
        let fileRelativeUrl = getFileServerRelativeUrl(result.value);
        const fileId = await GetFileItemId(siteUrl, fileRelativeUrl);
        const updateRestUrl = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/SitePages/Pages/UpdateAppPage`;
        const updateResult = await (0, rest_1.GetJson)(updateRestUrl, (0, json_1.jsonStringify)({
            pageId: fileId,
            title: info.name,
            webPartDataAsJson: (0, json_1.jsonStringify)(webPartDataAsJson)
        }), { method: 'POST', jsonMetadata: rest_types_1.jsonTypes.nometadata });
        log(`updated page`);
        log((0, json_1.jsonStringify)(updateResult));
        fileRelativeUrl = getFileServerRelativeUrl(updateResult.value);
        return fileRelativeUrl;
    });
}
exports.CreateAppPage = CreateAppPage;
/** Move a file to a new name/url, this API allows for changing file extension as well */
async function MoveFile(siteUrl, currentServerRelativeUrl, targetServerRelativeUrl, options) {
    return CopyOrMoveFile(siteUrl, currentServerRelativeUrl, targetServerRelativeUrl, "move", options);
    //this does NOT allow to change the file extension. only file name.
    // return UpdateItem(siteUrl, listIdOrTitle, itemId, {
    //     FileLeafRef: newFileName "hello.txt" >> "hello.md" won't work.
    // });
}
exports.MoveFile = MoveFile;
/** Copy a file to a new name/url, this API allows for changing file extension as well */
async function CopyFile(siteUrl, currentServerRelativeUrl, targetServerRelativeUrl, options) {
    return CopyOrMoveFile(siteUrl, currentServerRelativeUrl, targetServerRelativeUrl, "copy", options);
}
exports.CopyFile = CopyFile;
async function CopyOrMoveFile(siteUrl, currentServerRelativeUrl, targetServerRelativeUrl, action, options) {
    try {
        if (options && options.autoRename) {
            let targetParts = targetServerRelativeUrl.split('/');
            let fileName = targetParts.pop();
            let targetFolderUrl = targetParts.join('/');
            //get all files from this folder and find the next available name
            let files = await GetFolderFiles(siteUrl, targetFolderUrl);
            let fileNames = files.map(f => f.Name.toLowerCase());
            let counter = 0;
            let originalName = fileName.split('.');
            originalName.splice(originalName.length - 1, 0, counter.toString());
            while (fileNames.includes(fileName.toLowerCase())) {
                counter++;
                originalName[originalName.length - 2] = counter.toString();
                fileName = originalName.join('.');
            }
            targetServerRelativeUrl = `${targetFolderUrl}/${fileName}`;
        }
        let url = `${(0, common_1.GetRestBaseUrl)(siteUrl)}/web/getfilebyserverrelativeurl('${currentServerRelativeUrl}')/`;
        if (action === "copy") {
            url += `copyto(strNewUrl='${targetServerRelativeUrl}',bOverwrite=${options && options.overwrite ? "true" : "false"})`;
        }
        else {
            url += `moveto(newurl='${targetServerRelativeUrl}',flags=${options && options.overwrite ? 1 : 0})`;
        }
        let result = await (0, rest_1.GetJson)(url, undefined, {
            method: "POST",
            jsonMetadata: rest_types_1.jsonTypes.nometadata
        });
        logger.json(result, "CopyOrMoveFile");
        return true;
    }
    catch (e) {
        logger.json(e, "CopyOrMoveFile");
        return false;
    }
    //this does NOT allow to change the file extension. only file name.
    // return UpdateItem(siteUrl, listIdOrTitle, itemId, {
    //     FileLeafRef: newFileName "hello.txt" >> "hello.md" won't work.
    // });
}
//# sourceMappingURL=file.folder.js.map