feat(router): rilevamento duplicati pre-smistamento e instradamento in duplicati

services/unrouted.js

@@ -4,23 +4,52 @@ const os = require('os');
 
 const PRIMARY_UNROUTED_DIR = '/cadroute/__NON_SMISTATI';
 const HOME_UNROUTED_DIR = path.join(os.homedir(), '.cadroute', '__NON_SMISTATI');
+const PRIMARY_DUPLICATES_DIR = '/cadroute/duplicati';
+const HOME_DUPLICATES_DIR = path.join(os.homedir(), '.cadroute', 'duplicati');
 
-let resolvedUnroutedDirPromise = null;
+const SPECIAL_TARGETS = {
+  unrouted: {
+    primary: PRIMARY_UNROUTED_DIR,
+    fallback: HOME_UNROUTED_DIR,
+  },
+  duplicates: {
+    primary: PRIMARY_DUPLICATES_DIR,
+    fallback: HOME_DUPLICATES_DIR,
+  },
+};
 
-async function resolveUnroutedDir() {
-  if (!resolvedUnroutedDirPromise) {
-    resolvedUnroutedDirPromise = (async () => {
-      try {
-        await fs.ensureDir(PRIMARY_UNROUTED_DIR);
-        return PRIMARY_UNROUTED_DIR;
-      } catch {
-        await fs.ensureDir(HOME_UNROUTED_DIR);
-        return HOME_UNROUTED_DIR;
-      }
-    })();
+const resolvedDirs = new Map();
+
+async function resolveTargetDir(kind) {
+  const target = SPECIAL_TARGETS[kind];
+  if (!target) {
+    throw new Error(`Target speciale non supportato: ${kind}`);
   }
 
-  return resolvedUnroutedDirPromise;
+  if (!resolvedDirs.has(kind)) {
+    resolvedDirs.set(
+      kind,
+      (async () => {
+        try {
+          await fs.ensureDir(target.primary);
+          return target.primary;
+        } catch {
+          await fs.ensureDir(target.fallback);
+          return target.fallback;
+        }
+      })()
+    );
+  }
+
+  return resolvedDirs.get(kind);
+}
+
+async function resolveUnroutedDir() {
+  return resolveTargetDir('unrouted');
+}
+
+async function resolveDuplicatesDir() {
+  return resolveTargetDir('duplicates');
 }
 
 async function getUniquePath(destinationDir, fileName) {
@@ -36,8 +65,8 @@ async function getUniquePath(destinationDir, fileName) {
   return candidate;
 }
 
-async function getUnroutedTarget(fileName) {
-  const destinationDir = await resolveUnroutedDir();
+async function getTarget(kind, fileName) {
+  const destinationDir = await resolveTargetDir(kind);
   const destinationPath = await getUniquePath(destinationDir, fileName);
 
   return {
@@ -46,6 +75,14 @@ async function getUnroutedTarget(fileName) {
   };
 }
 
+async function getUnroutedTarget(fileName) {
+  return getTarget('unrouted', fileName);
+}
+
+async function getDuplicateTarget(fileName) {
+  return getTarget('duplicates', fileName);
+}
+
 async function listFilesRecursively(rootDir) {
   const files = [];
 
@@ -88,16 +125,45 @@ async function listFilesRecursively(rootDir) {
   return files;
 }
 
-async function listUnroutedFiles() {
-  const directory = await resolveUnroutedDir();
+async function listTargetFiles(kind) {
+  const directory = await resolveTargetDir(kind);
   const files = await listFilesRecursively(directory);
   return { directory, files };
 }
 
+async function clearTargetFiles(kind) {
+  const directory = await resolveTargetDir(kind);
+  await fs.emptyDir(directory);
+  return { directory };
+}
+
+async function listUnroutedFiles() {
+  return listTargetFiles('unrouted');
+}
+
+async function listDuplicateFiles() {
+  return listTargetFiles('duplicates');
+}
+
+async function clearUnroutedFiles() {
+  return clearTargetFiles('unrouted');
+}
+
+async function clearDuplicateFiles() {
+  return clearTargetFiles('duplicates');
+}
+
 module.exports = {
   getUnroutedTarget,
+  getDuplicateTarget,
   resolveUnroutedDir,
+  resolveDuplicatesDir,
   listUnroutedFiles,
+  listDuplicateFiles,
+  clearUnroutedFiles,
+  clearDuplicateFiles,
   PRIMARY_UNROUTED_DIR,
   HOME_UNROUTED_DIR,
+  PRIMARY_DUPLICATES_DIR,
+  HOME_DUPLICATES_DIR,
 };