From 7f588cc80c780ecb3b0103161e1d0014388848df Mon Sep 17 00:00:00 2001 From: phoenix Date: Wed, 12 Nov 2025 19:25:54 +0000 Subject: [PATCH] tsk-13: Retrieve scheduled message endpoint (#36) Closes #13 Reviewed-on: https://git.kundeng.us/phoenix/textsender-api/pulls/36 Co-authored-by: phoenix Co-committed-by: phoenix --- cmd/api/main.go | 1 + cmd/api/main_test.go | 1 + internal/handler/endpoint/endpoint.go | 1 + internal/handler/helper.go | 24 ++++++- internal/handler/scheduled_message.go | 69 +++++++++++++++++++ internal/handler/scheduled_message_test.go | 39 ++++++++++- .../store/mock/scheduled_message_store.go | 26 +++++++ internal/store/scheduled_message_store.go | 28 ++++++++ 8 files changed, 184 insertions(+), 5 deletions(-) diff --git a/cmd/api/main.go b/cmd/api/main.go index ebdb170..7d0aa7e 100644 --- a/cmd/api/main.go +++ b/cmd/api/main.go @@ -88,6 +88,7 @@ func main() { router.Method("GET", endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent))) router.Method("DELETE", endpoint.DeleteScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.DeleteScheduledMessageEvent))) router.Method("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageStatusHandler.UpdateStatus))) + router.Method("GET", endpoint.GetScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.GetScheduledMessage))) // Start server server := &http.Server{ diff --git a/cmd/api/main_test.go b/cmd/api/main_test.go index acd0bea..57c9d84 100644 --- a/cmd/api/main_test.go +++ b/cmd/api/main_test.go @@ -74,6 +74,7 @@ func TestMain(m *testing.M) { testRouter.Method("GET", endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent))) testRouter.Method("DELETE", endpoint.DeleteScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.DeleteScheduledMessageEvent))) testRouter.Method("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageStatusHandler.UpdateStatus))) + testRouter.Method("GET", endpoint.GetScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.GetScheduledMessage))) code := m.Run() os.Exit(code) diff --git a/internal/handler/endpoint/endpoint.go b/internal/handler/endpoint/endpoint.go index c796f55..673c6e7 100644 --- a/internal/handler/endpoint/endpoint.go +++ b/internal/handler/endpoint/endpoint.go @@ -6,6 +6,7 @@ const GET_MESSAGE = "/api/v1/message" const GET_CONTACT = "/api/v1/contact" const ADD_CONTACT_ENDPOINT = "/api/v1/contact/new" const ScheduleMessageEndpoint = "/api/v1/schedule/message" +const GetScheduledMessageEndpoint = "/api/v1/schedule/message" const AddEventToScheduledMessageEndpoint = "/api/v1/schedule/message/event" const GetScheduledMessageEventEndpoint = "/api/v1/schedule/message/event/{id}" const DeleteScheduledMessageEventEndpoint = "/api/v1/schedule/message/event/{id}" diff --git a/internal/handler/helper.go b/internal/handler/helper.go index 075f09e..c9d2c32 100644 --- a/internal/handler/helper.go +++ b/internal/handler/helper.go @@ -1,8 +1,11 @@ package handler -import "encoding/json" -import "log" -import "net/http" +import ( + "encoding/json" + "fmt" + "log" + "net/http" +) func ExtractFromRequest(r *http.Request, reqItem interface{}) error { err := json.NewDecoder(r.Body).Decode(&reqItem) @@ -21,3 +24,18 @@ func RespondWithJSON(w http.ResponseWriter, statusCode int, data interface{}) { log.Printf("Error encoding JSON: %v", err) } } + +// Gets the query parameter from the URL +func ParseQueryParams(r *http.Request, query string) (*string, error) { + queryParams := r.URL.Query() + if _, exists := queryParams[query]; exists { + value := queryParams.Get(query) + if len(value) == 0 { + return nil, fmt.Errorf("Value of query parameter is empty") + } else { + return &value, nil + } + } else { + return nil, fmt.Errorf("Could not find query %s", query) + } +} diff --git a/internal/handler/scheduled_message.go b/internal/handler/scheduled_message.go index 57ad8c3..8ccb601 100644 --- a/internal/handler/scheduled_message.go +++ b/internal/handler/scheduled_message.go @@ -24,6 +24,11 @@ type AddScheduledMessageResponse struct { Data []scheduling.ScheduledMessage `json:"data"` } +type GetScheduledMessageResponse struct { + Message string `json:"message"` + Data []scheduling.ScheduledMessage `json:"data"` +} + type ScheduledMessageHandler struct { ScheduledMessageStore store.ScheduledMessageStore } @@ -83,6 +88,70 @@ func (c *ScheduledMessageHandler) AddScheduledMessage(w http.ResponseWriter, r * RespondWithJSON(w, statusCode, &resp) } +func (c *ScheduledMessageHandler) GetScheduledMessage(w http.ResponseWriter, r *http.Request) { + var id, userId uuid.UUID + + if idParam, err := ParseQueryParams(r, "id"); err == nil { + var err error + id, err = uuid.Parse(*idParam) + if err != nil { + http.Error(w, "Error parsing Id", http.StatusBadRequest) + return + } + } + if userIdParam, err := ParseQueryParams(r, "user_id"); err == nil { + userId, err = uuid.Parse(*userIdParam) + if err != nil { + http.Error(w, "Error parsing Id", http.StatusBadRequest) + return + } + } + + var resp GetScheduledMessageResponse + var statusCode int + ctx := r.Context() + + if userId == uuid.Nil && id == uuid.Nil { + http.Error(w, "Invalid query parameters", http.StatusBadRequest) + return + } else if userId != uuid.Nil && id != uuid.Nil { + if schMsgs, err := c.ScheduledMessageStore.GetWithUserId(ctx, userId); err != nil { + statusCode = http.StatusInternalServerError + resp.Message = err.Error() + } else { + for _, schMsg := range schMsgs { + if schMsg.Id == id { + resp.Data = append(resp.Data, *schMsg) + } + } + statusCode = http.StatusOK + resp.Message = "Successful" + } + } else if id != uuid.Nil { + if schMsg, err := c.ScheduledMessageStore.Get(ctx, id); err != nil { + statusCode = http.StatusInternalServerError + resp.Message = err.Error() + } else { + statusCode = http.StatusOK + resp.Message = "Successful" + resp.Data = append(resp.Data, *schMsg) + } + } else { + if schMsgs, err := c.ScheduledMessageStore.GetWithUserId(ctx, userId); err != nil { + statusCode = http.StatusInternalServerError + resp.Message = err.Error() + } else { + statusCode = http.StatusOK + resp.Message = "Successful" + for _, schMsg := range schMsgs { + resp.Data = append(resp.Data, *schMsg) + } + } + } + + RespondWithJSON(w, statusCode, &resp) +} + func isScheduledTimeValid(schMsg *scheduling.ScheduledMessage) (bool, error) { now := time.Now() timeCutOff := now.Add(-5 * time.Minute) diff --git a/internal/handler/scheduled_message_test.go b/internal/handler/scheduled_message_test.go index 115c633..07a1849 100644 --- a/internal/handler/scheduled_message_test.go +++ b/internal/handler/scheduled_message_test.go @@ -2,6 +2,7 @@ package handler import ( "encoding/json" + "fmt" "net/http" "net/http/httptest" "strings" @@ -28,8 +29,7 @@ func TestCreateScheduledMessageWithMock(t *testing.T) { handler := NewScheduledMessageHandler(mockStore) testUserId := uuid.New() - scheduled := now.Add(5 * time.Minute) - testBody := CreateScheduledMessageRequest{Status: scheduling.Pending, UserId: testUserId, Scheduled: scheduled} + testBody := testCreateScheduledMessageRequest(testUserId, now) jsonValue, _ := json.Marshal(testBody) req, _ := http.NewRequest("POST", endpoint.ScheduleMessageEndpoint, strings.NewReader(string(jsonValue))) @@ -47,3 +47,38 @@ func TestCreateScheduledMessageWithMock(t *testing.T) { assert.NotNil(t, response.Data[0].Id, "Id should not be nil") } + +func TestGetScheduledMessageWithMock(t *testing.T) { + now := time.Now() + mockStore := mock.NewMockScheduledMessageStore() + + testUserId := uuid.New() + testBody := testCreateScheduledMessageRequest(testUserId, now) + + ctx := t.Context() + schMsg := scheduling.ScheduledMessage{} + schMsg.Scheduled = testBody.Scheduled + schMsg.Status = testBody.Status + schMsg.UserId = testBody.UserId + if err := mockStore.CreateScheduledMessage(ctx, &schMsg); err != nil { + assert.NoError(t, err, "Error Creating message %v", err) + } + + url := fmt.Sprintf("%s?id=%s&user_id=%s", endpoint.GetScheduledMessageEndpoint, schMsg.Id, schMsg.UserId) + req, _ := http.NewRequest("GET", url, nil) + rr := httptest.NewRecorder() + + handler := NewScheduledMessageHandler(mockStore) + handler.GetScheduledMessage(rr, req) + + assert.Equal(t, http.StatusOK, rr.Code) + + var response GetScheduledMessageResponse + err := json.Unmarshal(rr.Body.Bytes(), &response) + assert.NoError(t, err, "Error parsing response %v", err) +} + +func testCreateScheduledMessageRequest(userId uuid.UUID, now time.Time) CreateScheduledMessageRequest { + scheduled := now.Add(5 * time.Minute) + return CreateScheduledMessageRequest{Status: scheduling.Pending, UserId: userId, Scheduled: scheduled} +} diff --git a/internal/store/mock/scheduled_message_store.go b/internal/store/mock/scheduled_message_store.go index 4dd4d6f..71adbf4 100644 --- a/internal/store/mock/scheduled_message_store.go +++ b/internal/store/mock/scheduled_message_store.go @@ -47,6 +47,32 @@ func (m *MockScheduledMessageStore) Get(ctx context.Context, id uuid.UUID) (*sch } } +func (m *MockScheduledMessageStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error) { + m.mu.Lock() + defer m.mu.Unlock() + + if m.Error != nil { + return nil, m.Error + } + + if userId == uuid.Nil { + return nil, fmt.Errorf("User Id is nil") + } else { + var schMsgs []*scheduling.ScheduledMessage + for _, schMsg := range m.ScheduledMessages { + if schMsg.UserId == userId { + schMsgs = append(schMsgs, schMsg) + } + } + + if len(schMsgs) == 0 { + return nil, nil + } else { + return schMsgs, nil + } + } +} + func (m *MockScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error { m.mu.Lock() defer m.mu.Unlock() diff --git a/internal/store/scheduled_message_store.go b/internal/store/scheduled_message_store.go index 704c0bf..02c8d33 100644 --- a/internal/store/scheduled_message_store.go +++ b/internal/store/scheduled_message_store.go @@ -13,6 +13,7 @@ import ( type ScheduledMessageStore interface { Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error) + GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, error) } @@ -44,6 +45,33 @@ func (s *PGScheduledMessageStore) Get(ctx context.Context, id uuid.UUID) (*sched return &schMsg, nil } +func (s *PGScheduledMessageStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error) { + query := ` + SELECT id, scheduled, created, status, user_id FROM scheduled_messages WHERE user_id = $1 + ` + rows, err := s.db.Query(ctx, query, userId) + if err != nil { + return nil, fmt.Errorf("Error retrieving rows from scheduled_messages: %w", err) + } + + var schMsgs []*scheduling.ScheduledMessage + + for rows.Next() { + var schMsg scheduling.ScheduledMessage + if err := rows.Scan(&schMsg.Id, &schMsg.Scheduled, &schMsg.Created, &schMsg.Status, &schMsg.UserId); err != nil { + return nil, fmt.Errorf("Error fetching data from row: %w", err) + } else { + schMsgs = append(schMsgs, &schMsg) + } + } + + if err := rows.Err(); err != nil { + return nil, err + } else { + return schMsgs, nil + } +} + func (s *PGScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error { query := ` INSERT INTO scheduled_messages (scheduled, status, user_id)