tsk-13: Retrieve scheduled message endpoint (#36)

Closes #13

Reviewed-on: phoenix/textsender-api#36
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>

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{

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)

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}"

internal/handler/helper.go

@@ -1,8 +1,11 @@
 package handler
 
-import "encoding/json"
+import (
-import "log"
+	"encoding/json"
-import "net/http"
+	"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)
+	}
+}

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)

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 := testCreateScheduledMessageRequest(testUserId, now)
-	testBody := CreateScheduledMessageRequest{Status: scheduling.Pending, UserId: testUserId, Scheduled: scheduled}
 	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}
+}

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()

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)