Delete files and folders in File Cabinet

REQUIREMENT

The client is facing an issue with the file cabinet storage space when pdf files are attached to the file cabinet when a large number of emails are sent. Need to delete the attachment files and their folders under a particular employee record that are created a month ago. Develop a scheduled script to delete the files and their folders created one month ago.

SOLUTION

/**
 * @NApiVersion 2.1
 * @NScriptType MapReduceScript
 */

define(["N/record", "N/search", "N/file"], /**
 * @param{record} record
 * @param{search} search
 * @param{file} file
 */
    (record, search, file) => {
        const getInputData = (inputContext) => {
            try {
                let getFoldersAndFiles = getFilesFromFileCabinet();
                if (getFoldersAndFiles.length > 0) {
                    return getFoldersAndFiles
                }
                else {
                    return []
                }
            } catch (err) {
                log.debug("error@getInputData", err);
                return []
            }
        };

        const map = (mapContext) => {
            try {
                let mapData = JSON.parse(mapContext.value)
                mapContext.write({
                    key: mapData.folderId,
                    value: mapData.fileId
                })
            }
            catch (err) {
                log.error("error@map", err)
            }
        }


        const reduce = (reduceContext) => {
            try {
               
                let folderId = reduceContext.key
                let fileId = reduceContext.values
                if (fileId.length > 0) {
                    for (let num = 0; num < fileId.length; num++) {
                        if (checkForParameter(fileId[num])) {
                            file.delete({
                                id: fileId[num]
                            });
                            log.debug("deleted fileId", fileId[num])
                        }
                    }
                }

                if (checkForParameter(folderId)) {
                    if (checkIfFolderIsEmpty(folderId)) {
                        record.delete({
                            type: record.Type.FOLDER,
                            id: folderId,
                        })
                    }
                }
            }
            catch (err) {
                log.error("error@Reduce", err)
                return []
            }
        };

       
        const summarize = (summaryContext) => {

        };



        function getFilesFromFileCabinet() {
            try {
                let runSearch = null;
                let fromRange = 0;
                let toRange = 0;
                let searchResults = null;
                let hasResults = true;

                let internalIdArray = []

                let folderSearchObj = search.create({
                    type: "folder",
                    filters:
                        [
                            ["parent", "anyof", "64278"],
                            "AND",
                            ["file.created", "before", "startofthismonth"],
                        ],
                    columns:
                        [
                            search.createColumn({ name: "internalid", label: "Internal ID" }),
                            search.createColumn({
                                name: "internalid",
                                join: "file",
                                label: "File Internal id"
                            })
                        ]



                });
                let searchResultCount = folderSearchObj.runPaged().count;
                log.debug("folderSearchObj result count", searchResultCount);

                runSearch = folderSearchObj.run()
                while (hasResults) {
                    fromRange = toRange;
                    toRange = fromRange + 1000;
                    searchResults = runSearch.getRange({ start: fromRange, end: toRange });

                    if (searchResults) {
                        if (searchResults.length < 1000) {
                            hasResults = false;
                        }

                        for (let count = 0; count < searchResults.length; count++) {
                            let folderSearchResultsObj = {}
                            folderSearchResultsObj.folderId = searchResults[count].getValue({ name: "internalid", label: "Internal ID" })
                            if (checkForParameter(searchResults[count].getValue({ name: "internalid", label: "Internal ID" }))) {
                                folderSearchResultsObj.fileId = searchResults[count].getValue({
                                    name: "internalid",
                                    join: "file",
                                    label: "File Internal id"
                                })
                            }

                            internalIdArray.push(folderSearchResultsObj);

                        }
                    } else {
                        hasResults = false;
                    }
                }

                if (internalIdArray.length > 0) {
                    log.debug("internalIdArray", internalIdArray)
                    return internalIdArray
                }
                else {
                    return []
                }

            } catch (err) {
                log.error("Error@getFilesFromFileCabinet", err);
                return []
            }
        }


        function checkForParameter(parameter) {

            if (parameter !== "" && parameter !== null && parameter !== undefined && parameter !== false && parameter !== "null" && parameter !== "undefined" && parameter !== " " && parameter !== 'false') {
                return true;
            }

        }



        function checkIfFolderIsEmpty(folderId) {
            try {
                let folderSearchObj = search.create({
                    type: "folder",
                    filters:
                        [
                            ["parent", "anyof", "64278"],
                            "AND",
                            ["internalid", "anyof", folderId],
                            "AND",
                            ["file.internalid", "noneof", "@NONE@"]
                        ],
                    columns:
                        [
                            search.createColumn({ name: "internalid", label: "Internal ID" }),
                            search.createColumn({
                                name: "internalid",
                                join: "file",
                                label: "File Internal id"
                            })
                        ]
                });
                let searchResultCount = folderSearchObj.runPaged().count;
                log.debug("searchResultCount folder contents", searchResultCount)
                if (searchResultCount > 0) {
                    return false
                }
                else {
                    return true
                }
            }
            catch (err) {
                log.error("error@checkIfFolderIsEmpty", err)
                return false
            }
        }

        return { getInputData, map, reduce, summarize };
    });