createprose.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strings"
	"time"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgtype"
	auth "github.com/jaydee029/Verses/internal/auth"
	"github.com/jaydee029/Verses/internal/database"
)

type Prose struct {
	ID          pgtype.UUID      `json:"id,omitempty"`
	Userid      pgtype.UUID      `json:"userid,omitempty"`
	Body        string           `json:"body"`
	User        *User            `json:"user,omitempty"`
	Created_at  pgtype.Timestamp `json:"created_at"`
	Updated_at  pgtype.Timestamp `json:"Updated_at"`
	Mine        bool             `json:"mine"`
	Liked       bool             `json:"liked"`
	Likes_count int              `json:"likes_count"`
	Username    string           `json:"username,omitempty"`
	Comments    int              `json:"comments,omitempty"`
}

type body struct {
	Body string `json:"body"`
}

func (cfg *apiconfig) postProse(w http.ResponseWriter, r *http.Request) {

	token, err := auth.BearerHeader(r.Header)

	if err != nil {
		respondWithError(w, http.StatusUnauthorized, "error decoding auth header:"+err.Error())
		return
	}
	authorid, err := auth.ValidateToken(token, cfg.jwtsecret)

	if err != nil {
		respondWithError(w, http.StatusUnauthorized, "error parsing the userid:"+err.Error())
		return
	}
	decoder := json.NewDecoder(r.Body)
	params := body{}
	err = decoder.Decode(&params)

	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "parameters couldn't be decoded")
		return
	}

	cleanText := strings.TrimSpace(params.Body)

	if len([]rune(cleanText)) > 280 || cleanText == "" {
		respondWithError(w, http.StatusBadRequest, "Prose is invalid")
		return
	}

	var pgUUID pgtype.UUID
	err = pgUUID.Scan(authorid)
	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "error parsing into pgtype.uuid")
		return
	}
	uuids := uuid.New().String()
	var post_pgUUID pgtype.UUID

	err = post_pgUUID.Scan(uuids)
	if err != nil {
		fmt.Println("Error setting UUID:", err)
	}

	//total, _ := cfg.DB.Countprose(r.Context(), pgUUID)
	content := profane(cleanText)

	var pgtime pgtype.Timestamp
	err = pgtime.Scan(time.Now().UTC())
	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "error parsing timestamp into pgtype value")
		return
	}

	tx, err := cfg.DBpool.Begin(r.Context())
	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "error starting the transaction"+err.Error())
		return
	}

	qtx := cfg.DB.WithTx(tx)

	defer tx.Rollback(r.Context())

	prose, err := qtx.Createprose(r.Context(), database.CreateproseParams{
		ID:        post_pgUUID,
		AuthorID:  pgUUID,
		Body:      content,
		CreatedAt: pgtime,
		UpdatedAt: pgtime,
	})

	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "couldn't create Prose")
		return
	}

	respondWithJson(w, http.StatusCreated, Prose{
		ID:         post_pgUUID,
		Body:       prose.Body,
		Created_at: prose.CreatedAt,
		Updated_at: prose.UpdatedAt,
		Mine:       true,
	})

	err = qtx.InserinTimeline(r.Context(), database.InserinTimelineParams{
		ProseID: post_pgUUID,
		UserID:  pgUUID,
	})
	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "couldn't insert Prose in the timeline")
		return
	}

	var tl timeline_item

	//tl.Userid = pgUUID
	tl.Post.ID = post_pgUUID
	tl.Post.Mine = true
	tl.Post.Userid = pgUUID
	tl.Post.Body = cleanText

	err = tx.Commit(r.Context())
	if err != nil {
		respondWithError(w, http.StatusInternalServerError, "couldn't commit the transaction")
	}

	go cfg.prosecreation(tl.Post)

}

func (cfg *apiconfig) prosecreation(p Prose) {
	u, err := cfg.DB.GetUserbyId(context.Background(), p.Userid)

	if err != nil {
		log.Println(err)
		return
	}

	p.User.Email = u.Email
	p.User.ID = u.ID
	p.User.Name = u.Name
	p.User.Username = u.Username
	p.Mine = false

	go cfg.fanoutprose(p)
	go cfg.notifypostmentions(p)
}

func (cfg *apiconfig) fanoutprose(p Prose) {

	items, err := cfg.DB.FetchTimelineItems(context.Background(), database.FetchTimelineItemsParams{
		ProseID:    p.ID,
		FolloweeID: p.Userid,
	})

	if err != nil {
		log.Println(err)
		return
	}

	for _, k := range items {
		var ti timeline_item
		ti.Id = int(k.ID)
		ti.Userid = k.UserID
		ti.Post = p
		go cfg.Broadcasttimeline(ti)
	}

}

func profane(content string) string {
	contentslice := strings.Split(content, " ")

	for i, word := range contentslice {
		wordl := strings.ToLower(word)
		if wordl == "fuck" || wordl == "shit" || wordl == "fornax" {
			contentslice[i] = "****"
		}
	}

	return strings.Join(contentslice, " ")
}