# Analytique - créer des tables attributaires
### **C'est parti ! On va donner une dimension analytique à ton SIG. On procède en trois étapes rapides.**
### Étape 1 : Préparer la Base de Données
On va ajouter la colonne `surface_m2` et mettre à jour tes données actuelles.
1. **Connecte-toi à la base** :
*(Entre ton mot de passe `Julien...`)*
- **Exécute ces deux commandes SQL** :
SQL
```
-- 1. Ajoute la colonne pour stocker le calcul
ALTER TABLE zones_interet ADD COLUMN surface_m2 FLOAT;
-- 2. Calcule la surface pour les zones que tu as déjà dessinées
-- On utilise ::geography pour forcer le calcul en mètres (et pas en degrés)
UPDATE zones_interet SET surface_m2 = ST_Area(geom::geography);
```
- Quitte avec `\q`.
Voici le contenu intégral et optimisé pour ton fichier **`server.js`**. Il inclut la gestion des fichiers statiques, la route de récupération avec les surfaces, la vérification de clic et la nouvelle route de sauvegarde avec calcul PostGIS.
JavaScript
```
const express = require('express');
const bodyParser = require('body-parser');
const pool = require('./db');
const app = express();
const PORT = 3001;
// Middleware pour lire le JSON et servir le dossier public (HTML/JS)
app.use(bodyParser.json());
app.use(express.static('public'));
// --- 1. RÉCUPÉRER TOUTES LES ZONES (AVEC SURFACE) ---
app.get('/api/zones', async (req, res) => {
try {
// On récupère le nom, la surface et la géométrie convertie en GeoJSON
const query = `
SELECT id, nom, surface_m2, ST_AsGeoJSON(geom) as geometrie
FROM zones_interet;
`;
const result = await pool.query(query);
const features = result.rows.map(row => ({
type: "Feature",
properties: {
nom: row.nom,
surface: row.surface_m2
},
geometry: JSON.parse(row.geometrie)
}));
res.json({ type: "FeatureCollection", features: features });
} catch (err) {
console.error("Erreur GET /api/zones :", err);
res.status(500).json({ error: "Erreur lors de la récupération des zones" });
}
});
// --- 2. VÉRIFIER SI UN POINT EST DANS UNE ZONE ---
app.post('/api/check-zone', async (req, res) => {
try {
const geoJsonInput = req.body;
const query = `
SELECT nom, surface_m2
FROM zones_interet
WHERE ST_Contains(geom, ST_SetSRID(ST_GeomFromGeoJSON($1), 4326));
`;
const result = await pool.query(query, [JSON.stringify(geoJsonInput)]);
if (result.rows.length > 0) {
const zone = result.rows[0];
const s = zone.surface_m2;
const surfTexte = s > 10000 ? (s/10000).toFixed(2) + " ha" : Math.round(s) + " m²";
res.json({
status: "success",
message: `📍 Dans la zone : ${zone.nom} (${surfTexte})`
});
} else {
res.json({ status: "success", message: "📍 Hors de toute zone connue." });
}
} catch (err) {
console.error("Erreur POST /api/check-zone :", err);
res.status(500).json({ error: "Erreur calcul spatial" });
}
});
// --- 3. SAUVEGARDER UNE NOUVELLE ZONE AVEC CALCUL DE SURFACE ---
app.post('/api/save-zone', async (req, res) => {
try {
const { nom, geojson } = req.body;
// L'astuce PostGIS : ::geography force le calcul en mètres carrés
const query = `
INSERT INTO zones_interet (nom, geom, surface_m2)
VALUES (
$1,
ST_SetSRID(ST_GeomFromGeoJSON($2), 4326),
ST_Area(ST_SetSRID(ST_GeomFromGeoJSON($2), 4326)::geography)
)
RETURNING id, surface_m2;
`;
const result = await pool.query(query, [nom, JSON.stringify(geojson.geometry)]);
const surface = Math.round(result.rows[0].surface_m2);
res.json({
status: "success",
message: "Zone enregistrée !",
surface: surface,
id: result.rows[0].id
});
} catch (err) {
console.error("Erreur POST /api/save-zone :", err);
res.status(500).json({ error: "Erreur lors de la sauvegarde" });
}
});
// Lancement du serveur
app.listen(PORT, () => {
console.log(`🚀 Serveur Alteris prêt sur le port ${PORT}`);
});
```
1. **Relance PM2** :
Bash
```
pm2 restart alteris-api
```
Voici le fichier **`index.html`** complet et optimisé. Il est synchronisé avec ton nouveau `server.js` pour afficher les surfaces (en $m^2$ ou en hectares) et utilise les outils de dessin sur le fond de carte **Google Satellite**.
HTML
```
Alteris - SIG Expert & Surfaces
Alteris Geomatic
Dessiner : Utilisez les outils à gauche.
Mesurer : Cliquez sur une zone pour voir sa surface calculée par PostGIS.
```
Et l'ajout du module suppression !
Voici donc la mise à jour pour la **fonctionnalité de suppression**, présentée selon ta nouvelle règle.
### 1. Les blocs qui évoluent (Le "Pourquoi")
#### Dans `server.js` :
On ajoute une route `DELETE`. Note l'utilisation de `:id` dans l'URL, qui permet de passer l'identifiant de la zone dynamiquement.
JavaScript
```
app.delete('/api/zones/:id', async (req, res) => {
const { id } = req.params;
await pool.query('DELETE FROM zones_interet WHERE id = $1', [id]);
res.json({ status: "success" });
});
```
#### Dans `index.html` :
On modifie le popup pour inclure un bouton qui appelle une nouvelle fonction `supprimerZone(id)`.
JavaScript
```
// Dans la fonction chargerZones, le popup devient :
layer.bindPopup(`... ...`);
// Et on ajoute la fonction de communication avec l'API :
async function supprimerZone(id) {
await fetch(`/api/zones/${id}`, { method: 'DELETE' });
location.reload();
}
```