chirp-create.go

package main

import (
	"encoding/json"
	"errors"
	"log"
	"net/http"
	"strings"
	"time"

	"github.com/google/uuid"
	"github.com/mdmdj/bootdev-chirpy/internal/auth"
	"github.com/mdmdj/bootdev-chirpy/internal/database"
)

type chirpCreateRequest struct {
	Body string `json:"body"`
	//UserID uuid.UUID `json:"user_id"`
}

type Chirp struct {
	ID        uuid.UUID `json:"id"`
	Body      string    `json:"body"`
	UserID    uuid.UUID `json:"user_id"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

func chirpCreateRoute(w http.ResponseWriter, r *http.Request) {
	requestParams := chirpCreateRequest{}

	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&requestParams)
	if err != nil {
		log.Printf("Error decoding chirpCreateRoute parameters: %s", err)
		respondWithError(w, http.StatusBadRequest, "Something went wrong")
		return
	}

	chirpBody, err := chirpValidate(requestParams.Body)
	if err != nil {
		log.Printf("Error validating chirp: %s", err)
		respondWithError(w, http.StatusBadRequest, "Chirp is invalid")
		return
	}

	token, err := auth.GetBearerToken(r.Header)
	if err != nil {
		log.Printf("Error in GetBearerToken: %s", err)
		respondWithError(w, http.StatusUnauthorized, "Something went wrong")
		return
	}

	userID, err := auth.ValidateJWT(token, cfg.secret)
	if err != nil {
		log.Printf("Error in ValidateJWT: %s", err)
		respondWithError(w, http.StatusUnauthorized, "Something went wrong")
		return
	}

	dbChirp, err := cfg.db.CreateChirp(
		r.Context(),
		database.CreateChirpParams{
			UserID: userID,
			Body:   chirpBody,
		})
	if err != nil {
		log.Printf("Error creating chirp: %s %s %s", err, userID, requestParams.Body)
		respondWithError(w, http.StatusInternalServerError, "Something went wrong")
		return
	}

	// Map database.User to main.User
	chirp := Chirp{
		ID:        dbChirp.ID,
		UserID:    dbChirp.UserID,
		Body:      dbChirp.Body,
		CreatedAt: dbChirp.CreatedAt,
		UpdatedAt: dbChirp.UpdatedAt,
	}

	respondWithJSON(w, http.StatusCreated, chirp)

}

func chirpValidate(input string) (result string, err error) {
	chirpValid := (len(input) <= 140)

	if !chirpValid {
		log.Printf("Chirp is too long: %s", input)
		err = errors.New("Chirp is too long")
		return
	}

	result = chirpClean(input)

	return result, nil

}

func chirpClean(incoming string) (result string) {
	incomingSplit := strings.Split(incoming, " ")
	incomingLower := strings.ToLower(incoming)
	incomingLowerSplit := strings.Split(incomingLower, " ")

	badWords := []string{"kerfuffle", "sharbert", "fornax"}

	for i, v := range incomingLowerSplit {
		for _, w := range badWords {
			if v == w {
				incomingSplit[i] = "****"
			}
		}
	}

	return strings.Join(incomingSplit, " ")
}