cad-data-router/sop.md

SOP – CAD File Router MVP

Obiettivo

Realizzare un'app desktop (.exe) che:

• accetti una cartella o uno ZIP
• legga file CAD (.prt .asm .drw)
• analizzi nome file ed estensione
• applichi regole di routing
• copi i file verso destinazioni configurate (anche share di rete)

Tecnologie:

• Node.js
• Electron
• unzipper
• fs-extra

---

1. Prerequisiti

Installare:

• Node.js LTS
• Git
• Visual Studio Code / VSCodium

Verifica:

node -v
npm -v

---

2. Creazione progetto

mkdir cad-file-router
cd cad-file-router
npm init -y

Installare dipendenze:

npm install electron unzipper fs-extra
npm install electron-builder --save-dev

---

3. Struttura progetto

cad-file-router
│
├── package.json
├── main.js
├── preload.js
│
├── renderer
│   ├── index.html
│   └── renderer.js
│
├── services
│   ├── router.js
│   ├── zipProcessor.js
│   ├── folderProcessor.js
│   └── configService.js
│
└── config
    └── defaultConfig.json

---

4. Configurazione iniziale

config/defaultConfig.json

{
  "rules": [
    {
      "ext": "prt",
      "pattern": "^1",
      "destination": "\\\\SERVER-CAD\\clienti1\\PRT"
    },
    {
      "ext": "prt",
      "pattern": "^6",
      "destination": "\\\\SERVER-CAD\\clienti2\\PRT"
    },
    {
      "ext": "asm",
      "destination": "\\\\SERVER-CAD\\assembly"
    },
    {
      "ext": "drw",
      "destination": "\\\\SERVER-CAD\\drawing"
    }
  ]
}

---

5. Config Service

services/configService.js

const fs = require("fs-extra")
const path = require("path")
const os = require("os")

const configPath = path.join(os.homedir(), ".cad-router-config.json")

function loadConfig(){

    if(fs.existsSync(configPath)){
        return fs.readJsonSync(configPath)
    }

    const defaultConfig = fs.readJsonSync(
        path.join(__dirname,"../config/defaultConfig.json")
    )

    fs.writeJsonSync(configPath, defaultConfig)

    return defaultConfig
}

module.exports = { loadConfig }

---

6. Motore di routing

services/router.js

const path = require("path")

function findDestination(filename, config){

    const ext = path.extname(filename).slice(1)

    for(const rule of config.rules){

        if(rule.ext !== ext)
            continue

        if(!rule.pattern)
            return rule.destination

        const regex = new RegExp(rule.pattern)

        if(regex.test(filename))
            return rule.destination
    }

    return null
}

module.exports = { findDestination }

---

7. Processare una cartella

services/folderProcessor.js

const fs = require("fs-extra")
const path = require("path")
const { findDestination } = require("./router")

async function processFolder(folder, config){

    const files = await fs.readdir(folder)

    for(const file of files){

        const src = path.join(folder,file)

        const destDir = findDestination(file, config)

        if(!destDir) continue

        const dest = path.join(destDir,file)

        await fs.copy(src,dest)
    }
}

module.exports = { processFolder }

---

8. Processare ZIP

services/zipProcessor.js

const unzipper = require("unzipper")
const fs = require("fs-extra")
const path = require("path")
const { findDestination } = require("./router")

async function processZip(zipPath, config){

    const stream = fs.createReadStream(zipPath)
        .pipe(unzipper.Parse())

    for await (const entry of stream){

        const file = entry.path

        const destDir = findDestination(file, config)

        if(!destDir){
            entry.autodrain()
            continue
        }

        const dest = path.join(destDir,path.basename(file))

        entry.pipe(fs.createWriteStream(dest))
    }
}

module.exports = { processZip }

---

9. Main Electron

main.js

const { app, BrowserWindow, dialog, ipcMain } = require("electron")
const path = require("path")

const { processFolder } = require("./services/folderProcessor")
const { processZip } = require("./services/zipProcessor")
const { loadConfig } = require("./services/configService")

let config = loadConfig()

function createWindow(){

    const win = new BrowserWindow({
        width:800,
        height:600,
        webPreferences:{
            preload: path.join(__dirname,"preload.js")
        }
    })

    win.loadFile("renderer/index.html")
}

app.whenReady().then(createWindow)

ipcMain.handle("select-folder", async () => {

    const result = await dialog.showOpenDialog({
        properties:["openDirectory"]
    })

    if(result.canceled) return

    await processFolder(result.filePaths[0], config)

})

ipcMain.handle("select-zip", async () => {

    const result = await dialog.showOpenDialog({
        filters:[{ name:"Zip", extensions:["zip"] }]
    })

    if(result.canceled) return

    await processZip(result.filePaths[0], config)

})

---

10. Preload

preload.js

const { contextBridge, ipcRenderer } = require("electron")

contextBridge.exposeInMainWorld("api", {

    selectFolder: () => ipcRenderer.invoke("select-folder"),

    selectZip: () => ipcRenderer.invoke("select-zip")

})

---

11. UI minima

renderer/index.html

<h2>CAD File Router</h2>

<button onclick="window.api.selectFolder()">
Process Folder
</button>

<button onclick="window.api.selectZip()">
Process ZIP
</button>

---

12. Avvio applicazione

Nel package.json aggiungere:

"scripts": {
  "start": "electron ."
}

Avviare:

npm start

---

13. Build .exe

Aggiungere nel package.json:

"build": {
  "appId": "com.cad.router",
  "win": {
    "target": "nsis"
  }
}

Build:

npx electron-builder

Output:

dist/
   cad-file-router Setup.exe

---

MVP completato quando

• l'app si avvia
• si seleziona ZIP o cartella
• i file .prt .asm .drw vengono analizzati
• i file vengono copiati nelle destinazioni configurate

---

Migliorie future

• progress bar
• drag and drop ZIP
• modifica regole da UI
• logging operazioni
• parallelismo file
• watch folder automatico