phoenix/schedtxt_api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: phoenix/schedtxt_api:v0.0.3
Branches Tags
phoenix/schedtxt_api:main
phoenix/schedtxt_api:v0.2.3 phoenix/schedtxt_api:v0.2.0 phoenix/schedtxt_api:v0.1.2 phoenix/schedtxt_api:v0.1.1 phoenix/schedtxt_api:v0.0.12 phoenix/schedtxt_api:v0.1.0 phoenix/schedtxt_api:v0.0.11 phoenix/schedtxt_api:v0.0.10 phoenix/schedtxt_api:v0.0.9 phoenix/schedtxt_api:v0.0.8 phoenix/schedtxt_api:v0.0.7 phoenix/schedtxt_api:v0.0.6 phoenix/schedtxt_api:v0.0.5 phoenix/schedtxt_api:v0.0.4 phoenix/schedtxt_api:v0.0.2 phoenix/schedtxt_api:v0.0.3 phoenix/schedtxt_api:v0.0.1
...
compare: phoenix/schedtxt_api:v0.0.9
Branches Tags
phoenix/schedtxt_api:main
phoenix/schedtxt_api:v0.2.3 phoenix/schedtxt_api:v0.2.0 phoenix/schedtxt_api:v0.1.2 phoenix/schedtxt_api:v0.1.1 phoenix/schedtxt_api:v0.0.12 phoenix/schedtxt_api:v0.1.0 phoenix/schedtxt_api:v0.0.11 phoenix/schedtxt_api:v0.0.10 phoenix/schedtxt_api:v0.0.9 phoenix/schedtxt_api:v0.0.8 phoenix/schedtxt_api:v0.0.7 phoenix/schedtxt_api:v0.0.6 phoenix/schedtxt_api:v0.0.5 phoenix/schedtxt_api:v0.0.4 phoenix/schedtxt_api:v0.0.2 phoenix/schedtxt_api:v0.0.3 phoenix/schedtxt_api:v0.0.1
11 Commits
v0.0.3 ... v0.0.9
Author SHA1 Message Date
phoenixandphoenix f69d56f527 tsk-35: Add API documentation (#39) 
Closes #35

Reviewed-on: phoenix/textsender-api#39
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-13 21:45:17 +00:00
phoenixandphoenix 0cd71c5506 tsk-34: Fetch next ready scheduled message (#38) 
Closes #34

Reviewed-on: phoenix/textsender-api#38
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-13 01:59:39 +00:00
phoenixandphoenix 3218c69f1e tsk-33: Tweak get schedule message event endpoint (#37) 
Closes #33

Reviewed-on: phoenix/textsender-api#37
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-13 00:48:04 +00:00
phoenixandphoenix 7f588cc80c 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>
 2025-11-12 19:25:54 +00:00
phoenixandphoenix a37f1627fc tsk-19: Update status of scheduled message endpoint (#32) 
Closes #19

Reviewed-on: phoenix/textsender-api#32
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-12 17:54:32 +00:00
phoenixandphoenix d191d6a9c1 tsk-27: Added endpoint to delete scheduled message event (#31) 
Closes #27

Reviewed-on: phoenix/textsender-api#31
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-11 18:35:04 +00:00
phoenixandphoenix 2716bb50d3 tsk-29: Place restrictions on adding scheduled message event (#30) 
Closes #29

Reviewed-on: phoenix/textsender-api#30
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-11 16:43:51 +00:00
phoenixandphoenix 880461dffb 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>
 2025-11-10 20:22:40 +00:00
phoenixandphoenix 77c950d299 tsk-24: Fixed tests (#25) 
Closes #24

Reviewed-on: phoenix/textsender-api#25
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-10 17:42:41 +00:00
phoenixandphoenix 44e00684cc tsk-20: Add event to scheduled message (#23) 
Closes #20

Reviewed-on: phoenix/textsender-api#23
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-10 16:25:34 +00:00
phoenixandphoenix 5f9bfa8fe2 tsk-9: Schedule queued message endpoint (#22) 
Closes #9

Reviewed-on: phoenix/textsender-api#22
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
 2025-11-09 04:32:30 +00:00
28 changed files with 4236 additions and 49 deletions
Expand all files Collapse all files
Dockerfile
+1
View File
@@ -29,6 +29,7 @@ COPY ./internal ./internal
COPY ./Makefile .
COPY ./.env .
COPY ./migrations ./migrations
COPY ./docs ./docs
# Build the application
RUN CGO_ENABLED=0 GOOS=linux make build
README.md
+11
View File
@@ -8,3 +8,14 @@ A software system to process Text messaging queueing
```BASH
make build
```
Generate API documentation
```
go install github.com/swaggo/swag/cmd/swag@latest
go get -u github.com/swaggo/http-swagger/v2
swag init --generalInfo main.go --dir ./cmd/api,./internal/handler --output docs/ --parseDependency --parseInternal
```
The API documentation can be viewed from `http://localhost:8080/swagger/index.html`.
cmd/api/main.go
+29
View File
@@ -12,7 +12,9 @@ import (
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/swaggo/http-swagger/v2"
_ "git.kundeng.us/phoenix/textsender-api/docs"
"git.kundeng.us/phoenix/textsender-api/internal/config"
database "git.kundeng.us/phoenix/textsender-api/internal/db"
"git.kundeng.us/phoenix/textsender-api/internal/handler"
@@ -22,6 +24,17 @@ import (
"git.kundeng.us/phoenix/textsender-api/internal/store"
)
// @title textsender-api
// @version 1.0
// @description Core API to send text messages
// @host localhost:8080
// @BasePath /api/v1
// @securityDefinitions.apikey BearerAuth
// @in header
// @name Authorization
// @description JWT Bearer Token
func main() {
cfg := config.Load()
if cfg == nil {
@@ -63,9 +76,14 @@ 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, schStore)
scheduledMessageStatusHandler := handler.NewScheduledMessageStatusHandler(schMsgEventStore, schStore)
router := chi.NewRouter()
@@ -78,6 +96,17 @@ 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.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)))
router.Method("GET", endpoint.FetchNextScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.FetchNextMessage)))
router.Method("GET", "/swagger/*", httpSwagger.Handler(
httpSwagger.URL(fmt.Sprintf("http://localhost:%s/swagger/doc.json", config.PORT)),
))
// Start server
server := &http.Server{
cmd/api/main_test.go
+46 -12
View File
@@ -4,44 +4,78 @@ 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 {
fmt.Println(err.Error())
panic("Failed to initialize database")
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)
}
}
contactStore := store.NewContactStore(db.Pool)
contactHandler := handler.NewContactHandler(contactStore)
jwtService := services.NewJWTService(cfg.JWTSecret)
testRouter = mux.NewRouter()
testRouter.HandleFunc(endpoint.ADD_CONTACT_ENDPOINT, contactHandler.AddContact).Methods("POST")
contactStore := store.NewContactStore(database.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, schStore)
scheduledMessageStatusHandler := handler.NewScheduledMessageStatusHandler(schMsgEventStore, schStore)
testRouter = chi.NewRouter()
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.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)))
testRouter.Method("GET", endpoint.FetchNextScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.FetchNextMessage)))
code := m.Run()
os.Exit(code)
docs/docs.go
+906
View File
@@ -0,0 +1,906 @@
// Package docs Code generated by swaggo/swag. DO NOT EDIT
package docs
import "github.com/swaggo/swag"
const docTemplate = `{
"schemes": {{ marshal .Schemes }},
"swagger": "2.0",
"info": {
"description": "{{escape .Description}}",
"title": "{{.Title}}",
"contact": {},
"version": "{{.Version}}"
},
"host": "{{.Host}}",
"basePath": "{{.BasePath}}",
"paths": {
"/contact": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Get a contact record to have a recipient to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"contacts"
],
"summary": "Get contact",
"parameters": [
{
"type": "string",
"description": "Contact Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "User Id",
"name": "user_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetContactResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetContactResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetContactResponse"
}
}
}
}
},
"/contact/new": {
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Add a contact record to have a recipient to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"contacts"
],
"summary": "Add contact",
"parameters": [
{
"description": "Data to add contact",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddContact"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddContactResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.AddContactResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddContactResponse"
}
}
}
}
},
"/message": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Get a message record to have a recipient to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"messages"
],
"summary": "Get message",
"parameters": [
{
"type": "string",
"description": "Message Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "User Id",
"name": "user_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetMessageResponse"
}
}
}
}
},
"/message/new": {
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Add a message record to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"messages"
],
"summary": "Add message",
"parameters": [
{
"description": "Data to add message",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddMessage"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddMessageResponse"
}
}
}
}
},
"/schedule/message": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Get a scheduled message (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled messages"
],
"summary": "Get scheduled message",
"parameters": [
{
"type": "string",
"description": "Contact Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "User Id",
"name": "user_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageResponse"
}
}
}
},
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Adds a scheduled message (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled messages"
],
"summary": "Add scheduled message",
"parameters": [
{
"description": "Data to add scheduled message",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddScheduledMessage"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageResponse"
}
}
}
}
},
"/schedule/message/event": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Gets a scheduled message event (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled message events"
],
"summary": "Get scheduled message event",
"parameters": [
{
"type": "string",
"description": "Contact Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "Scheduled Message Id",
"name": "scheduled_message_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageEventResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageEventResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageEventResponse"
}
}
}
},
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Add a scheduled message event (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled message events"
],
"summary": "Add scheduled message event",
"parameters": [
{
"description": "Data to add scheduled message event",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddScheduledMessageEvent"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageEventResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageEventResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageEventResponse"
}
}
}
}
},
"/schedule/message/event/{id}": {
"delete": {
"security": [
{
"BearerAuth": []
}
],
"description": "Deletes a scheduled message event (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled message events"
],
"summary": "Delete scheduled message event",
"parameters": [
{
"type": "string",
"format": "uuid",
"description": "scheduled message event Id",
"name": "id",
"in": "path",
"required": true
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.DeleteScheduledMessageEventResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.DeleteScheduledMessageEventResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.DeleteScheduledMessageEventResponse"
}
}
}
}
},
"/schedule/message/fetch": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Fetches a scheduled message that is available to be processed (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled messages"
],
"summary": "Fetch scheduled message",
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.FetchNextMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.FetchNextMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.FetchNextMessageResponse"
}
}
}
}
},
"/schedule/message/status/update": {
"patch": {
"security": [
{
"BearerAuth": []
}
],
"description": "Update the status of a scheduled message (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"status"
],
"summary": "Update status",
"parameters": [
{
"description": "Used to update scheduled message status",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestScheduledMessageStatus"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
},
"404": {
"description": "Not Found",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
}
}
}
}
},
"definitions": {
"contact.Contact": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"phone_number": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.AddContactResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/contact.Contact"
}
},
"message": {
"type": "string"
}
}
},
"handler.AddMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/message.Message"
}
},
"message": {
"type": "string"
}
}
},
"handler.AddScheduledMessageEventResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessageEvent"
}
},
"message": {
"type": "string"
}
}
},
"handler.AddScheduledMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
},
"message": {
"type": "string"
}
}
},
"handler.DeleteScheduledMessageEventResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessageEvent"
}
},
"message": {
"type": "string"
}
}
},
"handler.FetchNextMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetContactResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/contact.Contact"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/message.Message"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetScheduledMessageEventResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessageEvent"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetScheduledMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
},
"message": {
"type": "string"
}
}
},
"handler.RequestAddContact": {
"type": "object",
"properties": {
"phone_number": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.RequestAddMessage": {
"type": "object",
"properties": {
"content": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.RequestAddScheduledMessage": {
"type": "object",
"properties": {
"scheduled": {
"type": "string"
},
"status": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.RequestAddScheduledMessageEvent": {
"type": "object",
"properties": {
"message_id": {
"type": "string"
},
"recipient_id": {
"type": "string"
},
"scheduled_message_id": {
"type": "string"
}
}
},
"handler.RequestScheduledMessageStatus": {
"type": "object",
"properties": {
"scheduled_message_id": {
"type": "string"
},
"status": {
"type": "string"
}
}
},
"handler.ScheduledMessageChange": {
"type": "object",
"properties": {
"old_status": {
"type": "string"
},
"scheduled_message": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
}
},
"handler.ScheduledMessageStatusResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/handler.ScheduledMessageChange"
}
},
"message": {
"type": "string"
}
}
},
"message.Message": {
"type": "object",
"properties": {
"content": {
"type": "string"
},
"id": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"scheduling.ScheduledMessage": {
"type": "object",
"properties": {
"created": {
"type": "string"
},
"id": {
"type": "string"
},
"scheduled": {
"type": "string"
},
"status": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"scheduling.ScheduledMessageEvent": {
"type": "object",
"properties": {
"created": {
"type": "string"
},
"id": {
"type": "string"
},
"message_id": {
"type": "string"
},
"recipient_id": {
"type": "string"
},
"scheduled_message_id": {
"type": "string"
}
}
}
},
"securityDefinitions": {
"BearerAuth": {
"description": "JWT Bearer Token",
"type": "apiKey",
"name": "Authorization",
"in": "header"
}
}
}`
// SwaggerInfo holds exported Swagger Info so clients can modify it
var SwaggerInfo = &swag.Spec{
Version: "1.0",
Host: "localhost:8080",
BasePath: "/api/v1",
Schemes: []string{},
Title: "textsender-api",
Description: "Core API to send text messages",
InfoInstanceName: "swagger",
SwaggerTemplate: docTemplate,
LeftDelim: "{{",
RightDelim: "}}",
}
func init() {
swag.Register(SwaggerInfo.InstanceName(), SwaggerInfo)
}
docs/swagger.json
+882
View File
@@ -0,0 +1,882 @@
{
"swagger": "2.0",
"info": {
"description": "Core API to send text messages",
"title": "textsender-api",
"contact": {},
"version": "1.0"
},
"host": "localhost:8080",
"basePath": "/api/v1",
"paths": {
"/contact": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Get a contact record to have a recipient to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"contacts"
],
"summary": "Get contact",
"parameters": [
{
"type": "string",
"description": "Contact Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "User Id",
"name": "user_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetContactResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetContactResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetContactResponse"
}
}
}
}
},
"/contact/new": {
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Add a contact record to have a recipient to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"contacts"
],
"summary": "Add contact",
"parameters": [
{
"description": "Data to add contact",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddContact"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddContactResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.AddContactResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddContactResponse"
}
}
}
}
},
"/message": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Get a message record to have a recipient to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"messages"
],
"summary": "Get message",
"parameters": [
{
"type": "string",
"description": "Message Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "User Id",
"name": "user_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetMessageResponse"
}
}
}
}
},
"/message/new": {
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Add a message record to send a text to (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"messages"
],
"summary": "Add message",
"parameters": [
{
"description": "Data to add message",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddMessage"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddMessageResponse"
}
}
}
}
},
"/schedule/message": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Get a scheduled message (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled messages"
],
"summary": "Get scheduled message",
"parameters": [
{
"type": "string",
"description": "Contact Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "User Id",
"name": "user_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageResponse"
}
}
}
},
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Adds a scheduled message (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled messages"
],
"summary": "Add scheduled message",
"parameters": [
{
"description": "Data to add scheduled message",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddScheduledMessage"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageResponse"
}
}
}
}
},
"/schedule/message/event": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Gets a scheduled message event (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled message events"
],
"summary": "Get scheduled message event",
"parameters": [
{
"type": "string",
"description": "Contact Id",
"name": "id",
"in": "path",
"required": true
},
{
"type": "string",
"description": "Scheduled Message Id",
"name": "scheduled_message_id",
"in": "path",
"required": true
}
],
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageEventResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageEventResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.GetScheduledMessageEventResponse"
}
}
}
},
"post": {
"security": [
{
"BearerAuth": []
}
],
"description": "Add a scheduled message event (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled message events"
],
"summary": "Add scheduled message event",
"parameters": [
{
"description": "Data to add scheduled message event",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestAddScheduledMessageEvent"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageEventResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageEventResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.AddScheduledMessageEventResponse"
}
}
}
}
},
"/schedule/message/event/{id}": {
"delete": {
"security": [
{
"BearerAuth": []
}
],
"description": "Deletes a scheduled message event (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled message events"
],
"summary": "Delete scheduled message event",
"parameters": [
{
"type": "string",
"format": "uuid",
"description": "scheduled message event Id",
"name": "id",
"in": "path",
"required": true
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.DeleteScheduledMessageEventResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.DeleteScheduledMessageEventResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.DeleteScheduledMessageEventResponse"
}
}
}
}
},
"/schedule/message/fetch": {
"get": {
"security": [
{
"BearerAuth": []
}
],
"description": "Fetches a scheduled message that is available to be processed (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"scheduled messages"
],
"summary": "Fetch scheduled message",
"responses": {
"200": {
"description": "OK",
"schema": {
"$ref": "#/definitions/handler.FetchNextMessageResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.FetchNextMessageResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.FetchNextMessageResponse"
}
}
}
}
},
"/schedule/message/status/update": {
"patch": {
"security": [
{
"BearerAuth": []
}
],
"description": "Update the status of a scheduled message (requires JWT)",
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"status"
],
"summary": "Update status",
"parameters": [
{
"description": "Used to update scheduled message status",
"name": "request",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/handler.RequestScheduledMessageStatus"
}
}
],
"responses": {
"201": {
"description": "Created",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
},
"400": {
"description": "Bad Request",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
},
"404": {
"description": "Not Found",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
},
"500": {
"description": "Internal Server Error",
"schema": {
"$ref": "#/definitions/handler.ScheduledMessageStatusResponse"
}
}
}
}
}
},
"definitions": {
"contact.Contact": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"phone_number": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.AddContactResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/contact.Contact"
}
},
"message": {
"type": "string"
}
}
},
"handler.AddMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/message.Message"
}
},
"message": {
"type": "string"
}
}
},
"handler.AddScheduledMessageEventResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessageEvent"
}
},
"message": {
"type": "string"
}
}
},
"handler.AddScheduledMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
},
"message": {
"type": "string"
}
}
},
"handler.DeleteScheduledMessageEventResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessageEvent"
}
},
"message": {
"type": "string"
}
}
},
"handler.FetchNextMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetContactResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/contact.Contact"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/message.Message"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetScheduledMessageEventResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessageEvent"
}
},
"message": {
"type": "string"
}
}
},
"handler.GetScheduledMessageResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
},
"message": {
"type": "string"
}
}
},
"handler.RequestAddContact": {
"type": "object",
"properties": {
"phone_number": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.RequestAddMessage": {
"type": "object",
"properties": {
"content": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.RequestAddScheduledMessage": {
"type": "object",
"properties": {
"scheduled": {
"type": "string"
},
"status": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"handler.RequestAddScheduledMessageEvent": {
"type": "object",
"properties": {
"message_id": {
"type": "string"
},
"recipient_id": {
"type": "string"
},
"scheduled_message_id": {
"type": "string"
}
}
},
"handler.RequestScheduledMessageStatus": {
"type": "object",
"properties": {
"scheduled_message_id": {
"type": "string"
},
"status": {
"type": "string"
}
}
},
"handler.ScheduledMessageChange": {
"type": "object",
"properties": {
"old_status": {
"type": "string"
},
"scheduled_message": {
"$ref": "#/definitions/scheduling.ScheduledMessage"
}
}
},
"handler.ScheduledMessageStatusResponse": {
"type": "object",
"properties": {
"data": {
"type": "array",
"items": {
"$ref": "#/definitions/handler.ScheduledMessageChange"
}
},
"message": {
"type": "string"
}
}
},
"message.Message": {
"type": "object",
"properties": {
"content": {
"type": "string"
},
"id": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"scheduling.ScheduledMessage": {
"type": "object",
"properties": {
"created": {
"type": "string"
},
"id": {
"type": "string"
},
"scheduled": {
"type": "string"
},
"status": {
"type": "string"
},
"user_id": {
"type": "string"
}
}
},
"scheduling.ScheduledMessageEvent": {
"type": "object",
"properties": {
"created": {
"type": "string"
},
"id": {
"type": "string"
},
"message_id": {
"type": "string"
},
"recipient_id": {
"type": "string"
},
"scheduled_message_id": {
"type": "string"
}
}
}
},
"securityDefinitions": {
"BearerAuth": {
"description": "JWT Bearer Token",
"type": "apiKey",
"name": "Authorization",
"in": "header"
}
}
}
docs/swagger.yaml
+568
View File
@@ -0,0 +1,568 @@
basePath: /api/v1
definitions:
contact.Contact:
properties:
id:
type: string
phone_number:
type: string
user_id:
type: string
type: object
handler.AddContactResponse:
properties:
data:
items:
$ref: '#/definitions/contact.Contact'
type: array
message:
type: string
type: object
handler.AddMessageResponse:
properties:
data:
items:
$ref: '#/definitions/message.Message'
type: array
message:
type: string
type: object
handler.AddScheduledMessageEventResponse:
properties:
data:
items:
$ref: '#/definitions/scheduling.ScheduledMessageEvent'
type: array
message:
type: string
type: object
handler.AddScheduledMessageResponse:
properties:
data:
items:
$ref: '#/definitions/scheduling.ScheduledMessage'
type: array
message:
type: string
type: object
handler.DeleteScheduledMessageEventResponse:
properties:
data:
items:
$ref: '#/definitions/scheduling.ScheduledMessageEvent'
type: array
message:
type: string
type: object
handler.FetchNextMessageResponse:
properties:
data:
items:
$ref: '#/definitions/scheduling.ScheduledMessage'
type: array
message:
type: string
type: object
handler.GetContactResponse:
properties:
data:
items:
$ref: '#/definitions/contact.Contact'
type: array
message:
type: string
type: object
handler.GetMessageResponse:
properties:
data:
items:
$ref: '#/definitions/message.Message'
type: array
message:
type: string
type: object
handler.GetScheduledMessageEventResponse:
properties:
data:
items:
$ref: '#/definitions/scheduling.ScheduledMessageEvent'
type: array
message:
type: string
type: object
handler.GetScheduledMessageResponse:
properties:
data:
items:
$ref: '#/definitions/scheduling.ScheduledMessage'
type: array
message:
type: string
type: object
handler.RequestAddContact:
properties:
phone_number:
type: string
user_id:
type: string
type: object
handler.RequestAddMessage:
properties:
content:
type: string
user_id:
type: string
type: object
handler.RequestAddScheduledMessage:
properties:
scheduled:
type: string
status:
type: string
user_id:
type: string
type: object
handler.RequestAddScheduledMessageEvent:
properties:
message_id:
type: string
recipient_id:
type: string
scheduled_message_id:
type: string
type: object
handler.RequestScheduledMessageStatus:
properties:
scheduled_message_id:
type: string
status:
type: string
type: object
handler.ScheduledMessageChange:
properties:
old_status:
type: string
scheduled_message:
$ref: '#/definitions/scheduling.ScheduledMessage'
type: object
handler.ScheduledMessageStatusResponse:
properties:
data:
items:
$ref: '#/definitions/handler.ScheduledMessageChange'
type: array
message:
type: string
type: object
message.Message:
properties:
content:
type: string
id:
type: string
user_id:
type: string
type: object
scheduling.ScheduledMessage:
properties:
created:
type: string
id:
type: string
scheduled:
type: string
status:
type: string
user_id:
type: string
type: object
scheduling.ScheduledMessageEvent:
properties:
created:
type: string
id:
type: string
message_id:
type: string
recipient_id:
type: string
scheduled_message_id:
type: string
type: object
host: localhost:8080
info:
contact: {}
description: Core API to send text messages
title: textsender-api
version: "1.0"
paths:
/contact:
get:
consumes:
- application/json
description: Get a contact record to have a recipient to send a text to (requires
JWT)
parameters:
- description: Contact Id
in: path
name: id
required: true
type: string
- description: User Id
in: path
name: user_id
required: true
type: string
produces:
- application/json
responses:
"200":
description: OK
schema:
$ref: '#/definitions/handler.GetContactResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.GetContactResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.GetContactResponse'
security:
- BearerAuth: []
summary: Get contact
tags:
- contacts
/contact/new:
post:
consumes:
- application/json
description: Add a contact record to have a recipient to send a text to (requires
JWT)
parameters:
- description: Data to add contact
in: body
name: request
required: true
schema:
$ref: '#/definitions/handler.RequestAddContact'
produces:
- application/json
responses:
"201":
description: Created
schema:
$ref: '#/definitions/handler.AddContactResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.AddContactResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.AddContactResponse'
security:
- BearerAuth: []
summary: Add contact
tags:
- contacts
/message:
get:
consumes:
- application/json
description: Get a message record to have a recipient to send a text to (requires
JWT)
parameters:
- description: Message Id
in: path
name: id
required: true
type: string
- description: User Id
in: path
name: user_id
required: true
type: string
produces:
- application/json
responses:
"200":
description: OK
schema:
$ref: '#/definitions/handler.GetMessageResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.GetMessageResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.GetMessageResponse'
security:
- BearerAuth: []
summary: Get message
tags:
- messages
/message/new:
post:
consumes:
- application/json
description: Add a message record to send a text to (requires JWT)
parameters:
- description: Data to add message
in: body
name: request
required: true
schema:
$ref: '#/definitions/handler.RequestAddMessage'
produces:
- application/json
responses:
"201":
description: Created
schema:
$ref: '#/definitions/handler.AddMessageResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.AddMessageResponse'
security:
- BearerAuth: []
summary: Add message
tags:
- messages
/schedule/message:
get:
consumes:
- application/json
description: Get a scheduled message (requires JWT)
parameters:
- description: Contact Id
in: path
name: id
required: true
type: string
- description: User Id
in: path
name: user_id
required: true
type: string
produces:
- application/json
responses:
"200":
description: OK
schema:
$ref: '#/definitions/handler.GetScheduledMessageResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.GetScheduledMessageResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.GetScheduledMessageResponse'
security:
- BearerAuth: []
summary: Get scheduled message
tags:
- scheduled messages
post:
consumes:
- application/json
description: Adds a scheduled message (requires JWT)
parameters:
- description: Data to add scheduled message
in: body
name: request
required: true
schema:
$ref: '#/definitions/handler.RequestAddScheduledMessage'
produces:
- application/json
responses:
"201":
description: Created
schema:
$ref: '#/definitions/handler.AddScheduledMessageResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.AddScheduledMessageResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.AddScheduledMessageResponse'
security:
- BearerAuth: []
summary: Add scheduled message
tags:
- scheduled messages
/schedule/message/event:
get:
consumes:
- application/json
description: Gets a scheduled message event (requires JWT)
parameters:
- description: Contact Id
in: path
name: id
required: true
type: string
- description: Scheduled Message Id
in: path
name: scheduled_message_id
required: true
type: string
produces:
- application/json
responses:
"200":
description: OK
schema:
$ref: '#/definitions/handler.GetScheduledMessageEventResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.GetScheduledMessageEventResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.GetScheduledMessageEventResponse'
security:
- BearerAuth: []
summary: Get scheduled message event
tags:
- scheduled message events
post:
consumes:
- application/json
description: Add a scheduled message event (requires JWT)
parameters:
- description: Data to add scheduled message event
in: body
name: request
required: true
schema:
$ref: '#/definitions/handler.RequestAddScheduledMessageEvent'
produces:
- application/json
responses:
"201":
description: Created
schema:
$ref: '#/definitions/handler.AddScheduledMessageEventResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.AddScheduledMessageEventResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.AddScheduledMessageEventResponse'
security:
- BearerAuth: []
summary: Add scheduled message event
tags:
- scheduled message events
/schedule/message/event/{id}:
delete:
consumes:
- application/json
description: Deletes a scheduled message event (requires JWT)
parameters:
- description: scheduled message event Id
format: uuid
in: path
name: id
required: true
type: string
produces:
- application/json
responses:
"201":
description: Created
schema:
$ref: '#/definitions/handler.DeleteScheduledMessageEventResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.DeleteScheduledMessageEventResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.DeleteScheduledMessageEventResponse'
security:
- BearerAuth: []
summary: Delete scheduled message event
tags:
- scheduled message events
/schedule/message/fetch:
get:
consumes:
- application/json
description: Fetches a scheduled message that is available to be processed (requires
JWT)
produces:
- application/json
responses:
"200":
description: OK
schema:
$ref: '#/definitions/handler.FetchNextMessageResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.FetchNextMessageResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.FetchNextMessageResponse'
security:
- BearerAuth: []
summary: Fetch scheduled message
tags:
- scheduled messages
/schedule/message/status/update:
patch:
consumes:
- application/json
description: Update the status of a scheduled message (requires JWT)
parameters:
- description: Used to update scheduled message status
in: body
name: request
required: true
schema:
$ref: '#/definitions/handler.RequestScheduledMessageStatus'
produces:
- application/json
responses:
"201":
description: Created
schema:
$ref: '#/definitions/handler.ScheduledMessageStatusResponse'
"400":
description: Bad Request
schema:
$ref: '#/definitions/handler.ScheduledMessageStatusResponse'
"404":
description: Not Found
schema:
$ref: '#/definitions/handler.ScheduledMessageStatusResponse'
"500":
description: Internal Server Error
schema:
$ref: '#/definitions/handler.ScheduledMessageStatusResponse'
security:
- BearerAuth: []
summary: Update status
tags:
- status
securityDefinitions:
BearerAuth:
description: JWT Bearer Token
in: header
name: Authorization
type: apiKey
swagger: "2.0"
go.mod
+23 -9
View File
@@ -2,28 +2,42 @@ 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/gorilla/mux v1.8.1
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.7.6
github.com/joho/godotenv v1.5.1
github.com/stretchr/testify v1.11.1
github.com/swaggo/http-swagger/v2 v2.0.2
github.com/swaggo/swag v1.16.6
)
require (
github.com/KyleBanks/depth v1.2.1 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/go-openapi/jsonpointer v0.22.1 // indirect
github.com/go-openapi/jsonreference v0.21.3 // indirect
github.com/go-openapi/spec v0.22.1 // indirect
github.com/go-openapi/swag/conv v0.25.1 // indirect
github.com/go-openapi/swag/jsonname v0.25.1 // indirect
github.com/go-openapi/swag/jsonutils v0.25.1 // indirect
github.com/go-openapi/swag/loading v0.25.1 // indirect
github.com/go-openapi/swag/stringutils v0.25.1 // indirect
github.com/go-openapi/swag/typeutils v0.25.1 // indirect
github.com/go-openapi/swag/yamlutils v0.25.1 // indirect
github.com/google/go-cmp v0.7.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/kr/text v0.2.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/rogpeppe/go-internal v1.14.1 // indirect
golang.org/x/crypto v0.42.0 // indirect
golang.org/x/sync v0.17.0 // indirect
golang.org/x/text v0.29.0 // indirect
github.com/swaggo/files/v2 v2.0.2 // indirect
go.yaml.in/yaml/v3 v3.0.4 // indirect
golang.org/x/crypto v0.44.0 // indirect
golang.org/x/mod v0.30.0 // indirect
golang.org/x/sync v0.18.0 // indirect
golang.org/x/text v0.31.0 // indirect
golang.org/x/tools v0.39.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
go.sum
+51 -13
View File
@@ -1,17 +1,43 @@
git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556 h1:BRF4JrIVZMa3kZOaRfHNLJTcspD1RWRoCTcabn+CAIA=
git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556/go.mod h1:lx5MCnOgGgsdpwzrfi9uph5xmkeb6H8AuexUNGss2no=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
git.kundeng.us/phoenix/textsender-models v0.0.6-4-e124bcfda8-556 h1:2shgOKmglCODswpCJeCuyPiUAph3wfc0Ep1z6b/ifis=
git.kundeng.us/phoenix/textsender-models v0.0.6-4-e124bcfda8-556/go.mod h1:lx5MCnOgGgsdpwzrfi9uph5xmkeb6H8AuexUNGss2no=
github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
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=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/go-chi/chi/v5 v5.2.3 h1:WQIt9uxdsAbgIYgid+BpYc+liqQZGMHRaUwp0JUcvdE=
github.com/go-chi/chi/v5 v5.2.3/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
github.com/go-openapi/jsonpointer v0.22.1 h1:sHYI1He3b9NqJ4wXLoJDKmUmHkWy/L7rtEo92JUxBNk=
github.com/go-openapi/jsonpointer v0.22.1/go.mod h1:pQT9OsLkfz1yWoMgYFy4x3U5GY5nUlsOn1qSBH5MkCM=
github.com/go-openapi/jsonreference v0.21.3 h1:96Dn+MRPa0nYAR8DR1E03SblB5FJvh7W6krPI0Z7qMc=
github.com/go-openapi/jsonreference v0.21.3/go.mod h1:RqkUP0MrLf37HqxZxrIAtTWW4ZJIK1VzduhXYBEeGc4=
github.com/go-openapi/spec v0.22.1 h1:beZMa5AVQzRspNjvhe5aG1/XyBSMeX1eEOs7dMoXh/k=
github.com/go-openapi/spec v0.22.1/go.mod h1:c7aeIQT175dVowfp7FeCvXXnjN/MrpaONStibD2WtDA=
github.com/go-openapi/swag v0.19.15 h1:D2NRCBzS9/pEY3gP9Nl8aDqGUcPFrwG2p+CNFrLyrCM=
github.com/go-openapi/swag/conv v0.25.1 h1:+9o8YUg6QuqqBM5X6rYL/p1dpWeZRhoIt9x7CCP+he0=
github.com/go-openapi/swag/conv v0.25.1/go.mod h1:Z1mFEGPfyIKPu0806khI3zF+/EUXde+fdeksUl2NiDs=
github.com/go-openapi/swag/jsonname v0.25.1 h1:Sgx+qbwa4ej6AomWC6pEfXrA6uP2RkaNjA9BR8a1RJU=
github.com/go-openapi/swag/jsonname v0.25.1/go.mod h1:71Tekow6UOLBD3wS7XhdT98g5J5GR13NOTQ9/6Q11Zo=
github.com/go-openapi/swag/jsonutils v0.25.1 h1:AihLHaD0brrkJoMqEZOBNzTLnk81Kg9cWr+SPtxtgl8=
github.com/go-openapi/swag/jsonutils v0.25.1/go.mod h1:JpEkAjxQXpiaHmRO04N1zE4qbUEg3b7Udll7AMGTNOo=
github.com/go-openapi/swag/jsonutils/fixtures_test v0.25.1 h1:DSQGcdB6G0N9c/KhtpYc71PzzGEIc/fZ1no35x4/XBY=
github.com/go-openapi/swag/jsonutils/fixtures_test v0.25.1/go.mod h1:kjmweouyPwRUEYMSrbAidoLMGeJ5p6zdHi9BgZiqmsg=
github.com/go-openapi/swag/loading v0.25.1 h1:6OruqzjWoJyanZOim58iG2vj934TysYVptyaoXS24kw=
github.com/go-openapi/swag/loading v0.25.1/go.mod h1:xoIe2EG32NOYYbqxvXgPzne989bWvSNoWoyQVWEZicc=
github.com/go-openapi/swag/stringutils v0.25.1 h1:Xasqgjvk30eUe8VKdmyzKtjkVjeiXx1Iz0zDfMNpPbw=
github.com/go-openapi/swag/stringutils v0.25.1/go.mod h1:JLdSAq5169HaiDUbTvArA2yQxmgn4D6h4A+4HqVvAYg=
github.com/go-openapi/swag/typeutils v0.25.1 h1:rD/9HsEQieewNt6/k+JBwkxuAHktFtH3I3ysiFZqukA=
github.com/go-openapi/swag/typeutils v0.25.1/go.mod h1:9McMC/oCdS4BKwk2shEB7x17P6HmMmA6dQRtAkSnNb8=
github.com/go-openapi/swag/yamlutils v0.25.1 h1:mry5ez8joJwzvMbaTGLhw8pXUnhDK91oSJLDPF1bmGk=
github.com/go-openapi/swag/yamlutils v0.25.1/go.mod h1:cm9ywbzncy3y6uPm/97ysW8+wZ09qsks+9RS8fLWKqg=
github.com/go-openapi/testify/v2 v2.0.2 h1:X999g3jeLcoY8qctY/c/Z8iBHTbwLz7R2WXd6Ub6wls=
github.com/go-openapi/testify/v2 v2.0.2/go.mod h1:HCPmvFFnheKK2BuwSA0TbbdxJ3I16pjwMkYkP4Ywn54=
github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
@@ -22,8 +48,8 @@ github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -35,12 +61,24 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
github.com/swaggo/files/v2 v2.0.2 h1:Bq4tgS/yxLB/3nwOMcul5oLEUKa877Ykgz3CJMVbQKU=
github.com/swaggo/files/v2 v2.0.2/go.mod h1:TVqetIzZsO9OhHX1Am9sRf9LdrFZqoK49N37KON/jr0=
github.com/swaggo/http-swagger/v2 v2.0.2 h1:FKCdLsl+sFCx60KFsyM0rDarwiUSZ8DqbfSyIKC9OBg=
github.com/swaggo/http-swagger/v2 v2.0.2/go.mod h1:r7/GBkAWIfK6E/OLnE8fXnviHiDeAHmgIyooa4xm3AQ=
github.com/swaggo/swag v1.16.6 h1:qBNcx53ZaX+M5dxVyTrgQ0PJ/ACK+NzhwcbieTt+9yI=
github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4Xesg=
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
golang.org/x/crypto v0.44.0 h1:A97SsFvM3AIwEEmTBiaxPPTYpDC47w720rdiiUvgoAU=
golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc=
golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ=
golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
internal/handler/contact.go
+26
View File
@@ -33,6 +33,18 @@ func NewContactHandler(str store.ContactStore) *ContactHandler {
return &ContactHandler{ContactStore: str}
}
// AddContact godoc
// @Summary Add contact
// @Description Add a contact record to have a recipient to send a text to (requires JWT)
// @Tags contacts
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body RequestAddContact true "Data to add contact"
// @Success 201 {object} AddContactResponse
// @Failure 400 {object} AddContactResponse
// @Failure 500 {object} AddContactResponse
// @Router /contact/new [post]
func (c *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
@@ -76,6 +88,19 @@ func (c *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
RespondWithJSON(w, statusCode, &resp)
}
// GetContact godoc
// @Summary Get contact
// @Description Get a contact record to have a recipient to send a text to (requires JWT)
// @Tags contacts
// @Accept json
// @Produce json
// @Param id path string true "Contact Id"
// @Param user_id path string true "User Id"
// @Security BearerAuth
// @Success 200 {object} GetContactResponse
// @Failure 400 {object} GetContactResponse
// @Failure 500 {object} GetContactResponse
// @Router /contact [get]
func (c *ContactHandler) GetContact(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
fmt.Println("Method:", r.Method)
@@ -83,6 +108,7 @@ func (c *ContactHandler) GetContact(w http.ResponseWriter, r *http.Request) {
return
}
// One or the other
var id, userId uuid.UUID
queryParams := r.URL.Query()
internal/handler/contact_test.go
+3 -2
View File
@@ -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/draftMessage.go
+1
View File
@@ -4,6 +4,7 @@ import "net/http"
import "git.kundeng.us/phoenix/textsender-api/internal/model"
// TODO: Remove file
func DraftMessageHandler(w http.ResponseWriter, r *http.Request) {
da := model.MessageItem{
Id: 1,
internal/handler/endpoint/endpoint.go
+7
View File
@@ -5,3 +5,10 @@ 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 GetScheduledMessageEndpoint = "/api/v1/schedule/message"
const AddEventToScheduledMessageEndpoint = "/api/v1/schedule/message/event"
const GetScheduledMessageEventEndpoint = "/api/v1/schedule/message/event"
const DeleteScheduledMessageEventEndpoint = "/api/v1/schedule/message/event/{id}"
const UpdateScheduledMessageStatusEndpoint = "/api/v1/schedule/message/status/update"
const FetchNextScheduledMessageEndpoint = "/api/v1/schedule/message/fetch"
internal/handler/helper.go
+21 -3
View File
@@ -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)
}
}
internal/handler/message.go
+29 -5
View File
@@ -33,6 +33,17 @@ func NewMessageHandler(str store.MessageStore) *MessageHandler {
return &MessageHandler{MessageStore: str}
}
// AddMessage godoc
// @Summary Add message
// @Description Add a message record to send a text to (requires JWT)
// @Tags messages
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body RequestAddMessage true "Data to add message"
// @Success 201 {object} AddMessageResponse
// @Failure 500 {object} AddMessageResponse
// @Router /message/new [post]
func (m *MessageHandler) AddMessage(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
@@ -64,6 +75,19 @@ func (m *MessageHandler) AddMessage(w http.ResponseWriter, r *http.Request) {
RespondWithJSON(w, statusCode, &resp)
}
// GetMessage godoc
// @Summary Get message
// @Description Get a message record to have a recipient to send a text to (requires JWT)
// @Tags messages
// @Accept json
// @Produce json
// @Param id path string true "Message Id"
// @Param user_id path string true "User Id"
// @Security BearerAuth
// @Success 200 {object} GetMessageResponse
// @Failure 400 {object} GetMessageResponse
// @Failure 500 {object} GetMessageResponse
// @Router /message [get]
func (c *MessageHandler) GetMessage(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
@@ -114,10 +138,10 @@ func (c *MessageHandler) GetMessage(w http.ResponseWriter, r *http.Request) {
}
} else if userId != uuid.Nil {
fmt.Println("Checking with User Id")
if contacts, err := c.MessageStore.GetAllMessages(ctx); err == nil {
for _, con := range contacts {
if con.UserId == userId {
resp.Data = append(resp.Data, *con)
if messages, err := c.MessageStore.GetAllMessages(ctx); err == nil {
for _, msg := range messages {
if msg.UserId == userId {
resp.Data = append(resp.Data, *msg)
}
}
@@ -126,7 +150,7 @@ func (c *MessageHandler) GetMessage(w http.ResponseWriter, r *http.Request) {
resp.Message = "Successful"
} else {
statusCode = http.StatusNotFound
resp.Message = "Contact not found"
resp.Message = "Message not found"
}
} else {
statusCode = http.StatusInternalServerError
internal/handler/message_test.go
+3 -2
View File
@@ -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/schedule_message_status.go
+167
View File
@@ -0,0 +1,167 @@
package handler
import (
"net/http"
"github.com/google/uuid"
"git.kundeng.us/phoenix/textsender-api/internal/store"
"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
)
type RequestScheduledMessageStatus struct {
ScheduledMessageId uuid.UUID `json:"scheduled_message_id"`
Status string `json:"status"`
}
type ScheduledMessageChange struct {
OldStatus string `json:"old_status"`
ScheduledMessage scheduling.ScheduledMessage `json:"scheduled_message"`
}
type ScheduledMessageStatusResponse struct {
Message string `json:"message"`
Data []ScheduledMessageChange `json:"data"`
}
type ScheduledMessageStatusHandler struct {
ScheduledMessageEventStore store.ScheduledMessageEventStore
ScheduledMessageStore store.ScheduledMessageStore
}
func NewScheduledMessageStatusHandler(str store.ScheduledMessageEventStore, schStore store.ScheduledMessageStore) *ScheduledMessageStatusHandler {
return &ScheduledMessageStatusHandler{ScheduledMessageEventStore: str, ScheduledMessageStore: schStore}
}
// UpdateStatus godoc
// @Summary Update status
// @Description Update the status of a scheduled message (requires JWT)
// @Tags status
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body RequestScheduledMessageStatus true "Used to update scheduled message status"
// @Success 201 {object} ScheduledMessageStatusResponse
// @Failure 400 {object} ScheduledMessageStatusResponse
// @Failure 404 {object} ScheduledMessageStatusResponse
// @Failure 500 {object} ScheduledMessageStatusResponse
// @Router /schedule/message/status/update [patch]
func (s *ScheduledMessageStatusHandler) UpdateStatus(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPatch {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var req RequestScheduledMessageStatus
if err := ExtractFromRequest(r, &req); err != nil {
http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
}
defer r.Body.Close()
var statusCode int
var resp ScheduledMessageStatusResponse
if req.ScheduledMessageId == uuid.Nil {
statusCode = http.StatusBadRequest
resp.Message = "Scheduled messaged Id is nil"
} else if len(req.Status) == 0 {
statusCode = http.StatusBadRequest
resp.Message = "No status provided"
} else {
ctx := r.Context()
if schMsg, err := s.ScheduledMessageStore.Get(ctx, req.ScheduledMessageId); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
if schMsg.Status == scheduling.Done {
statusCode = http.StatusNotFound
resp.Message = "Scheduled message has already completed"
} else {
switch req.Status {
case scheduling.Pending:
{
if schMsg.Status == scheduling.Processing {
statusCode = http.StatusBadRequest
resp.Message = "Message is currently processing"
} else {
if returnedStatus, err := s.ScheduledMessageStore.UpdateStatus(ctx, schMsg.Id, req.Status); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
chg := initScheduledMessageChange(schMsg, schMsg.Status, *returnedStatus)
statusCode = http.StatusOK
resp.Message = "Successful"
resp.Data = append(resp.Data, chg)
}
}
}
case scheduling.Ready:
{
if events, err := s.ScheduledMessageEventStore.GetWithScheduleMessageId(ctx, schMsg.Id); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
oldStatus := schMsg.Status
if schMsg.Status != scheduling.Processing && schMsg.Status != scheduling.Ready {
// Update status
if len(events) > 0 {
if returnedStatus, err := s.ScheduledMessageStore.UpdateStatus(ctx, schMsg.Id, req.Status); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
chg := initScheduledMessageChange(schMsg, oldStatus, *returnedStatus)
statusCode = http.StatusOK
resp.Message = "Successful"
resp.Data = append(resp.Data, chg)
}
} else {
statusCode = http.StatusInternalServerError
resp.Message = "Not enough scheduled message events"
}
} else {
if schMsg.Status == scheduling.Processing {
statusCode = http.StatusBadRequest
resp.Message = "Scheduled messages are processing"
} else {
statusCode = http.StatusNotModified
resp.Message = "Status is already set"
}
}
}
}
case scheduling.Processing, scheduling.Done:
{
if events, err := s.ScheduledMessageEventStore.GetWithScheduleMessageId(ctx, schMsg.Id); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
if len(events) > 0 {
if returnedStatus, err := s.ScheduledMessageStore.UpdateStatus(ctx, schMsg.Id, req.Status); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
chg := initScheduledMessageChange(schMsg, schMsg.Status, *returnedStatus)
statusCode = http.StatusOK
resp.Message = "Successful"
resp.Data = append(resp.Data, chg)
}
} else {
statusCode = http.StatusInternalServerError
resp.Message = "Not enough scheduled message events"
}
}
}
}
}
}
}
RespondWithJSON(w, statusCode, &resp)
}
func initScheduledMessageChange(schMsg *scheduling.ScheduledMessage, oldStatus, newStatus string) ScheduledMessageChange {
schMsg.Status = newStatus
return ScheduledMessageChange{OldStatus: oldStatus, ScheduledMessage: *schMsg}
}
internal/handler/schedule_message_status_test.go
+73
View File
@@ -0,0 +1,73 @@
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"
)
func TestUpdateScheduledMessageStatusWithMock(t *testing.T) {
now := time.Now()
schMsgEventStore := mock.NewMockScheduledMessageEventStore()
contactStore := mock.NewMockContactStore()
messageStore := mock.NewMockMessageStore()
schMsgStore := mock.NewMockScheduledMessageStore()
recipientId := uuid.New()
messageId := uuid.New()
scheduledMessageId := uuid.New()
testUserId := uuid.New()
con := testContact(recipientId, testUserId)
msg := testMessage(messageId, testUserId)
schMsg := testScheduledMessage(scheduledMessageId, testUserId, now)
event := testScheduledMessageEvent(msg.Id, con.Id, 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)
}
testReq := RequestScheduledMessageStatus{}
testReq.Status = scheduling.Ready
testReq.ScheduledMessageId = schMsg.Id
jsonValue, _ := json.Marshal(testReq)
jsonBody := strings.NewReader(string(jsonValue))
req, _ := http.NewRequest("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, jsonBody)
rr := httptest.NewRecorder()
handler := NewScheduledMessageStatusHandler(schMsgEventStore, schMsgStore)
handler.UpdateStatus(rr, req)
assert.Equal(t, http.StatusOK, rr.Code)
var response ScheduledMessageStatusResponse
err := json.Unmarshal(rr.Body.Bytes(), &response)
assert.NoError(t, err, "Error creating event %v", err)
assert.NotEmpty(t, response.Data, "Data should not be empty")
changes := response.Data[0]
assert.NotEqual(t, changes.OldStatus, changes.ScheduledMessage.Status, "The status should not match")
assert.Equal(t, scheduling.Pending, changes.OldStatus, "The Old status does not match Old %s New %s", changes.OldStatus, scheduling.Pending)
assert.Equal(t, scheduling.Ready, changes.ScheduledMessage.Status, "Status has not been updated")
}
internal/handler/scheduled_message.go
+240
View File
@@ -0,0 +1,240 @@
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"`
Status string `json:"status"`
UserId uuid.UUID `json:"user_id"`
}
type AddScheduledMessageResponse struct {
Message string `json:"message"`
Data []scheduling.ScheduledMessage `json:"data"`
}
type GetScheduledMessageResponse struct {
Message string `json:"message"`
Data []scheduling.ScheduledMessage `json:"data"`
}
type FetchNextMessageResponse 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}
}
// AddScheduledMessage godoc
// @Summary Add scheduled message
// @Description Adds a scheduled message (requires JWT)
// @Tags scheduled messages
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body RequestAddScheduledMessage true "Data to add scheduled message"
// @Success 201 {object} AddScheduledMessageResponse
// @Failure 400 {object} AddScheduledMessageResponse
// @Failure 500 {object} AddScheduledMessageResponse
// @Router /schedule/message [post]
func (s *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 = s.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)
}
// GetScheduledMessage godoc
// @Summary Get scheduled message
// @Description Get a scheduled message (requires JWT)
// @Tags scheduled messages
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path string true "Contact Id"
// @Param user_id path string true "User Id"
// @Success 200 {object} GetScheduledMessageResponse
// @Failure 400 {object} GetScheduledMessageResponse
// @Failure 500 {object} GetScheduledMessageResponse
// @Router /schedule/message [get]
func (s *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 := s.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 := s.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 := s.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)
}
// FetchNextMessage godoc
// @Summary Fetch scheduled message
// @Description Fetches a scheduled message that is available to be processed (requires JWT)
// @Tags scheduled messages
// @Accept json
// @Produce json
// @Security BearerAuth
// @Success 200 {object} FetchNextMessageResponse
// @Failure 400 {object} FetchNextMessageResponse
// @Failure 500 {object} FetchNextMessageResponse
// @Router /schedule/message/fetch [get]
func (s *ScheduledMessageHandler) FetchNextMessage(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
var resp FetchNextMessageResponse
var statusCode int
if schMsg, err := s.ScheduledMessageStore.FetchNextScheduledMessage(ctx); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
if schMsg != nil {
statusCode = http.StatusOK
resp.Message = "Successful"
resp.Data = append(resp.Data, *schMsg)
} else {
statusCode = http.StatusNotFound
resp.Message = "No item"
}
}
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
+245
View File
@@ -0,0 +1,245 @@
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 DeleteScheduledMessageEventResponse struct {
Message string `json:"message"`
Data []scheduling.ScheduledMessageEvent `json:"data"`
}
type ScheduledMessageEventHandler struct {
ScheduledMessageEventStore store.ScheduledMessageEventStore
ScheduledMessageStore store.ScheduledMessageStore
}
func NewScheduledMessageEventHandler(str store.ScheduledMessageEventStore, schStore store.ScheduledMessageStore) *ScheduledMessageEventHandler {
return &ScheduledMessageEventHandler{ScheduledMessageEventStore: str, ScheduledMessageStore: schStore}
}
// AddContact godoc
// @Summary Add scheduled message event
// @Description Add a scheduled message event (requires JWT)
// @Tags scheduled message events
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body RequestAddScheduledMessageEvent true "Data to add scheduled message event"
// @Success 201 {object} AddScheduledMessageEventResponse
// @Failure 400 {object} AddScheduledMessageEventResponse
// @Failure 500 {object} AddScheduledMessageEventResponse
// @Router /schedule/message/event [post]
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 schMsg, err := s.ScheduledMessageStore.Get(ctx, event.ScheduledMessageId); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
if schMsg.Status == scheduling.Pending {
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()
}
} else {
statusCode = http.StatusBadRequest
resp.Message = "Scheduled message cannot be modified due to the status"
}
}
}
RespondWithJSON(w, statusCode, &resp)
}
// GetScheduledMessageEvent godoc
// @Summary Get scheduled message event
// @Description Gets a scheduled message event (requires JWT)
// @Tags scheduled message events
// @Accept json
// @Produce json
// @Param id path string true "Contact Id"
// @Param scheduled_message_id path string true "Scheduled Message Id"
// @Security BearerAuth
// @Success 200 {object} GetScheduledMessageEventResponse
// @Failure 400 {object} GetScheduledMessageEventResponse
// @Failure 500 {object} GetScheduledMessageEventResponse
// @Router /schedule/message/event [get]
func (s *ScheduledMessageEventHandler) GetScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "Metnot allowed", http.StatusMethodNotAllowed)
return
}
var id, scheduledMessageId uuid.UUID
if idParam, err := ParseQueryParams(r, "id"); err == nil {
id, err = uuid.Parse(*idParam)
}
if scheduledMessageIdParam, err := ParseQueryParams(r, "scheduled_message_id"); err == nil {
scheduledMessageId, err = uuid.Parse(*scheduledMessageIdParam)
}
var statusCode int
var resp GetScheduledMessageEventResponse
ctx := r.Context()
if id == uuid.Nil && scheduledMessageId == uuid.Nil {
statusCode = http.StatusBadRequest
resp.Message = "Query parameters missing"
} else if id != uuid.Nil {
if event, err := s.ScheduledMessageEventStore.Get(ctx, id); err != nil {
resp.Message = err.Error()
statusCode = http.StatusInternalServerError
} else {
if event != nil {
resp.Message = "Successful"
statusCode = http.StatusOK
resp.Data = append(resp.Data, *event)
} else {
statusCode = http.StatusNotFound
resp.Message = "Scheduled message event not found"
}
}
} else {
if events, err := s.ScheduledMessageEventStore.GetWithScheduleMessageId(ctx, scheduledMessageId); err != nil {
statusCode = http.StatusInternalServerError
resp.Message = err.Error()
} else {
statusCode = http.StatusOK
resp.Message = "Successful"
for _, event := range events {
resp.Data = append(resp.Data, *event)
}
}
}
RespondWithJSON(w, statusCode, &resp)
}
// DeleteScheduledMessageEvent godoc
// @Summary Delete scheduled message event
// @Description Deletes a scheduled message event (requires JWT)
// @Tags scheduled message events
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path string true "scheduled message event Id" Format(uuid)
// @Success 201 {object} DeleteScheduledMessageEventResponse
// @Failure 400 {object} DeleteScheduledMessageEventResponse
// @Failure 500 {object} DeleteScheduledMessageEventResponse
// @Router /schedule/message/event/{id} [delete]
func (s *ScheduledMessageEventHandler) DeleteScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
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 resp DeleteScheduledMessageEventResponse
var statusCode int
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 {
if schMsg, err := s.ScheduledMessageStore.Get(ctx, event.ScheduledMessageId); err != nil {
resp.Message = err.Error()
statusCode = http.StatusInternalServerError
} else {
if schMsg.Status == scheduling.Pending {
if err = s.ScheduledMessageEventStore.Delete(ctx, event.Id); err != nil {
resp.Message = err.Error()
statusCode = http.StatusInternalServerError
} else {
resp.Message = "Successful"
resp.Data = append(resp.Data, *event)
statusCode = http.StatusOK
}
} else {
statusCode = http.StatusBadRequest
resp.Message = "Invalid status"
}
}
}
}
RespondWithJSON(w, statusCode, &resp)
}
internal/handler/scheduled_message_event_test.go
+206
View File
@@ -0,0 +1,206 @@
package handler
import (
"encoding/json"
"fmt"
"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"
)
var (
recipientId = uuid.New()
messageId = uuid.New()
scheduledMessageId = uuid.New()
testUserId = uuid.New()
)
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, schMsgStore)
recipientId := uuid.New()
messageId := uuid.New()
scheduledMessageId := uuid.New()
testUserId := uuid.New()
con := testContact(recipientId, testUserId)
msg := testMessage(messageId, testUserId)
schMsg := testScheduledMessage(scheduledMessageId, testUserId, now)
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, schMsgStore)
recipientId := uuid.New()
messageId := uuid.New()
scheduledMessageId := uuid.New()
testUserId := uuid.New()
con := testContact(recipientId, testUserId)
msg := testMessage(messageId, testUserId)
schMsg := testScheduledMessage(scheduledMessageId, testUserId, now)
event := testScheduledMessageEvent(msg.Id, con.Id, 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)
}
url := fmt.Sprintf("%s?id=%s", endpoint.GetScheduledMessageEventEndpoint, event.Id.String())
req, _ := http.NewRequest("GET", url, 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")
}
func TestDeleteScheduledMessageEventWithMock(t *testing.T) {
now := time.Now()
contactStore := mock.NewMockContactStore()
messageStore := mock.NewMockMessageStore()
schMsgStore := mock.NewMockScheduledMessageStore()
schMsgEventStore := mock.NewMockScheduledMessageEventStore()
handler := NewScheduledMessageEventHandler(schMsgEventStore, schMsgStore)
con := testContact(recipientId, testUserId)
msg := testMessage(messageId, testUserId)
schMsg := testScheduledMessage(scheduledMessageId, testUserId, now)
event := testScheduledMessageEvent(msg.Id, con.Id, 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.DeleteScheduledMessageEventEndpoint, "{id}", event.Id.String(), 1)
req, _ := http.NewRequest("DELETE", endpointValue, nil)
rr := httptest.NewRecorder()
handler.DeleteScheduledMessageEvent(rr, req)
assert.Equal(t, http.StatusOK, rr.Code)
var response DeleteScheduledMessageEventResponse
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")
}
func testContact(id uuid.UUID, userId uuid.UUID) contact.Contact {
if id == uuid.Nil {
return contact.Contact{Id: uuid.New(), PhoneNumber: "+10123456789", UserId: userId}
} else {
return contact.Contact{Id: id, PhoneNumber: "+10123456789", UserId: userId}
}
}
func testMessage(id uuid.UUID, userId uuid.UUID) message.Message {
if id == uuid.Nil {
return message.Message{Id: uuid.New(), Content: "Oh how the mighty have fallen", UserId: userId}
} else {
return message.Message{Id: id, Content: "Oh how the mighty have fallen", UserId: userId}
}
}
func testScheduledMessage(id uuid.UUID, userId uuid.UUID, now time.Time) scheduling.ScheduledMessage {
if id == uuid.Nil {
return scheduling.ScheduledMessage{Id: uuid.New(), UserId: userId, Scheduled: now.Add(20 * time.Minute), Status: scheduling.Pending}
} else {
return scheduling.ScheduledMessage{Id: id, UserId: userId, Scheduled: now.Add(20 * time.Minute), Status: scheduling.Pending}
}
}
func testScheduledMessageEvent(messageId, recipientId, scheduledMessageId uuid.UUID) scheduling.ScheduledMessageEvent {
return scheduling.ScheduledMessageEvent{MessageId: messageId, RecipientId: recipientId, ScheduledMessageId: scheduledMessageId}
}
internal/handler/scheduled_message_test.go
+135
View File
@@ -0,0 +1,135 @@
package handler
import (
"encoding/json"
"fmt"
"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()
testBody := testCreateScheduledMessageRequest(testUserId, now)
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")
}
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 TestFetchScheduledMessageWithMock(t *testing.T) {
now := time.Now()
mockStore := mock.NewMockScheduledMessageStore()
contactStore := mock.NewMockContactStore()
messageStore := mock.NewMockMessageStore()
schMsgEventStore := mock.NewMockScheduledMessageEventStore()
recipientId := uuid.New()
messageId := uuid.New()
scheduledMessageId := uuid.New()
testUserId := uuid.New()
con := testContact(recipientId, testUserId)
msg := testMessage(messageId, testUserId)
schMsg := testScheduledMessage(scheduledMessageId, testUserId, now)
event := testScheduledMessageEvent(msg.Id, con.Id, 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 = mockStore.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)
} else if newStatus, err := mockStore.UpdateStatus(ctx, schMsg.Id, scheduling.Ready); err != nil {
assert.NoError(t, err, "Error updating status: %v", err)
} else {
assert.Equal(t, *newStatus, scheduling.Ready)
}
req, _ := http.NewRequest("GET", endpoint.FetchNextScheduledMessageEndpoint, nil)
rr := httptest.NewRecorder()
handler := NewScheduledMessageHandler(mockStore)
handler.FetchNextMessage(rr, req)
assert.Equal(t, http.StatusOK, rr.Code)
var response FetchNextMessageResponse
err := json.Unmarshal(rr.Body.Bytes(), &response)
assert.NoError(t, err, "Error fetching scheduled message: %v", err)
assert.NotEmpty(t, response.Data, "No data")
fetchedSchMsg := response.Data[0]
assert.Equal(t, scheduling.Processing, fetchedSchMsg.Status, "The statuses do not match")
}
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/handler/mock_store_test.go → internal/store/mock/mock_store.go
+1 -1
View File
@@ -1,4 +1,4 @@
package handler
package mock
import (
"context"
internal/store/mock/scheduled_message_event_store.go
+160
View File
@@ -0,0 +1,160 @@
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 {
return nil, fmt.Errorf("Not found")
}
}
func (m *MockScheduledMessageEventStore) GetWithScheduleMessageId(ctx context.Context, schMsgId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.Error != nil {
return nil, m.Error
}
if schMsgId == uuid.Nil {
return nil, fmt.Errorf("Scheduled message Id is nil")
}
var events []*scheduling.ScheduledMessageEvent
for _, event := range m.ScheduledMessageEvents {
if event.ScheduledMessageId == schMsgId {
events = append(events, event)
}
}
if len(events) > 0 {
return events, nil
} else {
return nil, nil
}
}
func (m *MockScheduledMessageEventStore) Delete(ctx context.Context, id uuid.UUID) error {
m.mu.Lock()
defer m.mu.Unlock()
if m.Error != nil {
return m.Error
}
if id == uuid.Nil {
return fmt.Errorf("Id is nil")
}
if _, exists := m.ScheduledMessageEvents[id]; exists {
originalAmount := len(m.ScheduledMessageEvents)
copiedEvents := make(map[uuid.UUID]*scheduling.ScheduledMessageEvent)
copiedEventsKey := make(map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent)
for i, schMsgEvent := range m.ScheduledMessageEvents {
key := ScheduledMessageEventKey{RecipientId: schMsgEvent.RecipientId, MessageId: schMsgEvent.MessageId, ScheduledMessageId: schMsgEvent.ScheduledMessageId}
if schMsgEvent.Id != id {
copiedEvents[i] = schMsgEvent
copiedEventsKey[key] = schMsgEvent
}
}
if originalAmount > 1 {
if len(copiedEvents) > 0 && len(copiedEventsKey) > 0 {
m.ScheduledMessageEvents = copiedEvents
m.ScheduledMessageEventsByKey = copiedEventsKey
return nil
} else {
return fmt.Errorf("Not removed")
}
} else {
m.ScheduledMessageEvents = make(map[uuid.UUID]*scheduling.ScheduledMessageEvent)
m.ScheduledMessageEventsByKey = make(map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent)
return nil
}
} else {
return 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/mock/scheduled_message_store.go
+142
View File
@@ -0,0 +1,142 @@
package mock
import (
"context"
"fmt"
"sync"
"github.com/google/uuid"
"git.kundeng.us/phoenix/textsender-models/pkg/message/scheduling"
)
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) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, 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")
} else {
if schMsg := m.ScheduledMessages[id]; schMsg != nil {
return schMsg, nil
} else {
return nil, fmt.Errorf("Scheduled message does not exist")
}
}
}
func (m *MockScheduledMessageStore) FetchNextScheduledMessage(ctx context.Context) (*scheduling.ScheduledMessage, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.Error != nil {
return nil, m.Error
}
var schMsg *scheduling.ScheduledMessage
for _, msg := range m.ScheduledMessages {
if msg.Status == scheduling.Ready {
msg.Status = scheduling.Processing
schMsg = msg
break
}
}
if schMsg == nil {
return nil, fmt.Errorf("No scheduled message is ready")
} else {
return schMsg, nil
}
}
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()
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
}
func (m *MockScheduledMessageStore) UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, 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")
} else {
if schMsg := m.ScheduledMessages[id]; schMsg != nil {
key := ScheduledMessageKey{UserId: schMsg.UserId}
schMsg.Status = updatedStatus
m.ScheduledMessages[schMsg.Id] = schMsg
m.ScheduledMessagesByKey[key] = schMsg
return &updatedStatus, nil
} else {
return nil, fmt.Errorf("Scheduled message does not exist")
}
}
}
internal/store/scheduled_message_event_store.go
+114
View File
@@ -0,0 +1,114 @@
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)
GetWithScheduleMessageId(ctx context.Context, schMsgId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error)
Delete(ctx context.Context, id uuid.UUID) 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
} else if err != nil {
return nil, fmt.Errorf("getting scheduled message event by ID: %w", err)
} else {
return &event, nil
}
}
func (s *PGScheduledMessageEventStore) GetWithScheduleMessageId(ctx context.Context, schMsgId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error) {
var events []*scheduling.ScheduledMessageEvent
query := `SELECT id, recipient_id, message_id, scheduled_message_id, created FROM scheduled_message_events WHERE scheduled_message_id = $1
`
rows, err := s.db.Query(ctx, query, schMsgId)
if err != nil {
return nil, fmt.Errorf("Error retrieving rows from scheduled_message_Events: %w", err)
}
for rows.Next() {
var event scheduling.ScheduledMessageEvent
if err := rows.Scan(&event.Id, &event.RecipientId, &event.MessageId, &event.ScheduledMessageId, &event.Created); err != nil {
return nil, fmt.Errorf("Error fetching data from row: %w", err)
} else {
events = append(events, &event)
}
}
if err := rows.Err(); err != nil {
return nil, err
}
return events, nil
}
func (s *PGScheduledMessageEventStore) Delete(ctx context.Context, id uuid.UUID) error {
query := `
DELETE FROM scheduled_message_events WHERE id = $1
`
commandTag, err := s.db.Exec(ctx, query, id)
if err != nil {
return fmt.Errorf("error deleting event: %w", err)
}
if commandTag.RowsAffected() == 0 {
return fmt.Errorf("no event found with id %d", id)
} else {
return 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
+128
View File
@@ -0,0 +1,128 @@
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 ScheduledMessageStore interface {
Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error)
FetchNextScheduledMessage(ctx context.Context) (*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)
}
type PGScheduledMessageStore struct {
db *pgxpool.Pool
}
func NewScheduledMessageStore(db *pgxpool.Pool) *PGScheduledMessageStore {
return &PGScheduledMessageStore{db: db}
}
func (s *PGScheduledMessageStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error) {
query := `
SELECT id, scheduled, created, status, user_id FROM scheduled_messages WHERE id = $1
`
var schMsg scheduling.ScheduledMessage
err := s.db.QueryRow(ctx, query, id).Scan(
&schMsg.Id, &schMsg.Scheduled, &schMsg.Created, &schMsg.Status, &schMsg.UserId,
)
if err == pgx.ErrNoRows {
return nil, fmt.Errorf("No rows")
} else if err != nil {
return nil, fmt.Errorf("Getting scheduled message: %w", err)
}
return &schMsg, nil
}
func (s *PGScheduledMessageStore) FetchNextScheduledMessage(ctx context.Context) (*scheduling.ScheduledMessage, error) {
query := `
UPDATE scheduled_messages
SET status = $1
WHERE id = (
SELECT id FROM scheduled_messages
WHERE status = $2
ORDER BY id
FOR UPDATE SKIP LOCKED
LIMIT 1
)
RETURNING id, scheduled, created, status, user_id
`
var schMsg scheduling.ScheduledMessage
err := s.db.QueryRow(ctx, query, scheduling.Processing, scheduling.Ready).Scan(
&schMsg.Id, &schMsg.Scheduled, &schMsg.Created, &schMsg.Status, &schMsg.UserId,
)
if err == pgx.ErrNoRows {
return nil, nil
} else if err != nil {
return nil, fmt.Errorf("Getting scheduled message: %w", err)
} else {
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)
VALUES ($1, $2, $3)
RETURNING id, created
`
return s.db.QueryRow(ctx, query, schedMsg.Scheduled, schedMsg.Status, schedMsg.UserId).Scan(
&schedMsg.Id, &schedMsg.Created,
)
}
func (s *PGScheduledMessageStore) UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, error) {
query := `
UPDATE scheduled_messages set status = $1 WHERE id = $2
RETURNING status
`
var returnedStatus string
if err := s.db.QueryRow(ctx, query, updatedStatus, id).Scan(&returnedStatus); err != nil {
return nil, err
} else {
return &returnedStatus, nil
}
}
migrations/schema.sql
+18 -2
View File
@@ -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()
)