Merge pull request #52 from acmcsufoss/interface

Create interfaces and implement more routes

Author: sidvasu

.gitignore

@@ -31,3 +31,5 @@ result/
 
 # Build artifact generated by Makefile
 .generate.marker
+
+tmp/

Makefile

@@ -20,8 +20,8 @@ generate: fmt $(GENERATE_MARKER)
 vet: fmt
 	go vet ./...
 
-run: generate
-	go run ./cmd/api
+run: build
+	./$(BIN_DIR)/$(APP_NAME)
 
 build: generate
 	mkdir -p $(BIN_DIR)

README.md

@@ -20,7 +20,7 @@ make # Compile program
 ```
 OR
 ```sh
-make run # This compiles & runs the program without creating a binary
+make run
 ```
 
 ### Other useful commands from the Makefile

cmd/api/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 	"log"
 	"os"
@@ -11,6 +10,7 @@ import (
 
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/api/routes"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/api/services"
+	"github.com/acmcsufoss/api.acmcsuf.com/internal/db"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/db/models"
 	"github.com/gin-gonic/gin"
 	_ "modernc.org/sqlite"
@@ -28,28 +28,11 @@ func main() {
 		cancel()
 	}()
 
-	// Setup SQLite database & make sure we can connect to it
-	uri := os.Getenv("DATABASE_URL")
-	if uri == "" {
-		log.Fatal("DATABASE_URL must be set")
-	}
-	db, err := sql.Open("sqlite", uri)
+	db, err := db.New(ctx)
 	if err != nil {
-		log.Fatalf("Error opening SQLite database: %vl", err)
+		log.Fatal(err)
 	}
 	defer db.Close()
-	if err := db.PingContext(ctx); err != nil {
-		log.Fatalf("Error connecting to database: %v", err)
-	}
-
-	schemaBytes, err := os.ReadFile("internal/db/sql/schemas/schema.sql")
-	if err != nil {
-		log.Fatalf("Error reading schema file: %v", err)
-	}
-
-	if _, err := db.ExecContext(ctx, string(schemaBytes)); err != nil {
-		log.Fatalf("Error initializing db schema: %v", err)
-	}
 
 	// Now we init services & gin router, and then start the server
 	// Should this be moved to the routes module??

flake.lock

@@ -2,7 +2,7 @@
   description = "Go Dev Environment for api.acmcsuf.com";
 
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
     flake-utils.url = "github:numtide/flake-utils";
   };
 

flake.nix

@@ -22,7 +22,7 @@ func (h *AnnouncementHandler) GetAnnouncement(c *gin.Context) {
 	ctx := c.Request.Context()
 	id := c.Param("id")
 
-	announcement, err := h.announcementService.GetAnnouncement(ctx, id)
+	announcement, err := h.announcementService.Get(ctx, id)
 
 	if err != nil {
 		if err.Error() == "sql: no rows in result set" {
@@ -50,15 +50,13 @@ func (h *AnnouncementHandler) CreateAnnouncement(c *gin.Context) {
 		return
 	}
 
-	announcement, err := h.announcementService.CreateAnnouncement(ctx, params)
-	if err != nil {
+	if err := h.announcementService.Create(ctx, params); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"error": "Not implemented",
 		})
 	}
 	c.JSON(http.StatusOK, gin.H{
-		"message": "Event created successfully",
+		"message": "Announcement created successfully",
 		"uuid":    params.Uuid,
 	})
-	c.JSON(http.StatusOK, announcement)
 }

internal/api/handlers/announcement_handler.go

@@ -24,7 +24,7 @@ func (h *EventsHandler) GetEvent(c *gin.Context) {
 	ctx := c.Request.Context()
 	id := c.Param("id")
 
-	event, err := h.eventsService.GetEvent(ctx, id)
+	event, err := h.eventsService.Get(ctx, id)
 
 	if err != nil {
 		if err.Error() == "sql: no rows in result set" {
@@ -61,7 +61,7 @@ func (h *EventsHandler) CreateEvent(c *gin.Context) {
 		return
 	}
 
-	err := h.eventsService.CreateEvent(ctx, params)
+	err := h.eventsService.Create(ctx, params)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"error": "Failed to create event. " + err.Error(),
@@ -74,15 +74,31 @@ func (h *EventsHandler) CreateEvent(c *gin.Context) {
 	})
 }
 
-// TODO: implement the following handlers
 func (h *EventsHandler) GetEvents(c *gin.Context) {
-	panic("implement me")
+	ctx := c.Request.Context()
+	host := c.Query("host")
+	filters := []any{}
+
+	if host != "" {
+		filters = append(filters, &services.HostFilter{Host: host})
+	}
+
+	events, err := h.eventsService.List(ctx, filters...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Failed to retrieve events",
+		})
+		return
+	}
+	c.JSON(http.StatusOK, events)
 }
 
 func (h *EventsHandler) UpdateEvent(c *gin.Context) {
-	panic("implement me")
+	// ctx := c.Request.Context()
+	// var params models.UpdateEventParams
+	panic("implement me (EventsHandler UpdateEvent)")
 }
 
 func (h *EventsHandler) DeleteEvent(c *gin.Context) {
-	panic("implement me")
+	panic("implement me (EventsHandler DeleteEvent)")
 }

internal/api/handlers/events_handler.go

@@ -8,7 +8,6 @@ import (
 
 func SetupRoutes(router *gin.Engine, eventService *services.EventsService, announcementService *services.AnnouncementService) {
 	eventsHandler := handlers.NewEventHandler(eventService)
-	// NOTE: Only GetEvent implemented so far
 	router.GET("/events", eventsHandler.GetEvents)
 	router.GET("/events/:id", eventsHandler.GetEvent)
 	router.POST("/events", eventsHandler.CreateEvent)

internal/api/routes/routes.go

@@ -6,27 +6,59 @@ import (
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/db/models"
 )
 
+type AnnouncementServicer interface {
+	Service[models.Announcement, string, models.CreateAnnouncementParams, models.UpdateAnnouncementParams]
+}
+
 type AnnouncementService struct {
 	q *models.Queries
 }
 
-var dll string
+// compile time check
+var _ AnnouncementServicer = (*AnnouncementService)(nil)
 
 func NewAnnouncementService(q *models.Queries) *AnnouncementService {
 	return &AnnouncementService{q: q}
 }
 
-func (s *AnnouncementService) GetAnnouncement(ctx context.Context, uuid string) (models.Announcement, error) {
+func (s *AnnouncementService) Get(ctx context.Context, uuid string) (models.Announcement, error) {
 	announcement, err := s.q.GetAnnouncement(ctx, uuid)
 	if err != nil {
 		return models.Announcement{}, err
 	}
 	return announcement, nil
 }
 
-func (s *AnnouncementService) CreateAnnouncement(ctx context.Context, arg models.CreateAnnouncementParams) (models.Announcement, error) {
-	if announcement, err := s.q.CreateAnnouncement(ctx, arg); err != nil {
-		return announcement, err
+func (s *AnnouncementService) Create(ctx context.Context, params models.CreateAnnouncementParams) error {
+	if err := s.q.CreateAnnouncement(ctx, params); err != nil {
+		return err
+	}
+	return nil
+}
+
+type AnnouncementFilter interface {
+	Apply(events []models.Announcement) []models.Announcement
+}
+
+func (s *AnnouncementService) List(ctx context.Context, filters ...any) ([]models.Announcement, error) {
+	announcements, err := s.q.GetAnnouncements(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	result := announcements
+	for _, filter := range filters {
+		if announcementFilter, ok := filter.(AnnouncementFilter); ok {
+			result = announcementFilter.Apply(result)
+		}
 	}
-	return models.Announcement{}, nil
+	return result, nil
+}
+
+func (s *AnnouncementService) Update(ctx context.Context, uuid string, params models.UpdateAnnouncementParams) error {
+	panic("implement me (AnnouncementService Update)")
+}
+
+func (s *AnnouncementService) Delete(ctx context.Context, uuid string) error {
+	panic("implement me (AnnouncementService Delete)")
 }