schedtxt_api/internal/handler/contact.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/contact"
)

type RequestAddContact struct {
	PhoneNumber string    `json:"phone_number"`
	UserId      uuid.UUID `json:"user_id"`
}

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

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

type ContactHandler struct {
	ContactStore store.ContactStore
}

func NewContactHandler(str store.ContactStore) *ContactHandler {
	return &ContactHandler{ContactStore: str}
}

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

	var req RequestAddContact
	if err := ExtractFromRequest(r, &req); err != nil {
		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
	}
	defer r.Body.Close()

	newContact := contact.Contact{PhoneNumber: req.PhoneNumber, UserId: req.UserId}

	var statusCode int
	var resp AddContactResponse

	ctx := r.Context()

	if exists, err := c.ContactStore.ContactExists(ctx, newContact.PhoneNumber, newContact.UserId); err != nil {
		fmt.Printf("Error: %v", err)
		statusCode = http.StatusInternalServerError
		resp.Message = err.Error()
	} else {
		if exists {
			statusCode = http.StatusBadRequest
			resp.Message = "Cannot create contact"
		} else {
			if err := c.ContactStore.CreateContact(ctx, &newContact); err != nil {
				fmt.Printf("Error: %v", err)
				statusCode = http.StatusInternalServerError
				resp.Message = err.Error()
			} else {
				statusCode = http.StatusCreated
				resp.Message = "Contact created"
				resp.Data = append(resp.Data, newContact)
			}
		}
	}

	RespondWithJSON(w, statusCode, &resp)
}

func (c *ContactHandler) GetContact(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		fmt.Println("Method:", r.Method)
		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 GetContactResponse

	ctx := r.Context()

	if id != uuid.Nil {
		fmt.Println("Checking with Id")
		if con, err := c.ContactStore.GetContactByID(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.ContactStore.GetAllContacts(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)
}