serv_benchmark/docs/FEATURE_UTILISATION_FIELD.md

Champ "Utilisation" pour les périphériques

Contexte

Chaque périphérique peut être soit en stockage, soit utilisé par un appareil/hôte spécifique. Le champ utilisation permet de tracer où chaque périphérique est utilisé.

Implémentation

1. Migration base de données

Fichier: migrations/015_add_utilisation.sql

ALTER TABLE peripherals ADD COLUMN utilisation VARCHAR(255);
CREATE INDEX idx_peripherals_utilisation ON peripherals(utilisation);

Application:

python3 backend/apply_migration_015.py

2. Modèle mis à jour

Fichier: backend/app/models/peripheral.py (ligne 60)

etat = Column(String(50), default="Neuf", index=True)
localisation = Column(String(255))
proprietaire = Column(String(100))
utilisation = Column(String(255))  # Host from host.yaml or "non-utilisé"  ← NOUVEAU
tags = Column(Text)
notes = Column(Text)

3. Schéma mis à jour

Fichier: backend/app/schemas/peripheral.py

PeripheralBase (ligne 46):

etat: Optional[str] = Field("Neuf", max_length=50)
localisation: Optional[str] = Field(None, max_length=255)
proprietaire: Optional[str] = Field(None, max_length=100)
utilisation: Optional[str] = Field(None, max_length=255)  # ← NOUVEAU
tags: Optional[str] = None

PeripheralUpdate (ligne 132):

etat: Optional[str] = Field(None, max_length=50)
localisation: Optional[str] = Field(None, max_length=255)
proprietaire: Optional[str] = Field(None, max_length=100)
utilisation: Optional[str] = Field(None, max_length=255)  # ← NOUVEAU
tags: Optional[str] = None

4. Configuration des hôtes

Fichier: config/host.yaml

hosts:
  - nom: Bureau-PC
    localisation: Bureau
  - nom: Serveur-NAS
    localisation: Salon
  - nom: Atelier-RPi
    localisation: Atelier
  - nom: Portable-Work
    localisation: Bureau

Les hôtes définis ici apparaissent dans le menu déroulant du champ "Utilisation".

5. API Endpoint

Fichier: backend/app/api/endpoints/peripherals.py (lignes 105-120)

@router.get("/config/hosts", response_model=dict)
def get_hosts():
    """
    Get hosts list from host.yaml configuration.
    Returns list of hosts with their names and locations.
    """
    try:
        hosts = yaml_loader.get_hosts()

        return {
            "success": True,
            "hosts": hosts
        }

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to load hosts: {str(e)}")

Route: GET /api/peripherals/config/hosts

Réponse:

{
  "success": true,
  "hosts": [
    {"nom": "Bureau-PC", "localisation": "Bureau"},
    {"nom": "Serveur-NAS", "localisation": "Salon"},
    {"nom": "Atelier-RPi", "localisation": "Atelier"},
    {"nom": "Portable-Work", "localisation": "Bureau"}
  ]
}

6. Frontend

HTML - frontend/peripherals.html (lignes 243-251)

<div class="form-group">
    <label for="utilisation">
        Utilisation
        <span class="help-text-inline">(Hôte ou appareil)</span>
    </label>
    <select id="utilisation" name="utilisation">
        <option value="">Chargement...</option>
    </select>
</div>

JavaScript - frontend/js/peripherals.js

Fonction de chargement des hosts (lignes 1262-1283):

// Cache for hosts from API
let hostsCache = null;

// Load hosts from API
async function loadHostsFromAPI() {
    if (hostsCache) {
        return hostsCache;
    }

    try {
        const result = await apiRequest('/peripherals/config/hosts');
        if (result.success && result.hosts) {
            hostsCache = result.hosts;
            return result.hosts;
        }
    } catch (error) {
        console.error('Failed to load hosts from API:', error);
    }

    // Fallback to default if API fails
    return [];
}

Fonction de chargement des options (lignes 1285-1309):

// Load utilisation options (hosts + "Non utilisé")
async function loadUtilisationOptions() {
    const utilisationSelect = document.getElementById('utilisation');
    if (!utilisationSelect) return;

    // Clear current options
    utilisationSelect.innerHTML = '';

    // Add "Non utilisé" as first option
    const nonUtiliseOption = document.createElement('option');
    nonUtiliseOption.value = 'Non utilisé';
    nonUtiliseOption.textContent = 'Non utilisé';
    utilisationSelect.appendChild(nonUtiliseOption);

    // Load hosts from API
    const hosts = await loadHostsFromAPI();

    // Add each host as an option
    hosts.forEach(host => {
        const option = document.createElement('option');
        option.value = host.nom;
        option.textContent = `${host.nom}${host.localisation ? ' (' + host.localisation + ')' : ''}`;
        utilisationSelect.appendChild(option);
    });
}

Appel au chargement (ligne 535):

async function showAddModal() {
    document.getElementById('form-add-peripheral').reset();
    document.getElementById('modal-add').style.display = 'block';
    await loadUtilisationOptions();  // Load hosts from host.yaml
    updateUtilisationFields();
    updatePhotoUrlAddUI();
}

Sauvegarde de la valeur (lignes 566-568):

// Handle utilisation field - store the host name or "Non utilisé"
const utilisation = document.getElementById('utilisation')?.value || 'Non utilisé';
data.utilisation = utilisation;

Utilisation

Ajouter/Modifier un périphérique

1. Ouvrir le formulaire d'ajout/modification
2. Dans la section "État et localisation", le champ Utilisation affiche:
   • Non utilisé (par défaut)
   • Bureau-PC (Bureau)
   • Serveur-NAS (Salon)
   • Atelier-RPi (Atelier)
   • Portable-Work (Bureau)
3. Sélectionner l'hôte où le périphérique est utilisé
4. Enregistrer

Ajouter un nouvel hôte

Pour ajouter un nouvel hôte dans la liste:

1. Éditer le fichier config/host.yaml
2. Ajouter une entrée:

   - nom: Nouveau-PC
     localisation: Chambre
   

3. Redémarrer le backend (si en développement) ou attendre le rechargement automatique
4. Le nouvel hôte apparaîtra automatiquement dans le menu déroulant

Exemples de valeurs

Valeur	Description
Non utilisé	Périphérique en stockage
Bureau-PC	Périphérique utilisé par le PC du bureau
Serveur-NAS	Périphérique utilisé par le serveur NAS
Atelier-RPi	Périphérique utilisé par le Raspberry Pi de l'atelier
Portable-Work	Périphérique utilisé par l'ordinateur portable de travail

Bénéfices

✅ Traçabilité: Savoir où chaque périphérique est utilisé ✅ Configuration centralisée: Les hôtes sont définis dans host.yaml ✅ Interface simplifiée: Menu déroulant au lieu de saisie libre ✅ Cohérence: Évite les fautes de frappe et les variations (ex: "bureau-pc" vs "Bureau PC") ✅ Extensible: Facile d'ajouter de nouveaux hôtes ✅ Indexé: Recherches rapides par utilisation

Requêtes utiles

Trouver tous les périphériques non utilisés

peripherals = session.query(Peripheral).filter(
    Peripheral.utilisation == 'Non utilisé'
).all()

Trouver tous les périphériques d'un hôte

peripherals = session.query(Peripheral).filter(
    Peripheral.utilisation == 'Bureau-PC'
).all()

Compter les périphériques par hôte

from sqlalchemy import func

stats = session.query(
    Peripheral.utilisation,
    func.count(Peripheral.id)
).group_by(Peripheral.utilisation).all()

Fichiers modifiés

1. migrations/015_add_utilisation.sql - Migration SQL
2. backend/apply_migration_015.py - Script d'application
3. backend/app/models/peripheral.py - Ajout du champ
4. backend/app/schemas/peripheral.py - Ajout au schéma (2 endroits)
5. backend/app/api/endpoints/peripherals.py - Endpoint /config/hosts
6. frontend/peripherals.html - Modification du select
7. frontend/js/peripherals.js - Chargement dynamique des options

Migration des données existantes

Si des périphériques existaient avant l'ajout du champ:

• La valeur par défaut est NULL
• Recommandé de définir à 'Non utilisé' pour les périphériques en stockage

UPDATE peripherals SET utilisation = 'Non utilisé' WHERE utilisation IS NULL;

Conclusion

Le champ utilisation permet un suivi précis de l'emplacement et de l'usage de chaque périphérique, avec une gestion centralisée des hôtes via le fichier host.yaml et un chargement dynamique dans l'interface.