rangement/index.mjs

/**---------------------
 * @name tykayn Rangement
 * @description Rangement sorts and rename files depending on their exif data
 * @contact contact@cipherbliss.com
 --------------------- */
/** ---------------------
 libs
 --------------------- */
import fs from 'node-fs'
import minimist from 'minimist'
import log from 'loglevel';
import path from "node:path";
/** ---------------------
 custom utilities and configuration
 --------------------- */
import rangement_instance from './configs.mjs'
import {
    TestFindFormattedDate,
    TestScreenShotIsFoundAndRenamed,
    TestTagsAreDetectedInFileName
} from './testFunctions.mjs'
import finder from './finder.mjs'

import exiftool from "node-exiftool";

let mini_arguments

log.setLevel(rangement_instance.log_level)
log.info(' ')

function parseArguments() {
    mini_arguments = minimist(process.argv.slice(2))
    log.debug('arguments', mini_arguments)
}

function addOriginalFileNameIfMissing(originalFileName, fileMixedNewName) {

    const ep = new exiftool.ExiftoolProcess()

    ep
        .open(fileMixedNewName)
        .then(() => ep.writeMetadata(fileMixedNewName, {
            'OriginalFileName+': originalFileName,
        }))
        .then(console.log, console.error)
        .then(() => ep.close())
        .catch(console.error)
}

function renameFile(originalFileName, fileMixedNewName) {
    fs.rename(originalFileName, fileMixedNewName, function (err) {
        log.info('name changed', fileMixedNewName)
        if (err) {
            log.info('rename ERROR: ' + err)
        } else {
            addOriginalFileNameIfMissing(originalFileName, fileMixedNewName)
            rangement_instance.statistics['filesModified']++
        }
    })
}

function appendFileName(fileProperties, newText) {
    fileProperties.freeText = finder.cleanSpaces(fileProperties.freeText + ' ' + newText)
    return fileProperties
}

function prependFileName(fileProperties, newText) {
    fileProperties.freeText = finder.cleanSpaces(newText + ' ' + fileProperties.freeText)
    return fileProperties
}

function makeFileNameFromProperties(fileProperties) {

    let tagPlace = ''
    if (fileProperties.tags.length) {
        tagPlace = ' ' + rangement_instance.tagSectionSeparator + ' '
    }
    return '' + fileProperties.dateStampExif + ' ' + fileProperties.freeText + tagPlace + fileProperties.tags.join(tagSeparator) + fileProperties.extension
}

function shouldWeChangeName(structureForFile) {
    log.info(' ______ allez hop fini la recherche on fait un nouveau nom')
    log.info('structureForFile', structureForFile)
    let newName = makeFileNameFromProperties(structureForFile)
    if (structureForFile.fileNameOriginal !== newName) {

        log.info('\n ancien nom :', structureForFile.fileNameOriginal)

        log.info(' nouveau nom:', newName)
        if (!mini_arguments['dry-run']) {
            renameFile(structureForFile.fullPath, structureForFile.folderPath + newName)
        } else {
            log.info('no renaming for real, this is a dry run')
        }
    } else {
        log.info(' rien à changer')
    }

}

/**
 * guess file name on one file which is not a directory
 * @param fullPath
 */
function guessFileNameOnOnefile(fullPath) {

    fs.stat(fullPath, (err, stats) => {

        if (err) {
            log.error('échec fichier', err)
            log.error('ce fichier n existe pas: ', fullPath)
            return;
        } else {

            let structureForFile = finder.destructurateFileName(fullPath)

            // examiner les infos exif de chaque fichier pour proposer un nouveau nom
            if (!structureForFile.dateStampInFileNameOriginal) {
                log.debug('    le nom de fichier ne contient pas de date formatée au début')

                finder.findExifCreationDate(structureForFile.fullPath)
                    .then(data => {
                            log.debug(' ... chercher la date de création')
                            let foundDate = finder.findEarliestDateInExifData(data)

                            log.info(' =>>>>>>> foundDate : ', foundDate)
                            if (foundDate) {
                                structureForFile.dateStampExif = foundDate
                                shouldWeChangeName(structureForFile)

                            } else {
                                log.info('pas de date trouvée dans le nom')
                            }

                        }
                        ,
                        (error) => {
                            log.warn('/////////// Error in reading exif of file: ' + error.message)
                            return ''
                        })
            }

        }
    })
}

let expandedFileList = []
let cwd = path.dirname(process.cwd()) + '/' + path.basename(process.cwd());
console.log('cwd', cwd)

function guessFileNameOnAllFilesFromArguments() {


    // parcourir les fichiers
    log.debug('liste des fichiers', mini_arguments._)
    let fileList = mini_arguments._


    // test file exists
    fileList.forEach(fullPath => {
            // parcourir les dossiers
            isFolderOrFile(`${fullPath}`)
        }
    )

    log.info('expanded file list :', expandedFileList)
    expandedFileList.forEach(filePath => guessFileNameOnOnefile(filePath))

}

function readSubdirectories(baseDir) {
    const newGlob = baseDir;
    let fileList = [];
    fs.readdir(baseDir, (err, files) => {
        if (err) throw err;

        console.log('files', files)
        files.forEach((subDirOrFile) => {
            const newFullPath = path.resolve(baseDir, subDirOrFile);

            if (fs.existsSync(newFullPath)) {
                const s = fs.statSync(newFullPath);

                if (s.isFile()) {
                    fileList.push(cwd+'/'+subDirOrFile)
                }
            }
        });
        return fileList
    });
    return fileList
}

function isFolderOrFile(fileName) {
    const stat = fs.statSync(cwd + '/' + fileName);

    if (stat.isDirectory()) {
        let fileList = readSubdirectories(fileName);
        console.log('fileList in directory ',fileName, '\n', fileList)
        if (fileList) {
            expandedFileList.push(...fileList)
        }
    }
    else if (stat.isFile()) {
        expandedFileList.push(cwd + '/' + fileName)
    }
}

parseArguments()

guessFileNameOnAllFilesFromArguments()


// run tests
if (rangement_instance.enableTestsLocally) {

    TestTagsAreDetectedInFileName()
    TestFindFormattedDate()
    TestScreenShotIsFoundAndRenamed()
}
if (rangement_instance.reportStatistics || mini_arguments.stats) {
    finder.reportStatistics()
}