schedtxt_api/internal/handler/message.go

package handler

import (
	"fmt"
	"net/http"

	"github.com/google/uuid"

	"git.kundeng.us/phoenix/textsender-api/internal/store"
	"git.kundeng.us/phoenix/textsender-models/pkg/message"
)

type RequestAddMessage struct {
	Content string    `json:"content"`
	UserId  uuid.UUID `json:"user_id"`
}

type AddMessageResponse struct {
	Message string            `json:"message"`
	Data    []message.Message `json:"data"`
}

type GetMessageResponse struct {
	Message string            `json:"message"`
	Data    []message.Message `json:"data"`
}

type MessageHandler struct {
	MessageStore store.MessageStore
}

func NewMessageHandler(str store.MessageStore) *MessageHandler {
	return &MessageHandler{MessageStore: str}
}

func (m *MessageHandler) AddMessage(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	var req RequestAddMessage
	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 AddMessageResponse
	newMessage := message.Message{Content: req.Content, UserId: req.UserId}

	ctx := r.Context()

	if err := m.MessageStore.CreateMessage(ctx, &newMessage); err != nil {
		fmt.Println("Error:", err)
		statusCode = http.StatusInternalServerError
		resp.Message = err.Error()
	} else {
		statusCode = http.StatusCreated
		resp.Message = "Message created"
		resp.Data = append(resp.Data, newMessage)
	}

	RespondWithJSON(w, statusCode, &resp)
}

func (c *MessageHandler) GetMessage(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	var id, userId uuid.UUID
	queryParams := r.URL.Query()

	// Check if parameter exists
	if _, exists := queryParams["id"]; !exists {
		if _, exists := queryParams["user_id"]; !exists {
			fmt.Fprintf(w, "Name parameter not provided")
			http.Error(w, "Query params", http.StatusBadRequest)
			return
		} else {
			var err error
			userId, err = uuid.Parse(queryParams.Get("user_id"))
			if err != nil {
				fmt.Fprintf(w, "Name parameter exists: %s", userId)
			}
		}
	} else {
		var err error
		idTmp := queryParams.Get("id")
		id, err = uuid.Parse(idTmp)
		if err != nil {
			fmt.Println("Error:", err)
			http.Error(w, "Error parsing Id", http.StatusBadRequest)
			return
		}
	}

	var statusCode int
	var resp GetMessageResponse

	ctx := r.Context()

	if id != uuid.Nil {
		fmt.Println("Checking with Id")
		if con, err := c.MessageStore.GetMessageByID(ctx, id); err == nil {
			statusCode = http.StatusOK
			resp.Message = "Successful"
			resp.Data = append(resp.Data, *con)
		} else {
			statusCode = http.StatusInternalServerError
			resp.Message = err.Error()
		}
	} 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 len(resp.Data) > 0 {
				statusCode = http.StatusOK
				resp.Message = "Successful"
			} else {
				statusCode = http.StatusNotFound
				resp.Message = "Contact not found"
			}
		} else {
			statusCode = http.StatusInternalServerError
			resp.Message = err.Error()
		}
	} else {
		statusCode = http.StatusBadRequest
		resp.Message = "Invalid query parameter"
	}

	RespondWithJSON(w, statusCode, &resp)
}