tsk-26: Retrieve scheduled message event endpoint (#28)

Closes #26

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

cmd/api/main.go

@@ -63,9 +63,13 @@ func main() {
 
 	contactStore := store.NewContactStore(db.Pool)
 	messageStore := store.NewMessageStore(db.Pool)
+	schStore := store.NewScheduledMessageStore(db.Pool)
+	schMsgEventStore := store.NewScheduledMessageEventStore(db.Pool)
 
 	contactHandler := handler.NewContactHandler(contactStore)
 	messageHandler := handler.NewMessageHandler(messageStore)
+	scheduledMessageHandler := handler.NewScheduledMessageHandler(schStore)
+	scheduledMessageEventHandler := handler.NewScheduledMessageEventHandler(schMsgEventStore)
 
 	router := chi.NewRouter()
 
@@ -78,6 +82,9 @@ func main() {
 	router.Handle(endpoint.GET_CONTACT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.GetContact)))
 	router.Handle(endpoint.ADD_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.AddMessage)))
 	router.Handle(endpoint.GET_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.GetMessage)))
+	router.Handle(endpoint.ScheduleMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.AddScheduledMessage)))
+	router.Handle(endpoint.AddEventToScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.AddScheduledMessageEvent)))
+	router.Handle(endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent)))
 
 	// Start server
 	server := &http.Server{

cmd/api/main_test.go

@@ -4,44 +4,74 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"net/http"
 	"os"
 	"path"
 	"testing"
 
-	"github.com/gorilla/mux"
+	"github.com/go-chi/chi/v5"
 	"github.com/joho/godotenv"
 
 	"git.kundeng.us/phoenix/textsender-api/internal/config"
 	"git.kundeng.us/phoenix/textsender-api/internal/db"
 	"git.kundeng.us/phoenix/textsender-api/internal/handler"
 	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	mdlware "git.kundeng.us/phoenix/textsender-api/internal/middleware"
+	"git.kundeng.us/phoenix/textsender-api/internal/services"
 	"git.kundeng.us/phoenix/textsender-api/internal/store"
 )
 
-var testRouter *mux.Router
+var testRouter *chi.Mux
 
 func TestMain(m *testing.M) {
 	cfg := load()
 
-	db, err := db.NewDatabase(cfg.GetDBConnString())
+	database, err := db.NewDatabase(cfg.GetDBConnString())
 	if err != nil {
 		fmt.Println(err.Error())
 		panic("Failed to initialize database")
 	}
-	defer db.Close()
+	defer database.Close()
 
 	ctx := context.Background()
-	err = db.ResetDatabase(ctx)
+
-	if err != nil {
+	if cfg.ResetDB {
+		if err = database.ResetDatabase(ctx); err != nil {
 			fmt.Println(err.Error())
 			panic("Failed to initialize database")
 		}
+	} else {
+		if exists, err := db.TableExists(ctx, database.Pool, "contacts "); err == nil && !exists {
+			fmt.Println("Resetting database")
+			err = database.ResetDatabase(ctx)
+			if err != nil {
+				fmt.Printf("Error:%v", err)
+			}
+		} else {
+			fmt.Printf("Error:%v", err)
+		}
+	}
+
+	jwtService := services.NewJWTService(cfg.JWTSecret)
+
+	contactStore := store.NewContactStore(database.Pool)
+	messageStore := store.NewMessageStore(db.Pool)
+	schStore := store.NewScheduledMessageStore(db.Pool)
+	schMsgEventStore := store.NewScheduledMessageEventStore(db.Pool)
 
-	contactStore := store.NewContactStore(db.Pool)
 	contactHandler := handler.NewContactHandler(contactStore)
+	messageHandler := handler.NewMessageHandler(messageStore)
+	scheduledMessageHandler := handler.NewScheduledMessageHandler(schStore)
+	scheduledMessageEventHandler := handler.NewScheduledMessageEventHandler(schMsgEventStore)
 
-	testRouter = mux.NewRouter()
+	testRouter = chi.NewRouter()
-	testRouter.HandleFunc(endpoint.ADD_CONTACT_ENDPOINT, contactHandler.AddContact).Methods("POST")
+	testRouter.Handle(endpoint.ADD_CONTACT_ENDPOINT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.AddContact)))
+	testRouter.Handle(endpoint.GET_CONTACT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.GetContact)))
+	testRouter.Handle(endpoint.ADD_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.AddMessage)))
+	testRouter.Handle(endpoint.GET_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.GetMessage)))
+	testRouter.Handle(endpoint.ScheduleMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.AddScheduledMessage)))
+	testRouter.Handle(endpoint.AddEventToScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.AddScheduledMessageEvent)))
+	testRouter.Handle(endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent)))
 
 	code := m.Run()
 	os.Exit(code)

go.mod

@@ -2,12 +2,11 @@ module git.kundeng.us/phoenix/textsender-api
 
 go 1.25.3
 
-require github.com/google/uuid v1.6.0
-
 require (
-	git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556
+	git.kundeng.us/phoenix/textsender-models v0.0.6-4-e124bcfda8-556
 	github.com/go-chi/chi/v5 v5.2.3
 	github.com/golang-jwt/jwt/v5 v5.3.0
+	github.com/google/uuid v1.6.0
 	github.com/gorilla/mux v1.8.1
 	github.com/jackc/pgx/v5 v5.7.6
 	github.com/joho/godotenv v1.5.1

go.sum

@@ -1,5 +1,5 @@
-git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556 h1:BRF4JrIVZMa3kZOaRfHNLJTcspD1RWRoCTcabn+CAIA=
+git.kundeng.us/phoenix/textsender-models v0.0.6-4-e124bcfda8-556 h1:2shgOKmglCODswpCJeCuyPiUAph3wfc0Ep1z6b/ifis=
-git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556/go.mod h1:lx5MCnOgGgsdpwzrfi9uph5xmkeb6H8AuexUNGss2no=
+git.kundeng.us/phoenix/textsender-models v0.0.6-4-e124bcfda8-556/go.mod h1:lx5MCnOgGgsdpwzrfi9uph5xmkeb6H8AuexUNGss2no=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

internal/handler/contact_test.go

@@ -15,6 +15,7 @@ import (
 
 	"git.kundeng.us/phoenix/textsender-api/internal/db"
 	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
 )
 
 type Request struct {
@@ -23,7 +24,7 @@ type Request struct {
 }
 
 func TestCreateContactWithMock(t *testing.T) {
-	mockstore := NewMockContactStore()
+	mockstore := mock.NewMockContactStore()
 	handler := NewContactHandler(mockstore)
 
 	testUserId := uuid.New()
@@ -47,7 +48,7 @@ func TestCreateContactWithMock(t *testing.T) {
 }
 
 func TestGetContactWithMock(t *testing.T) {
-	mockstore := NewMockContactStore()
+	mockstore := mock.NewMockContactStore()
 	testUserId := uuid.New()
 
 	testCon := contact.Contact{PhoneNumber: "+12335403383", UserId: testUserId}

internal/handler/endpoint/endpoint.go

@@ -5,3 +5,6 @@ const ADD_MESSAGE = "/api/v1/message/new"
 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 AddEventToScheduledMessageEndpoint = "/api/v1/schedule/message/event"
+const GetScheduledMessageEventEndpoint = "/api/v1/schedule/message/event/{id}"

internal/handler/message_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
 )
 
 type CreateMessageRequest struct {
@@ -21,7 +22,7 @@ type CreateMessageRequest struct {
 }
 
 func TestCreateMessageWithMock(t *testing.T) {
-	mockStore := NewMockMessageStore()
+	mockStore := mock.NewMockMessageStore()
 	handler := NewMessageHandler(mockStore)
 
 	testUserId := uuid.New()
@@ -45,7 +46,7 @@ func TestCreateMessageWithMock(t *testing.T) {
 }
 
 func TestGetMessageWithMock(t *testing.T) {
-	mockstore := NewMockMessageStore()
+	mockstore := mock.NewMockMessageStore()
 	testUserId := uuid.New()
 
 	testCon := message.Message{Content: "Who is the one that benefits?", UserId: testUserId}

internal/handler/scheduled_message.go

@@ -0,0 +1,109 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+)
+
+type RequestAddScheduledMessage struct {
+	Scheduled time.Time `json:"scheduled"`
+	Created   time.Time `json:"created"`
+	Status    string    `json:"status"`
+	UserId    uuid.UUID `json:"user_id"`
+}
+
+type AddScheduledMessageResponse struct {
+	Message string                        `json:"message"`
+	Data    []scheduling.ScheduledMessage `json:"data"`
+}
+
+type ScheduledMessageHandler struct {
+	ScheduledMessageStore store.ScheduledMessageStore
+}
+
+func NewScheduledMessageHandler(str store.ScheduledMessageStore) *ScheduledMessageHandler {
+	return &ScheduledMessageHandler{ScheduledMessageStore: str}
+}
+
+func (c *ScheduledMessageHandler) AddScheduledMessage(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req RequestAddScheduledMessage
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	scheduledMessage := scheduling.ScheduledMessage{Scheduled: req.Scheduled, Status: req.Status, UserId: req.UserId}
+
+	var statusCode int
+	var resp AddScheduledMessageResponse
+
+	if scheduledMessage.UserId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "No UserId"
+	} else {
+		ctx := r.Context()
+
+		if validStatus, err := isStatusValid(&scheduledMessage); err == nil {
+			if validStatus {
+				if valid, err := isScheduledTimeValid(&scheduledMessage); err == nil && valid {
+					if err = c.ScheduledMessageStore.CreateScheduledMessage(ctx, &scheduledMessage); err == nil {
+						statusCode = http.StatusCreated
+						resp.Data = append(resp.Data, scheduledMessage)
+						resp.Message = "Successful"
+					} else {
+						statusCode = http.StatusInternalServerError
+						resp.Message = err.Error()
+					}
+				} else {
+					statusCode = http.StatusBadRequest
+					resp.Message = "Invalid scheduled time"
+				}
+			} else {
+				statusCode = http.StatusBadRequest
+				resp.Message = "Invalid status"
+			}
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func isScheduledTimeValid(schMsg *scheduling.ScheduledMessage) (bool, error) {
+	now := time.Now()
+	timeCutOff := now.Add(-5 * time.Minute)
+	futureCutOff := now.Add((24 * 7) * time.Hour)
+
+	if schMsg.Scheduled.After(timeCutOff) {
+		if schMsg.Scheduled.Before(futureCutOff) {
+			return true, nil
+		} else {
+			return false, fmt.Errorf("Scheduled Time is too far in the future")
+		}
+	} else {
+		return false, nil
+	}
+}
+
+func isStatusValid(schMsg *scheduling.ScheduledMessage) (bool, error) {
+	schMsg.Status = strings.ToUpper(schMsg.Status)
+	if schMsg.Status == scheduling.Pending {
+		return true, nil
+	} else {
+		return false, fmt.Errorf("Status is not valid for creating scheduled message %s", schMsg.Status)
+	}
+}

internal/handler/scheduled_message_event.go

@@ -0,0 +1,126 @@
+package handler
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+)
+
+type RequestAddScheduledMessageEvent struct {
+	RecipientId        uuid.UUID `json:"recipient_id"`
+	MessageId          uuid.UUID `json:"message_id"`
+	ScheduledMessageId uuid.UUID `json:"scheduled_message_id"`
+}
+
+type AddScheduledMessageEventResponse struct {
+	Message string                             `json:"message"`
+	Data    []scheduling.ScheduledMessageEvent `json:"data"`
+}
+
+type GetScheduledMessageEventResponse struct {
+	Message string                             `json:"message"`
+	Data    []scheduling.ScheduledMessageEvent `json:"data"`
+}
+
+type ScheduledMessageEventHandler struct {
+	ScheduledMessageEventStore store.ScheduledMessageEventStore
+}
+
+func NewScheduledMessageEventHandler(str store.ScheduledMessageEventStore) *ScheduledMessageEventHandler {
+	return &ScheduledMessageEventHandler{ScheduledMessageEventStore: str}
+}
+
+func (s *ScheduledMessageEventHandler) AddScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req RequestAddScheduledMessageEvent
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	event := scheduling.ScheduledMessageEvent{RecipientId: req.RecipientId, MessageId: req.MessageId, ScheduledMessageId: req.ScheduledMessageId}
+
+	var statusCode int
+	var resp AddScheduledMessageEventResponse
+
+	if event.RecipientId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Recipient Id is nil"
+	} else if event.MessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Message Id is nil"
+	} else if event.ScheduledMessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Scheduled Message Id is nil"
+	} else {
+		ctx := r.Context()
+
+		if exists, err := s.ScheduledMessageEventStore.Exists(ctx, &event); err == nil {
+			if exists {
+				statusCode = http.StatusBadRequest
+				resp.Message = "Event already present"
+			} else {
+				if err = s.ScheduledMessageEventStore.CreateScheduledMessageEvent(ctx, &event); err == nil {
+					statusCode = http.StatusCreated
+					resp.Message = "Successful"
+					resp.Data = append(resp.Data, event)
+				} else {
+					statusCode = http.StatusInternalServerError
+					resp.Message = err.Error()
+				}
+			}
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func (s *ScheduledMessageEventHandler) GetScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Metnot allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	id := chi.URLParam(r, "id")
+	if len(id) == 0 {
+		pathParts := strings.Split(r.URL.Path, "/")
+		if len(pathParts) < 7 {
+			http.Error(w, "Id not provided", http.StatusBadRequest)
+			return
+		} else {
+			id = pathParts[6]
+		}
+	}
+
+	var statusCode int
+	var resp GetScheduledMessageEventResponse
+
+	if parsedId, err := uuid.Parse(id); err != nil {
+		resp.Message = err.Error()
+		statusCode = http.StatusBadRequest
+	} else {
+		ctx := r.Context()
+		if event, err := s.ScheduledMessageEventStore.Get(ctx, parsedId); err != nil {
+			resp.Message = err.Error()
+			statusCode = http.StatusInternalServerError
+		} else {
+			resp.Message = "Successful"
+			statusCode = http.StatusOK
+			resp.Data = append(resp.Data, *event)
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}

internal/handler/scheduled_message_event_test.go

@@ -0,0 +1,152 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/contact"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+type CreateScheduledMessageEventRequest struct {
+	RecipientId        uuid.UUID `json:"recipient_id"`
+	MessageId          uuid.UUID `json:"message_id"`
+	ScheduledMessageId uuid.UUID `json:"scheduled_message_id"`
+}
+
+func TestCreateScheduledMessageEventWithMock(t *testing.T) {
+	now := time.Now()
+
+	mockStore := mock.NewMockScheduledMessageEventStore()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+
+	handler := NewScheduledMessageEventHandler(mockStore)
+
+	recipientId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := contact.Contact{}
+	con.Id = recipientId
+	con.PhoneNumber = "+10123456789"
+	con.UserId = testUserId
+
+	msg := message.Message{}
+	msg.Id = messageId
+	msg.Content = "Oh how the might have fallen"
+	msg.UserId = testUserId
+
+	schMsg := scheduling.ScheduledMessage{}
+	schMsg.Id = scheduledMessageId
+	schMsg.UserId = testUserId
+	schMsg.Scheduled = now.Add(20 * time.Minute)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	}
+
+	testReq := CreateScheduledMessageEventRequest{RecipientId: recipientId, MessageId: messageId, ScheduledMessageId: scheduledMessageId}
+	jsonValue, _ := json.Marshal(testReq)
+
+	req, _ := http.NewRequest("POST", endpoint.AddEventToScheduledMessageEndpoint, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.AddScheduledMessageEvent(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response AddScheduledMessageEventResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error creating event %v", err)
+
+	assert.NotEmpty(t, response.Data, "No event created")
+
+	var event scheduling.ScheduledMessageEvent
+	event = response.Data[0]
+
+	assert.NotEmpty(t, event.Created, "Created date should not be empty")
+}
+
+func TestGetScheduledMessageEventWithMock(t *testing.T) {
+	now := time.Now()
+
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+	schMsgEventStore := mock.NewMockScheduledMessageEventStore()
+	handler := NewScheduledMessageEventHandler(schMsgEventStore)
+
+	recipientId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := contact.Contact{}
+	con.Id = recipientId
+	con.PhoneNumber = "+10123456789"
+	con.UserId = testUserId
+
+	msg := message.Message{}
+	msg.Id = messageId
+	msg.Content = "Oh how the might have fallen"
+	msg.UserId = testUserId
+
+	schMsg := scheduling.ScheduledMessage{}
+	schMsg.Id = scheduledMessageId
+	schMsg.UserId = testUserId
+	schMsg.Scheduled = now.Add(20 * time.Minute)
+
+	event := scheduling.ScheduledMessageEvent{}
+	event.MessageId = msg.Id
+	event.RecipientId = con.Id
+	event.ScheduledMessageId = schMsg.Id
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	} else if err = schMsgEventStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	}
+
+	endpointValue := strings.Replace(endpoint.GetScheduledMessageEventEndpoint, "{id}", event.Id.String(), 1)
+	req, _ := http.NewRequest("GET", endpointValue, nil)
+	rr := httptest.NewRecorder()
+
+	handler.GetScheduledMessageEvent(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response GetScheduledMessageEventResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error creating event %v", err)
+
+	assert.NotEmpty(t, response.Data, "No event created")
+
+	msgEvent := response.Data[0]
+
+	assert.NotEmpty(t, msgEvent.Created, "Created date should not be empty")
+}

internal/handler/scheduled_message_test.go

@@ -0,0 +1,49 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+type CreateScheduledMessageRequest struct {
+	Scheduled time.Time `json:"scheduled"`
+	Status    string    `json:"status"`
+	UserId    uuid.UUID `json:"user_id"`
+}
+
+func TestCreateScheduledMessageWithMock(t *testing.T) {
+	now := time.Now()
+	mockStore := mock.NewMockScheduledMessageStore()
+	handler := NewScheduledMessageHandler(mockStore)
+
+	testUserId := uuid.New()
+	scheduled := now.Add(5 * time.Minute)
+	testBody := CreateScheduledMessageRequest{Status: scheduling.Pending, UserId: testUserId, Scheduled: scheduled}
+	jsonValue, _ := json.Marshal(testBody)
+
+	req, _ := http.NewRequest("POST", endpoint.ScheduleMessageEndpoint, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.AddScheduledMessage(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response AddScheduledMessageResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error Creating message %v", err)
+
+	assert.NotEmpty(t, response.Data, "No Message created")
+
+	assert.NotNil(t, response.Data[0].Id, "Id should not be nil")
+}

internal/store/mock/mock_store.go

@@ -1,4 +1,4 @@
-package handler
+package mock
 
 import (
 	"context"
@@ -9,6 +9,7 @@ import (
 
 	"git.kundeng.us/phoenix/textsender-models/pkg/contact"
 	"git.kundeng.us/phoenix/textsender-models/pkg/message"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
 )
 
 type Key struct {
@@ -200,3 +201,40 @@ func (m *MockMessageStore) MessageExists(ctx context.Context, msg *message.Messa
 
 	return exists, nil
 }
+
+type ScheduledMessageKey struct {
+	UserId uuid.UUID
+}
+
+type MockScheduledMessageStore struct {
+	ScheduledMessages      map[uuid.UUID]*scheduling.ScheduledMessage
+	ScheduledMessagesByKey map[ScheduledMessageKey]*scheduling.ScheduledMessage
+	mu                     sync.RWMutex
+	Error                  error // Optional: simulate errors
+}
+
+func NewMockScheduledMessageStore() *MockScheduledMessageStore {
+	return &MockScheduledMessageStore{
+		ScheduledMessages:      make(map[uuid.UUID]*scheduling.ScheduledMessage),
+		ScheduledMessagesByKey: make(map[ScheduledMessageKey]*scheduling.ScheduledMessage),
+	}
+}
+
+func (m *MockScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if schedMsg.Id == uuid.Nil {
+		schedMsg.Id = uuid.New()
+	}
+
+	key := ScheduledMessageKey{UserId: schedMsg.UserId}
+
+	m.ScheduledMessages[schedMsg.Id] = schedMsg
+	m.ScheduledMessagesByKey[key] = schedMsg
+	return nil
+}

internal/store/mock/scheduled_message_event_store.go

@@ -0,0 +1,90 @@
+package mock
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+)
+
+type ScheduledMessageEventKey struct {
+	RecipientId        uuid.UUID
+	MessageId          uuid.UUID
+	ScheduledMessageId uuid.UUID
+}
+
+type MockScheduledMessageEventStore struct {
+	ScheduledMessageEvents      map[uuid.UUID]*scheduling.ScheduledMessageEvent
+	ScheduledMessageEventsByKey map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent
+	mu                          sync.RWMutex
+	Error                       error // Optional: simulate errors
+}
+
+func NewMockScheduledMessageEventStore() *MockScheduledMessageEventStore {
+	return &MockScheduledMessageEventStore{
+		ScheduledMessageEvents:      make(map[uuid.UUID]*scheduling.ScheduledMessageEvent),
+		ScheduledMessageEventsByKey: make(map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent),
+	}
+}
+
+func (m *MockScheduledMessageEventStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if id == uuid.Nil {
+		return nil, fmt.Errorf("Id is nil")
+	}
+
+	if _, exists := m.ScheduledMessageEvents[id]; exists {
+		return m.ScheduledMessageEvents[id], nil
+	} else {
+		fmt.Println("Not found")
+		return nil, fmt.Errorf("Not found")
+	}
+}
+
+func (m *MockScheduledMessageEventStore) CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if event.Id == uuid.Nil {
+		event.Id = uuid.New()
+	}
+
+	key := ScheduledMessageEventKey{RecipientId: event.RecipientId, MessageId: event.MessageId, ScheduledMessageId: event.ScheduledMessageId}
+
+	if _, exists := m.ScheduledMessageEventsByKey[key]; exists {
+		return fmt.Errorf("Already exists")
+	} else {
+		event.Created = time.Now()
+		m.ScheduledMessageEvents[event.Id] = event
+		m.ScheduledMessageEventsByKey[key] = event
+		return nil
+	}
+}
+
+func (m *MockScheduledMessageEventStore) Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return false, m.Error
+	}
+
+	key := ScheduledMessageEventKey{RecipientId: event.RecipientId, MessageId: event.MessageId, ScheduledMessageId: event.ScheduledMessageId}
+	_, exists := m.ScheduledMessageEventsByKey[key]
+
+	return exists, nil
+}

internal/store/scheduled_message_event_store.go

@@ -0,0 +1,68 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+)
+
+type ScheduledMessageEventStore interface {
+	Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error)
+	CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error
+	Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error)
+}
+
+type PGScheduledMessageEventStore struct {
+	db *pgxpool.Pool
+}
+
+func NewScheduledMessageEventStore(db *pgxpool.Pool) *PGScheduledMessageEventStore {
+	return &PGScheduledMessageEventStore{db: db}
+}
+
+func (s *PGScheduledMessageEventStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error) {
+	query := `SELECT id, recipient_id, message_id, scheduled_message_id, created FROM scheduled_message_events WHERE id = $1`
+
+	var event scheduling.ScheduledMessageEvent
+	err := s.db.QueryRow(ctx, query, id).Scan(
+		&event.Id, &event.RecipientId, &event.MessageId, &event.ScheduledMessageId, &event.Created,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("getting scheduled message event by ID: %w", err)
+	}
+
+	return &event, nil
+}
+
+func (s *PGScheduledMessageEventStore) CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error {
+	query := `
+		INSERT INTO scheduled_message_events (recipient_id, message_id, scheduled_message_id)
+		VALUES ($1, $2, $3)
+		RETURNING id, created
+	`
+
+	return s.db.QueryRow(ctx, query, event.RecipientId, event.MessageId, event.ScheduledMessageId).Scan(
+		&event.Id, &event.Created,
+	)
+}
+
+func (s *PGScheduledMessageEventStore) Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error) {
+	query := `SELECT EXISTS(SELECT 1 FROM scheduled_message_events WHERE scheduled_message_id = $1 AND recipient_id = $2)`
+
+	var exists bool
+	err := s.db.QueryRow(ctx, query, event.ScheduledMessageId, event.RecipientId).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("Scheduled message event does not exist: %w", err)
+	} else {
+		return exists, nil
+	}
+}

internal/store/scheduled_message_store.go

@@ -0,0 +1,33 @@
+package store
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
+)
+
+type ScheduledMessageStore interface {
+	CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error
+}
+
+type PGScheduledMessageStore struct {
+	db *pgxpool.Pool
+}
+
+func NewScheduledMessageStore(db *pgxpool.Pool) *PGScheduledMessageStore {
+	return &PGScheduledMessageStore{db: db}
+}
+
+func (s *PGScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error {
+	query := `
+		INSERT INTO scheduled_messages (scheduled, status, user_id)
+		VALUES ($1, $2, $3)
+		RETURNING id, created
+	`
+
+	return s.db.QueryRow(ctx, query, schedMsg.Scheduled, schedMsg.Status, schedMsg.UserId).Scan(
+		&schedMsg.Id, &schedMsg.Created,
+	)
+}

migrations/schema.sql

@@ -2,14 +2,30 @@ CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
 
 DROP TABLE IF EXISTS contacts CASCADE;
 
-CREATE TABLE contacts (
+CREATE TABLE IF NOT EXISTS contacts (
     id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
     phone_number TEXT NOT NULL,
     user_id UUID NOT NULL
 );
 
-CREATE TABLE messages (
+CREATE TABLE IF NOT EXISTS messages (
     id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
     content TEXT NOT NULL,
     user_id UUID NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS scheduled_messages (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    scheduled timestamptz NOT NULL,
+    created timestamptz DEFAULT now(),
+    status TEXT CHECK (status IN ('PENDING', 'READY', 'PROCESSING', 'DONE')),
+    user_id UUID NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS scheduled_message_events (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    recipient_id UUID NOT NULL,
+    message_id UUID NOT NULL,
+    scheduled_message_id UUID NOT NULL,
+    created timestamptz DEFAULT now()
+)