BrickFinder Le catalogue & le cerveau

MONGO_URI=mongodb+srv://user:motdepasse@cluster0.xxxx.mongodb.net/brickfinder

npm install mongoose

import mongoose from "mongoose"

export async function connecterBase() {
  await mongoose.connect(process.env.MONGO_URI)
  console.log("Base connectée")
}

import { connecterBase } from "./db.js"
await connecterBase()

import mongoose from "mongoose"

const PieceSchema = new mongoose.Schema({
  type: String,
  couleur: String,
  quantite: Number
}, { _id: false })

const ModeleSchema = new mongoose.Schema({
  setNum: { type: String, unique: true },
  nom: String,
  image: String,
  pieces: [PieceSchema]
})

export const Modele = mongoose.model("Modele", ModeleSchema)

REBRICKABLE_KEY=ta-cle-rebrickable

const KEY = process.env.REBRICKABLE_KEY
const setNum = "31147-1"
const url = `https://rebrickable.com/api/v3/lego/sets/${setNum}/parts/?key=${KEY}&page_size=1000`

const rep = await fetch(url)
const data = await rep.json()
console.log("Pièces reçues :", data.results.length)
console.log(data.results[0])

function normaliser(resultats) {
  return resultats.map(r => ({
    type: r.part.name,
    couleur: r.color.name,
    quantite: r.quantity
  }))
}

async function importerSet(setNum) {
  const base = "https://rebrickable.com/api/v3/lego"
  const key = process.env.REBRICKABLE_KEY

  // 1. les infos du set : son NOM et son IMAGE (la photo de la boîte !)
  const info = await (await fetch(`${base}/sets/${setNum}/?key=${key}`)).json()

  // 2. ses pièces
  const data = await (await fetch(`${base}/sets/${setNum}/parts/?key=${key}&page_size=1000`)).json()
  const pieces = normaliser(data.results)

  await Modele.findOneAndUpdate(
    { setNum },
    { setNum, nom: info.name, image: info.set_img_url, pieces },
    { upsert: true }
  )
  console.log(`Set ${setNum} (${info.name}) importé : ${pieces.length} types de pièces`)
}

app.post("/api/catalogue/:setNum", async (req, res) => {
  await importerSet(req.params.setNum)
  res.json({ importe: req.params.setNum })
})

// une clé "propre" : on compare malgré la casse et les espaces
function cle(type, couleur) {
  return `${type}|${couleur}`.toLowerCase().replace(/\s+/g, "")
}

function indexer(inventaire) {
  const index = {}
  for (const p of inventaire) {
    index[cle(p.type, p.couleur)] = p.quantite
  }
  return index
}

function evaluer(modele, index) {
  let ratioMin = Infinity
  const manquantes = []

  for (const piece of modele.pieces) {
    const dispo = index[cle(piece.type, piece.couleur)] || 0
    const ratio = dispo / piece.quantite
    if (ratio < ratioMin) ratioMin = ratio
    if (dispo < piece.quantite) {
      manquantes.push({ ...piece, manque: piece.quantite - dispo })
    }
  }

  return {
    nom: modele.nom,
    setNum: modele.setNum,
    image: modele.image,
    pourcentage: Math.round(Math.min(ratioMin, 1) * 100),
    constructible: manquantes.length === 0,
    manquantes
  }
}

async function faisabilite(inventaire) {
  const index = indexer(inventaire)
  const modeles = await Modele.find()
  return modeles
    .map(m => evaluer(m, index))
    .sort((a, b) => b.pourcentage - a.pourcentage)
}

app.post("/api/faisabilite", express.json(), async (req, res) => {
  const inventaire = req.body.inventaire
  if (!Array.isArray(inventaire)) {
    return res.status(400).json({ erreur: "inventaire (tableau) requis" })
  }
  const resultats = await faisabilite(inventaire)
  res.json({ resultats })
})

function listeDeCourses(resultats) {
  const total = {}
  for (const r of resultats) {
    for (const m of r.manquantes) {
      const cle = `${m.type}|${m.couleur}`
      total[cle] = (total[cle] || 0) + m.manque
    }
  }
  return Object.entries(total).map(([cle, manque]) => {
    const [type, couleur] = cle.split("|")
    return { type, couleur, manque }
  })
}