311 lines
8.8 KiB
JavaScript
311 lines
8.8 KiB
JavaScript
/**
|
|
* la classe qui repère des patterns
|
|
*/
|
|
import exifr from 'exifr'
|
|
import moment from 'moment'
|
|
import log from 'loglevel'
|
|
import rangement_instance from '../conf/configs.js'
|
|
|
|
log.setLevel(rangement_instance.log_level)
|
|
|
|
/**
|
|
* finds patterns for file name
|
|
*/
|
|
export default class finder {
|
|
|
|
static statistics = {
|
|
filesModified: 0,
|
|
filesNotModified: 0,
|
|
}
|
|
|
|
static reportStatistics () {
|
|
log.info('\n --------- statistics',
|
|
this.statistics)
|
|
}
|
|
|
|
static findScreenshot (inputString) {
|
|
return inputString.match(/screenshot/i) || inputString.match(/capture d'écran/i)
|
|
}
|
|
|
|
static findFormattedDate (filepath) {
|
|
let match = filepath.match(/\d{4}-\d{2}-\d{2}T\d{2}\.\d{2}\.\d{2}/ig)
|
|
log.debug(' finder - match findFormattedDate', match)
|
|
let result = ''
|
|
if (match && match[0]) {
|
|
result = match[0]
|
|
}
|
|
return result
|
|
}
|
|
|
|
static findFileExtension (inputString) {
|
|
let result = inputString.match(/\.\w{3,4}$/i)
|
|
if (result.length) {
|
|
return result[0]
|
|
}
|
|
return ''
|
|
}
|
|
|
|
/**
|
|
* find the section of file name which contains the free text to describe the picture
|
|
* @param fileName
|
|
* @returns {*|string}
|
|
*/
|
|
static findFileNameFreeTextPart (fileName) {
|
|
fileName = fileName.replace(this.findFileExtension(fileName), '')
|
|
let boom = fileName.split(rangement_instance.tagSectionSeparator)
|
|
if (boom.length) {
|
|
let freeTextPart = boom[0].trim()
|
|
// remove date
|
|
let foundDate = this.findFormattedDate(freeTextPart)
|
|
if (foundDate) {
|
|
freeTextPart = freeTextPart.replace(foundDate, '').trim()
|
|
}
|
|
log.debug(' finder - freeTextPart:', freeTextPart)
|
|
return freeTextPart
|
|
}
|
|
return fileName.trim()
|
|
}
|
|
|
|
/**
|
|
* find an array of tags
|
|
* @param inputString
|
|
* @returns {[]}
|
|
*/
|
|
static findTagSectionInString (inputString) {
|
|
let listOfTags = []
|
|
// remove extension
|
|
let extensionFile = finder.findFileExtension(inputString)
|
|
|
|
if (extensionFile) {
|
|
|
|
inputString = inputString.replace(extensionFile, '')
|
|
} else {
|
|
log.debug(' finder - no extensionFile', extensionFile, inputString)
|
|
extensionFile = ''
|
|
}
|
|
inputString = inputString.replace(extensionFile, '')
|
|
|
|
log.debug(' finder - extensionFile', extensionFile)
|
|
if (inputString.includes(rangement_instance.tagSectionSeparator)) {
|
|
log.debug(' finder - inputString', inputString)
|
|
if (inputString.length) {
|
|
|
|
let boom = inputString.split(rangement_instance.tagSectionSeparator)
|
|
log.debug(' finder - boom', boom)
|
|
if (boom.length) {
|
|
let fileSectionsName = boom.splice(rangement_instance.tagSeparator)
|
|
listOfTags = [...fileSectionsName[1].trim().split(rangement_instance.tagSeparator)]
|
|
log.debug(' finder - listOfTags', listOfTags)
|
|
} else {
|
|
log.debug(' finder - no boom', boom)
|
|
}
|
|
}
|
|
}
|
|
return listOfTags
|
|
}
|
|
|
|
static removeTagInProperties (properties, tagName) {
|
|
|
|
let foundTagNameIndex = properties.tags.indexOf(tagName)
|
|
if (foundTagNameIndex) {
|
|
delete properties.tags[foundTagNameIndex]
|
|
}
|
|
return properties
|
|
}
|
|
|
|
static cleanSpaces (inputString) {
|
|
return inputString.trim().replace(/ *g/, ' ').replace(/ /, ' ')
|
|
}
|
|
|
|
static searchAndReplaceInFileName (searchString, replaceString, fileName) {
|
|
return this.cleanSpaces(fileName.replace(searchString, replaceString))
|
|
}
|
|
|
|
/**
|
|
* search screenshot clues and rename
|
|
*/
|
|
static searchAndRenameScreenshots (fileName) {
|
|
if (finder.findScreenshot(fileName)) {
|
|
let tags = this.findTagSectionInString(fileName)
|
|
log.debug(' finder - tags', tags)
|
|
if (!tags.includes('screenshot')) {
|
|
|
|
fileName = this.addTagInFileName('screenshot', fileName)
|
|
fileName = this.searchAndReplaceInFileName('Screenshot', '', fileName)
|
|
log.debug(' finder - screenShotMockFileName:', fileName)
|
|
return this.cleanSpaces(fileName)
|
|
}
|
|
log.debug(' finder - is a screenshot, remove screenshot in name, and add tag screenshot')
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
|
|
/**
|
|
* determines if we must add or remove new tags
|
|
* @param tagCommand
|
|
* @returns {{tagsToAdd: [], tagCommand: *, tagsToRemove: []}}
|
|
*/
|
|
static addOrRemoveTagsParsing (tagCommand) {
|
|
let tagsToAdd = []
|
|
let tagsToRemove = []
|
|
|
|
// split all tags
|
|
let listOfTags = tagCommand.split(' ')
|
|
listOfTags.forEach(elem => {
|
|
// remove when a minus is present*
|
|
if (elem.indexOf('-')) {
|
|
tagsToRemove.push(elem)
|
|
} else {
|
|
// add tag otherwise
|
|
tagsToAdd.push(elem)
|
|
}
|
|
})
|
|
|
|
return { tagCommand, tagsToAdd, tagsToRemove }
|
|
}
|
|
|
|
static applyTagChangesOnProperties(tagChange, properties){
|
|
|
|
properties.tags = [...properties.tags, tagChange.tagsToAdd]
|
|
properties.tags.filter(elem=>{
|
|
return tagChange.tagsToRemove.includes(elem)
|
|
})
|
|
return properties
|
|
}
|
|
|
|
/**
|
|
* add a tag and gives new filename with extension
|
|
* @param tagName
|
|
* @param fileName
|
|
* @returns {*}
|
|
*/
|
|
static addTagInFileName (tagName, fileName) {
|
|
|
|
let tags = this.findTagSectionInString(fileName)
|
|
let firstPart = this.findFileNameFreeTextPart(fileName)
|
|
|
|
tags.push(tagName)
|
|
let uniqueArray = [...new Set(tags)]
|
|
|
|
let newFileName = firstPart + ' ' + rangement_instance.tagSectionSeparator + ' ' + uniqueArray.join(rangement_instance.tagSeparator)
|
|
newFileName = newFileName.replace(/ {*}/, '') + this.findFileExtension(fileName)
|
|
return this.cleanSpaces(newFileName)
|
|
}
|
|
|
|
/**
|
|
* convertit un nom de fichier en une structure décrivant plusieurs parties correspondant au pattern d'archivage
|
|
* @param fullPath
|
|
* @returns {{extension: *, dateStamp: string, freeText: (*|string), tags: *[]}}
|
|
*/
|
|
static destructurateFileName (fullPath) {
|
|
let [folderPath, fileNameOriginal] = this.findFolderPath(fullPath)
|
|
let dateStampInFileNameOriginal = this.findFormattedDate(fileNameOriginal)
|
|
return {
|
|
fullPath,
|
|
folderPath,
|
|
fileNameOriginal,
|
|
dateStampInFileNameOriginal,
|
|
dateStampExif: '',
|
|
freeText: this.findFileNameFreeTextPart(fileNameOriginal),
|
|
tags: this.findTagSectionInString(fileNameOriginal),
|
|
extension: this.findFileExtension(fileNameOriginal),
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* finds the earliest part in several exif date info
|
|
* @param exifData
|
|
* @returns {string}
|
|
*/
|
|
static findEarliestDateInExifData (exifData) {
|
|
log.debug(' finder - findEarliestDateInExifData')
|
|
if (exifData) {
|
|
|
|
let moments = []
|
|
|
|
log.debug(' finder - exif data : ', exifData) // Do something with your data!
|
|
if (exifData.DateTimeOriginal) {
|
|
log.debug(' finder - image créée le : DateTimeOriginal : ', exifData.DateTimeOriginal) // Do something with your data!
|
|
moments.push(exifData.DateTimeOriginal)
|
|
}
|
|
if (exifData.ModificationDateTime) {
|
|
log.debug(' finder - image créée le : ModificationDateTime : ', exifData.ModificationDateTime) // Do something with your data!
|
|
moments.push(exifData.ModificationDateTime)
|
|
}
|
|
if (exifData.ModifyDate) {
|
|
log.debug(' finder - image créée le : ModifyDate : ', exifData.ModifyDate) // Do something with your data!
|
|
moments.push(exifData.ModifyDate)
|
|
}
|
|
if (exifData.FileAccessDateTime) {
|
|
moments.push(exifData.FileAccessDateTime)
|
|
}
|
|
if (exifData.FileInodeChangeDateTime) {
|
|
moments.push(exifData.FileInodeChangeDateTime)
|
|
}
|
|
if (exifData.FileModificationDateTime) {
|
|
log.debug(' finder - image créée le : FileModificationDateTime : ', exifData.FileModificationDateTime) // Do something with your data!
|
|
moments.push(exifData.FileModificationDateTime)
|
|
}
|
|
if (exifData.CreateDate) {
|
|
log.debug(' finder - image créée le : CreateDate : ', exifData.CreateDate) // Do something with your data!
|
|
moments.push(exifData.CreateDate)
|
|
}
|
|
|
|
moments = moments.map(d => {
|
|
let newdate = moment(d)
|
|
return newdate
|
|
})
|
|
let minDate = moment.min(moments)
|
|
|
|
log.debug(' finder - minDate :::::::::', minDate)
|
|
log.info(' finder - minDate :::::::::', minDate.format(rangement_instance.iso_date_format))
|
|
|
|
return minDate.format(rangement_instance.iso_date_format)
|
|
} else {
|
|
log.debug(' finder - /!\\ pas de exif data')
|
|
return ''
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static appendFileName (fileProperties, newText) {
|
|
fileProperties.freeText = finder.cleanSpaces(fileProperties.freeText + ' ' + newText)
|
|
return fileProperties
|
|
}
|
|
|
|
static prependFileName (fileProperties, newText) {
|
|
fileProperties.freeText = finder.cleanSpaces(newText + ' ' + fileProperties.freeText)
|
|
return fileProperties
|
|
}
|
|
|
|
/**
|
|
* examine plusieurs propriétés exif de date et retourne la plus ancienne
|
|
* @param filepath
|
|
*/
|
|
static async findExifCreationDate (filepath) {
|
|
|
|
log.debug(' finder - filepath', filepath)
|
|
let dateAlreadyInFileName = finder.findFormattedDate(filepath)
|
|
if (dateAlreadyInFileName) {
|
|
|
|
log.debug(' finder - ------ dateAlreadyInFileName', dateAlreadyInFileName)
|
|
}
|
|
|
|
return await exifr.parse(filepath)
|
|
|
|
}
|
|
|
|
static findFolderPath (filePath) {
|
|
let folders = filePath.split('/')
|
|
let fileName = folders.pop()
|
|
folders = filePath.replace(fileName, '')
|
|
|
|
log.debug(' finder - \n - folders', folders)
|
|
log.debug(' finder - - fileName', fileName, '\n')
|
|
return [folders, fileName]
|
|
|
|
}
|
|
} |