v1.0 with SW PWA enabled

backend/handlers/node_handler.go

@@ -0,0 +1,148 @@
+package handlers
+
+import (
+	"backend/models"
+	"backend/repositories"
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+type NodeHandler struct {
+	Repo *repositories.NodeRepository // On stocke le repo ici
+}
+
+var registeredNodes = make(map[string]models.NodeInfo)
+
+func (h *NodeHandler) HandleRegisterNode(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var node models.NodeInfo
+	err := json.NewDecoder(r.Body).Decode(&node)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	var nodeID int
+	nodeID, err = h.Repo.RegisterNode(node)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(map[string]int{"id": nodeID})
+}
+
+func (h *NodeHandler) HandleRetrieveNodeList(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		http.Error(w, "GET requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	log.Printf("All node retrieved")
+
+	var registeredNodes = make(map[string]models.FullNodeInfo)
+	var err error
+
+	registeredNodes, err = h.Repo.RetriveNodeList()
+
+	log.Printf("nb nodes: %v", len(registeredNodes))
+
+	if err != nil {
+		log.Fatalf("Request error on retrieving all node: %v", err)
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	err = json.NewEncoder(w).Encode(registeredNodes)
+	if err != nil {
+		log.Fatalf("Erreur lors de l'encodage JSON: %v", err)
+		http.Error(w, "Erreur lors de l'encodage JSON", http.StatusInternalServerError)
+		return
+	}
+}
+
+/*func (h *NodeHandler) HandleUpdateNode(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var nodeUpdate models.NodeUpdate
+
+	err := json.NewDecoder(r.Body).Decode(&nodeUpdate)
+	if err != nil {
+		http.Error(w, "Erreur lors du décodage du JSON", http.StatusBadRequest)
+		return
+	}
+
+	h.UpdateNode(nodeUpdate)
+
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(`{"status": "success"}`))
+}*/
+
+func HandleUpdateNodes(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	UpdateNodes()
+}
+
+/*func (h *NodeHandler) UpdateNode(nodeUpdate models.NodeUpdate) {
+	node, found := registeredNodes[nodeUpdate.NodeId]
+	if found {
+
+		updateServicesFromNode(&node)
+		h.Repo.UpdateNodeLastSeen(nodeUpdate.NodeId)
+
+		for _, serviceUpdate := range nodeUpdate.Services {
+			h.Repo.UpdateServiceStatus(serviceUpdate)
+		}
+	}
+}*/
+
+func HandleRetrieveNode(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		http.Error(w, "GET requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	params := mux.Vars(r)
+	nodeID := params["id"]
+
+	node, found := registeredNodes[nodeID]
+	if found {
+		// 4. Node trouvé : le retourner au format JSON
+		json.NewEncoder(w).Encode(node)
+	} else {
+		// 5. Node non trouvé : retourner une erreur 404
+		w.WriteHeader(http.StatusNotFound)
+
+		// Optionnel : Retourner un message d'erreur clair
+		errorResponse := map[string]string{"error": "Node non trouvé", "id": nodeID}
+		json.NewEncoder(w).Encode(errorResponse)
+	}
+}
+
+func UpdateNodes() {
+	/*for nodeId := range registeredNodes {
+		updateNode(nodeId)
+	}*/
+}

backend/handlers/service_handler.go

@@ -0,0 +1,133 @@
+package handlers
+
+import (
+	"backend/models"
+	"encoding/json"
+	"log"
+	"net/http"
+)
+
+/*func retrieveServicesFromNode(node *models.NodeInfo) map[string]models.Service {
+
+	apiURL := node.Address + "/list"
+
+	resp, err := http.Get(apiURL)
+
+	log.Printf("retrieving node %s on address %s", node.Name, apiURL)
+
+	if err != nil {
+		log.Fatalf("Erreur lors de la requête : %v", err)
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		log.Fatalf("Requête échouée avec le statut : %s", resp.Status)
+	}
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatalf("Erreur lors de la lecture du corps de la réponse : %v", err)
+	}
+
+	var services []models.Service
+
+	err = json.Unmarshal(bodyBytes, &services)
+	if err != nil {
+		log.Fatalf("Erreur lors du décodage JSON : %v", err)
+	}
+
+	var result map[string]models.Service
+
+	for _, service := range services {
+		result[service.Name] = service
+	}
+
+	return result
+}*/
+
+func (h *NodeHandler) HandleRegisterService(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var serviceRegister models.ServiceRegister
+	err := json.NewDecoder(r.Body).Decode(&serviceRegister)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	var serviceID int
+	serviceID, err = h.Repo.RegisterService(serviceRegister.Service, serviceRegister.NodeId)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(map[string]int{"id": serviceID})
+}
+
+func (h *NodeHandler) HandleUpdateServiceStatus(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var serviceUpdate models.ServiceUpdateRequest
+	err := json.NewDecoder(r.Body).Decode(&serviceUpdate)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	err = h.Repo.UpdateServiceStatus(serviceUpdate)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+}
+
+/*func updateServicesFromNode(node *models.NodeInfo) {
+	node.Services = retrieveServicesFromNode(node)
+}*/
+
+func (h *NodeHandler) HandleDeleteService(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "DELETE" {
+		http.Error(w, "DELETE requested", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var serviceDelete models.ServiceMinimal
+	err := json.NewDecoder(r.Body).Decode(&serviceDelete)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	var node models.NodeInfo
+
+	node, err = h.Repo.RetriveNode(serviceDelete.NodeId)
+
+	if err == nil {
+		err = h.Repo.DeleteService(node, serviceDelete.ServiceId)
+		if err != nil {
+
+			log.Fatalf("error on deleteing service from node %v error : %v", serviceDelete.NodeId, err.Error())
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+	} else {
+		log.Fatalf("Node not found %v error : %v", serviceDelete.NodeId, err.Error())
+	}
+}