File System

const fileSystemModule = require("tns-core-modules/file-system");

const documents = fileSystemModule.knownFolders.documents();
const folder = documents.getFolder(vm.get("folderName") || "testFolder");
const file = folder.getFile(`${(vm.get("fileName") || "testFile")}`.txt);

file.writeText(vm.get("fileTextContent") || "some random content")
    .then((result) => {
        file.readText()
            .then((res) => {
                vm.set("successMessage", `Successfully saved in${file.path}`);
                vm.set("writtenContent", res);
                vm.set("isItemVisible", true);
            });
    }).catch((err) => {
        console.log(err);
    });

file.remove()
    .then((res) => {
        // Success removing the file.
        vm.set("resultMessage", "File successfully deleted!");
    }).catch((err) => {
        console.log(err.stack);
    });

// Remove a folder and recursively its content.
myFolder.remove()
    .then((fres) => {
        // Success removing the folder.
        vm.set("resultMessage", "Folder successfully deleted!");
    }).catch((err) => {
        console.log(err.stack);
    });

myFolder.clear()
    .then((res) => {
        // Successfully cleared the folder.
        vm.set("resultMessage", "Folder successfully cleared!");
    }).catch((err) => {
        console.log(err.stack);
    });

let documentsFolder = fileSystemModule.knownFolders.documents();
const currentAppFolder = fileSystemModule.knownFolders.currentApp();
const tempFolder = fileSystemModule.knownFolders.temp();

const testPath = "///test.txt";
// Get a normalized path such as <folder.path>/test.txt from <folder.path>///test.txt
vm.set("documents", fileSystemModule.path.normalize(documentsFolder.path + testPath));
vm.set("currentApp", fileSystemModule.path.normalize(currentAppFolder.path + testPath));
vm.set("temp", fileSystemModule.path.normalize(tempFolder.path + testPath));

// Generate a path like <documents.path>/myFiles/test.txt
documentsFolder = fileSystemModule.knownFolders.documents();
const filePath = fileSystemModule.path.join(documentsFolder.path, "myFiles", "test.txt");

// An OS dependent path separator, "\" or "/".
const separator = fileSystemModule.path.separator;

const documentsFolder = fileSystemModule.knownFolders.documents();
const path = fileSystemModule.path.join(documentsFolder.path, "FileFromPath.txt");
const file = fileSystemModule.File.fromPath(path);

// Writing text to the file.
file.writeText(vm.get("textContentToBeSaved"))
    .then((result) => {
        // Succeeded writing to the file.
        file.readText().then((res) => {
            // Succeeded read from file.
            vm.set("isContentSaved", true);
            vm.set("savedContent", res);
            console.log(`File content:  ${res}`);
        });
    }).catch((err) => {
        console.log(err.stack);
    });

const folderPath = fileSystemModule.path.join(fileSystemModule.knownFolders.documents().path, "music");
const folder = fileSystemModule.Folder.fromPath(folderPath);

file.readText()
    .then((res) => {
        vm.set("writtenContent", res);
    }).catch((err) => {
        console.log(err.stack);
    });

const image = imageSourceModule.fromResource("icon");
const folder = fileSystemModule.knownFolders.documents();
const path = fileSystemModule.path.join(folder.path, "Test.png");
const saved = image.saveToFile(path, "png");

if (saved) {
    const imageFile = fileSystemModule.File.fromPath(path);
    const binarySource = imageFile.readSync((err) => {
        console.log(err);
    });
    console.log(this.binarySource);

imageFile.writeSync(binarySource, (err) => {
    console.log(err);
});

documents = fileSystemModule.knownFolders.documents();
documents.getEntities()
    .then((entities) => {
        // entities is array with the document's files and folders.
        entities.forEach((entity) => {
            array.push(
                {
                    name: entity.name,
                    path: entity.path,
                    lastModified: entity.lastModified.toString()
                }
            );
        });
    }).catch((err) => {
        // Failed to obtain folder's contents.
        console.log(err.stack);
    });

documents = fileSystemModule.knownFolders.documents();
const path = fileSystemModule.path.join(documents.path, "Text.txt");
const exists = fileSystemModule.File.exists(path);
console.log(`Does Text.txt exists: ${exists}`);

const temp = fileSystemModule.knownFolders.temp();
const tempExists = fileSystemModule.Folder.exists(temp.path);
console.log(`Does temp folder exists: ${tempExists}`);

const fileName = vm.get("fileName");
file.rename(`${fileName}.txt`)
    .then((res) => {
        // File Successfully Renamed.
        vm.set("fileSuccessMessage", `File renamed to:  ${fileName}.txt`);
        vm.set("isItemVisible", true);
    }).catch((err) => {
        // Error!
        console.log("Error: ");
        console.log(err);
        dialogs.alert(err)
        .then(() => {
            console.log("Dialog closed!");
        });
    });

const folderName = vm.get("folderName");
myFolder.rename(folderName)
    .then((res) => {
        // Folder Successfully Renamed.
        vm.set("folderSuccessMessage", `Folder renamed to:  ${folderName}`);
        vm.set("isFolderItemVisible", true);
    }).catch((err) => {
        // Error!
        console.log("Error: ");
        console.log(err);
        dialogs.alert(err)
        .then(() => {
            console.log("Dialog closed!");
        });
    });