ADD: Implement the edit events route

cmd/GoApi/main.go

@@ -25,10 +25,14 @@ func main() {
     eventRepo := repository.NewEventRepository(db)
     eventController := api.NewEventController(eventRepo)
     createEventController := api.NewCreateEventController(eventRepo)
+    deleteEventController := api.NewDeleteEventsController(eventRepo)
+    editEventController := api.NewEditEventsController(eventRepo)
 
     mux := http.NewServeMux()
     mux.HandleFunc("/events", eventController.GetEventsHandler)
     mux.HandleFunc("/events/create", createEventController.CreateEventHandler)
+    mux.HandleFunc("/events/delete", deleteEventController.DeleteEventHandler)
+    mux.HandleFunc("/events/edit", editEventController.EditEventHandler)
 
     // Wrap com middleware HMAC
     hmacProtected := middleware.HMACAuth(cfg.HMACSecret)(mux)

internal/api/deleteEvents.go

@@ -0,0 +1,53 @@
+package api
+
+import (
+	"net/http"
+	"encoding/json"
+	"GoApi/internal/repository"
+)
+
+type DeleteEventsController struct {
+	repo repository.EventRepository
+}
+
+func NewDeleteEventsController(repo repository.EventRepository) DeleteEventsController {
+	return DeleteEventsController{repo: repo}
+}
+
+type DeleteEventsRequest struct {
+	EventID int `json:"event_id"`
+}
+
+func (c *DeleteEventsController) DeleteEventHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+        return
+    }
+
+	var req DeleteEventsRequest
+    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+        http.Error(w, "Invalid request body", http.StatusBadRequest)
+        return
+    }
+
+	if req.EventID <= 0 {
+		http.Error(w, "Event ID is required", http.StatusBadRequest)
+		return
+	}
+
+	rows, err := c.repo.DeleteEvent(req.EventID)
+	if err != nil {
+		http.Error(w, "Failed to delete event: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if rows == 0 {
+		http.Error(w, "Event not found", http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"deleted": rows,
+		"message": "Event deleted successfully",
+	})
+}

internal/api/editEvents.go

@@ -0,0 +1,69 @@
+package api
+
+import (
+	"net/http"
+	"encoding/json"
+	"GoApi/internal/repository"
+)
+
+type EditEventsController struct {
+	repo repository.EventRepository
+}
+
+func NewEditEventsController(repo repository.EventRepository) EditEventsController {
+	return EditEventsController{repo: repo}
+}
+
+type EditEventsRequest struct {
+	EventID int `json:"event_id"`
+	Name    string `json:"name"`
+	Date    string `json:"date"`
+	PassageValue   string  `json:"passage_value"`
+	HotelValue     string  `json:"hotel_value"`
+	GiftValue      string  `json:"gift_value"`
+	TeamValue      string  `json:"team_value"`
+	SponsorValue   string  `json:"sponsor_value"`
+	TotalValue     string  `json:"total_value"`
+	CollaboratorIDs []int64 `json:"collaborator_ids"`
+}
+
+func (c *EditEventsController) EditEventHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req EditEventsRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.EventID <= 0 {
+		http.Error(w, "Event ID is required", http.StatusBadRequest)
+		return
+	}
+
+	event := repository.Event{
+		ID:               req.EventID,
+		Name:             req.Name,
+		Date:             req.Date,
+		PassageValue:     req.PassageValue,
+		HotelValue:       req.HotelValue,
+		GiftValue:        req.GiftValue,
+		TeamValue:        req.TeamValue,
+		SponsorValue:     req.SponsorValue,
+		TotalValue:       req.TotalValue,
+		CollaboratorIDs:  req.CollaboratorIDs,
+	}
+
+	if err := c.repo.EditEvent(&event); err != nil {
+		http.Error(w, "Failed to edit event: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"message": "Event edited successfully",
+	})
+}

internal/repository/eventsModel.go

@@ -169,3 +169,96 @@ func (r EventRepository) CreateEvent(event *Event) (int64, error) {
 
     return eventID, nil
 }
+
+func (r EventRepository) DeleteEvent(eventID int) (int64, error) {
+	result, err := r.DB.Exec("DELETE FROM events WHERE event_id = ?", eventID)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}
+
+func (r EventRepository) EditEvent(event *Event) error {
+	tx, err := r.DB.Begin()
+	if err != nil {
+		return fmt.Errorf("failed to begin transaction: %w", err)
+	}
+
+	res, err := tx.Exec(`
+        UPDATE events
+        SET
+            event_name = ?,
+            event_date = ?,
+            event_passage_value = ?,
+            event_hotel_value = ?,
+            event_gift_value = ?,
+            event_team_value = ?,
+            event_sponsor_value = ?,
+            event_total_value = ?
+        WHERE event_id = ?
+    `,
+		event.Name,
+		event.Date,
+		event.PassageValue,
+		event.HotelValue,
+		event.GiftValue,
+		event.TeamValue,
+		event.SponsorValue,
+		event.TotalValue,
+		event.ID,
+	)
+	if err != nil {
+		tx.Rollback()
+		return fmt.Errorf("failed to update event: %w", err)
+	}
+
+	affected, err := res.RowsAffected()
+	if err != nil {
+		tx.Rollback()
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+	if affected == 0 {
+		tx.Rollback()
+		return sql.ErrNoRows
+	}
+
+	// Replace collaborator associations
+	if _, err := tx.Exec("DELETE FROM event_collaborators WHERE event_id = ?", event.ID); err != nil {
+		tx.Rollback()
+		return fmt.Errorf("failed to clear collaborator associations: %w", err)
+	}
+
+	for _, collabID := range event.CollaboratorIDs {
+		if collabID <= 0 {
+			continue
+		}
+
+		var exists bool
+		if err := tx.QueryRow(
+			"SELECT EXISTS(SELECT 1 FROM collaborator WHERE collaborator_id = ?)",
+			collabID,
+		).Scan(&exists); err != nil {
+			tx.Rollback()
+			return fmt.Errorf("failed to verify collaborator: %w", err)
+		}
+		if !exists {
+			tx.Rollback()
+			return fmt.Errorf("collaborator with ID %d does not exist", collabID)
+		}
+
+		if _, err := tx.Exec(
+			"INSERT INTO event_collaborators (event_id, collaborator_id) VALUES (?, ?)",
+			event.ID,
+			collabID,
+		); err != nil {
+			tx.Rollback()
+			return fmt.Errorf("failed to associate collaborator %d with event: %w", collabID, err)
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return fmt.Errorf("failed to commit transaction: %w", err)
+	}
+
+	return nil
+}