v1.0 with SW PWA enabled

backend/repositories/node_repo.go

@@ -0,0 +1,226 @@
+package repositories
+
+import (
+	"backend/models"
+	"bytes"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/lib/pq"
+	_ "github.com/lib/pq"
+)
+
+type NodeRepository struct {
+	DB *sqlx.DB
+}
+
+func (r *NodeRepository) UpdateNodeLastSeen(nodeId string) error {
+	query, _ := os.ReadFile("sql/update_service_status.sql")
+	_, err := r.DB.Exec(string(query), nodeId, time.Now().UTC())
+	return err
+}
+
+func (r *NodeRepository) UpdateServiceStatus(serviceUpdate models.ServiceUpdateRequest) error {
+	query, _ := os.ReadFile("sql/update_service_status.sql")
+	var (
+		serviceIds []int
+		statuses   []int
+		timestamps []time.Time
+	)
+
+	for _, s := range serviceUpdate.Services {
+		serviceIds = append(serviceIds, s.ServiceId)
+		statuses = append(statuses, int(s.Status.Status))
+		timestamps = append(timestamps, s.Status.Timestamp)
+	}
+
+	// lib/pq supporte le passage de slices Go vers les types array de Postgres
+	_, err := r.DB.Exec(string(query), pq.Array(serviceIds), pq.Array(statuses), pq.Array(timestamps))
+	return err
+}
+
+func (r *NodeRepository) RegisterNode(node models.NodeInfo) (int, error) {
+
+	log.Printf("Register node id %v, name %v, address %v", node.Id, node.Name, node.Address)
+
+	query, err := os.ReadFile("sql/register_node.sql")
+	if err != nil {
+		log.Printf("❌ Erreur de lecture SQL: %v", err)
+		return 0, err
+	}
+
+	var id int
+	err = r.DB.QueryRow(string(query), node.Name, node.Address, 0, node.Id).Scan(&id)
+
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return node.Id, nil
+		}
+		return 0, err
+	}
+
+	return id, nil
+}
+
+func (r *NodeRepository) RegisterService(service models.Service, nodeId int) (int, error) {
+
+	log.Printf("Register service id %v, name %v, nodeId %v with command %v", service.Id, service.Name, nodeId, service.Command)
+
+	query, err := os.ReadFile("sql/register_service.sql")
+	if err != nil {
+		log.Printf("❌ Erreur de lecture SQL: %v", err)
+		return 0, err
+	}
+
+	var id int
+	err = r.DB.QueryRow(string(query), nodeId, service.Name, 0, service.Command, service.Id).Scan(&id)
+
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return service.Id, nil
+		}
+		return 0, err
+	}
+
+	return id, nil
+}
+
+func (r *NodeRepository) RetriveNodeList() (map[string]models.FullNodeInfo, error) {
+	query, err := os.ReadFile("sql/retrieve_node_list.sql")
+
+	rows, err := r.DB.Query(string(query))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var nodes = make(map[string]models.FullNodeInfo)
+
+	for rows.Next() {
+		log.Printf("new node")
+
+		var node models.FullNodeInfo
+		var servicesData []byte // On récupère le JSON brut ici
+
+		// On scanne les colonnes dans l'ordre du SELECT
+		err := rows.Scan(
+			&node.Id,
+			&node.Name,
+			&node.Address,
+			&node.Status,
+			&node.LastSeen,
+			&servicesData,
+		)
+		if err != nil {
+			log.Printf("error on request")
+			return nil, err
+		}
+
+		// On décode le JSON des services dans la Map de la structure
+		if err := json.Unmarshal(servicesData, &node.Services); err != nil {
+			return nil, fmt.Errorf("error decoding services for node %d: %v", node.Id, err)
+		}
+
+		nodes[node.Name] = node
+	}
+
+	return nodes, nil
+}
+
+func deleteServiceFromNode(node *models.NodeInfo, serviceId int) error {
+
+	apiURL := node.Address + "/services"
+
+	bodyData := map[string]int{
+		"service_id": serviceId,
+	}
+
+	jsonData, err := json.Marshal(bodyData)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest(http.MethodDelete, apiURL, bytes.NewBuffer(jsonData)) // Le corps (body) est nil pour un DELETE
+	req.Header.Set("Content-Type", "application/json")
+
+	if err != nil {
+		return fmt.Errorf("Erreur lors de la création de la requête DELETE : %v", err)
+	}
+
+	client := http.Client{
+		Timeout: 10 * time.Second, // Définir un timeout
+	}
+
+	resp, err := client.Do(req)
+
+	if err != nil {
+		return fmt.Errorf("Erreur lors de l'exécution de la requête DELETE : %v", err)
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Requête DELETE échouée pour %s. Statut : %s", apiURL, resp.Status)
+	}
+
+	log.Printf("Service %d supprimé avec succès. Réponse : %s", serviceId, resp.Status)
+
+	return nil
+}
+
+func (r *NodeRepository) DeleteService(node models.NodeInfo, serviceId int) error {
+
+	tx, err := r.DB.Begin()
+
+	log.Printf("Delete service id %v, on nodeId %v", serviceId, node.Id)
+
+	query, err := os.ReadFile("sql/delete_service.sql")
+	if err != nil {
+		log.Printf("❌ Erreur de lecture SQL: %v", err)
+		return err
+	}
+
+	_, err = tx.Exec(string(query), node.Id, serviceId)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	err = deleteServiceFromNode(&node, serviceId)
+	if err != nil {
+		// 4. LE NODE A ÉCHOUÉ : On annule tout en DB
+		tx.Rollback()
+		return fmt.Errorf("échec sur le node, annulation du changement en base de données : %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (r *NodeRepository) RetriveNode(nodeId int) (models.NodeInfo, error) {
+
+	query := "SELECT * FROM nodes WHERE id = $1"
+
+	var node models.SimpleNodeInfo
+
+	err := r.DB.Get(&node, query, nodeId)
+
+	if err != nil {
+		return models.NodeInfo{}, err
+	}
+
+	var result models.NodeInfo
+
+	result.Address = node.Address
+	result.Id = node.Id
+	result.LastSeen = node.LastSeen.String()
+	result.Name = node.Name
+	result.Status = node.Status
+
+	return result, nil
+}