New comments backend

README.md

@@ -23,7 +23,7 @@ the application works.
 
 ### Card wall
 
-REPLACE THIS TEXT WITH A LINK TO YOUR CARD WALL
+https://trello.com/invite/b/YyHEoIyD/ATTIe230926302b5d8daad7ead41ef861018888CCDA1/xenon-acebook-meta
 
 ### Quickstart
 

api/go.mod

@@ -20,6 +20,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-faker/faker/v4 v4.3.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-playground/validator/v10 v10.19.0 // indirect

api/go.sum

@@ -23,6 +23,8 @@ github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
 github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-faker/faker/v4 v4.3.0 h1:UXOW7kn/Mwd0u6MR30JjUKVzguT20EB/hBOddAAO+DY=
+github.com/go-faker/faker/v4 v4.3.0/go.mod h1:F/bBy8GH9NxOxMInug5Gx4WYeG6fHJZ8Ol/dhcpRub4=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=

api/main.go

@@ -26,6 +26,7 @@ func main() {
 	testPost.Save()
 
 	app.Run(":8082")
+
 }
 
 func setupApp() *gin.Engine {

api/seeds/seed.sql

@@ -0,0 +1,61 @@
+DROP TABLE IF EXISTS comments;
+DROP SEQUENCE IF EXISTS comments_id_seq;
+DROP TABLE IF EXISTS posts;
+DROP SEQUENCE IF EXISTS posts_id_seq;
+DROP TABLE IF EXISTS users;
+DROP SEQUENCE IF EXISTS users_id_seq;
+
+CREATE SEQUENCE IF NOT EXISTS users_id_seq;
+CREATE TABLE users (
+    id text PRIMARY KEY,
+    email text,
+    username text,
+    password text
+);
+
+-- Then the table with the foreign key second.
+CREATE SEQUENCE IF NOT EXISTS posts_id_seq;
+CREATE TABLE posts (
+    id SERIAL PRIMARY KEY,
+    content text,
+    likes int,
+-- The foreign key name is always {other_table_singular}_id
+    user_id text,
+    constraint fk_user foreign key(user_id)
+        references users(id)
+        on delete cascade
+);
+
+CREATE SEQUENCE IF NOT EXISTS comments_id_seq;
+CREATE TABLE comments (
+    id SERIAL PRIMARY KEY,
+    content text,
+    likes int,
+-- The foreign key name is always {other_table_singular}_id
+    post_id int,
+    constraint fk_post foreign key(post_id)
+        references posts(id)
+        on delete cascade
+);
+
+-- Seed the table with data 
+-- users first
+
+INSERT INTO users (id, email, username, password)
+VALUES
+    ('9dc86cat-37bb-4c02-aab9-108ed9b2a261', 'cat@catmail.com', 'SuperCat', 'cat.123'),
+    ('9dc86dog-37bb-4c02-aab9-108ed9b2a262', 'dog@dogmail.com', 'LoyalDog', 'dog.456'),
+    ('9dc86rab-37bb-4c02-aab9-108ed9b2a263', 'rabbit@rabmail.com', 'BBunny', 'looney.123');
+
+INSERT INTO posts (content, likes, user_id)
+VALUES
+    ('Post of a cat', 64, '9dc86cat-37bb-4c02-aab9-108ed9b2a261'),
+    ('Post of a dog', 16, '9dc86dog-37bb-4c02-aab9-108ed9b2a262'),
+    ('Another post of a dog', 134, '9dc86dog-37bb-4c02-aab9-108ed9b2a262'),
+    ('A rabbit post', 92, '9dc86rab-37bb-4c02-aab9-108ed9b2a263');
+
+INSERT INTO comments (content, likes, post_id)
+VALUES
+    ('Comment to a cat post', 14, 1),
+    ('One more comment to the cat post', 54, 1);
+

api/src/auth/token.go

@@ -17,17 +17,25 @@ type AuthToken struct {
 func GenerateToken(userID string) (string, error) {
 	secret := os.Getenv("JWT_SECRET")
 	now := time.Now()
+	/*
+	 * Creates a token variable that creates a new webtoken, signs it, and maps its three values with a userID,
+	 * a time and date which will be now, and an expiration time with now plus 10 minutes
+	 */
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
 		"sub": userID,
 		"iat": jwt.NewNumericDate(now),
-		"exp": jwt.NewNumericDate(now.Add(time.Minute * 10)),
+		"exp": jwt.NewNumericDate(now.Add(time.Minute * 100)),
 	})
+	// This is then returned and signed into a string of bytes, and into our secret environment variable
 	return token.SignedString([]byte(secret))
 }
 
 func DecodeToken(tokenString string) (AuthToken, error) {
 	secret := os.Getenv("JWT_SECRET")
-
+	/*
+	 * First two lines take the code and parse it using the jwt package. Within it,
+	 * there is a pointer to the jwt.Token, presumably to pull this function and apply it to the tokenString.
+	 */
 	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
 		return []byte(secret), nil
 	})
@@ -46,10 +54,17 @@ func DecodeToken(tokenString string) (AuthToken, error) {
 
 func (authToken AuthToken) IsValid() bool {
 	now := time.Now()
+	// Basically checks if the AuthToken is valid by verifying the time it was
+	// created is within the parameters set earlier,
+	// that the time it was issued is not after now, and before the expiry time
 	return now.After(authToken.IssuedAt) && now.Before(authToken.ExpiresAt)
 }
 
 func createAuthTokenFromClaims(claims jwt.MapClaims) (AuthToken, error) {
+	/*
+	 * From the previously issued AuthToken from claims in the decode function,
+	 * this function is what powers the ending of the Decode Token and so is only callable from within this package
+	 */
 	expiresAt, err := claims.GetExpirationTime()
 	if err != nil {
 		return AuthToken{}, err
@@ -65,6 +80,10 @@ func createAuthTokenFromClaims(claims jwt.MapClaims) (AuthToken, error) {
 		return AuthToken{}, err
 	}
 
+	// Function checks the expiration time, when it was issued, the user id,
+	// using jwt.MapClaims to do so, and returning errors if there are any.
+	// If there are no errors, it will return the AuthToken in the format of the
+	// AuthToken struct
 	return AuthToken{
 		ExpiresAt: expiresAt.Time,
 		IssuedAt:  issuedAt.Time,

api/src/controllers/comments.go

@@ -0,0 +1,238 @@
+package controllers
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/makersacademy/go-react-acebook-template/api/src/auth"
+	"github.com/makersacademy/go-react-acebook-template/api/src/models"
+)
+
+type JSONComment struct {
+	ID      uint   `json:"_id"`
+	Message string `json:"message"`
+	Likes   int    `json:"likes"`
+	PostId  int    `json:"post_id"`
+	// UserID  string `json:"user_id"`
+	// Username string `json:"username"`
+	User JSONUser
+}
+
+type createCommentRequestBody struct {
+	Message string
+}
+
+func CreateComment(ctx *gin.Context) {
+	var requestBody createCommentRequestBody
+	err := ctx.BindJSON(&requestBody)
+
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	if len(requestBody.Message) == 0 {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": "Post message empty"})
+		return
+	}
+
+	postID := ctx.Param("id")
+	postIdInt, err := strconv.Atoi(postID)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	CommentTime := time.Now()
+
+	userIDToken, exists := ctx.Get("userID")
+	if !exists {
+		ctx.JSON(http.StatusUnauthorized, gin.H{"ERROR": "USER ID NOT FOUND IN CONTEXT"})
+		return
+	}
+
+	userIDString := userIDToken.(string)
+
+	newComment := models.Comment{
+		UserID:    strconv.Itoa(int([]byte(userIDString)[0])),
+		Message:   requestBody.Message,
+		CreatedAt: CommentTime,
+		Likes:     0,
+		PostId:    postIdInt,
+	}
+
+	_, err = newComment.Save()
+	if err != nil {
+		SendInternalError(ctx, err)
+		return
+	}
+
+	comments, err := models.FetchAllCommentsByPostId(postIdInt)
+
+	if err != nil {
+		SendInternalError(ctx, err)
+		return
+	}
+
+	val, _ := ctx.Get("userID")
+	userID := val.(string)
+	token, _ := auth.GenerateToken(userID)
+
+	// Convert comments to JSON Structs
+	jsonComments := make([]JSONComment, 0)
+	for _, comment := range *comments {
+		user, err := models.FindUser(comment.UserID)
+		if err != nil {
+			fmt.Println("FindUser error in CreateComment: ", err)
+			user.ID = 0
+			user.Username = ""
+		}
+		jsonComments = append(jsonComments, JSONComment{
+			Message: comment.Message,
+			ID:      comment.ID,
+			Likes:   comment.Likes,
+			PostId:  comment.PostId,
+			User: JSONUser{
+				UserID:   user.ID,
+				Username: user.Username,
+				// Image: user.FileData,
+			},
+		})
+	}
+
+	ctx.JSON(http.StatusCreated, gin.H{"message": "Comment created", "comments": jsonComments, "token": token})
+}
+
+func GetAllCommentsByPostId(ctx *gin.Context) {
+	// retrieving a parameter from the request URL here below
+	// needing route to be structured like this: /posts/:post_id
+	postID := ctx.Param("id")
+
+	postIdInt, err := strconv.Atoi(postID)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	comments, err := models.FetchAllCommentsByPostId(postIdInt)
+
+	if err != nil {
+		SendInternalError(ctx, err)
+		return
+	}
+
+	val, _ := ctx.Get("userID")
+	userID := val.(string)
+	token, _ := auth.GenerateToken(userID)
+
+	// Convert comments to JSON Structs
+	jsonComments := make([]JSONComment, 0)
+	for _, comment := range *comments {
+		user, err := models.FindUser(comment.UserID)
+		if err != nil {
+			fmt.Println("FindUser error in CreateComment: ", err)
+			user.ID = 0
+			user.Username = ""
+		}
+		jsonComments = append(jsonComments, JSONComment{
+			Message: comment.Message,
+			ID:      comment.ID,
+			Likes:   comment.Likes,
+			PostId:  comment.PostId,
+			User: JSONUser{
+				UserID:   user.ID,
+				Username: user.Username,
+				// Image: user.FileData,
+			},
+		})
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"comments": jsonComments, "token": token})
+}
+
+func GetSpecificComment(ctx *gin.Context) {
+	postID := ctx.Param("id")
+
+	postIdInt, err := strconv.Atoi(postID)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	commentID := ctx.Param("comment_id")
+
+	commentIdInt, err := strconv.Atoi(commentID)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	comment, err := models.FetchSpecificComment(postIdInt, commentIdInt)
+	if err != nil {
+		SendInternalError(ctx, err)
+		return
+	}
+
+	user, err := models.FindUser(comment.UserID)
+	if err != nil {
+		fmt.Println("FindUser error in CreateComment: ", err)
+		user.ID = 0
+		user.Username = ""
+	}
+
+	jsonComment := JSONComment{
+		Message: comment.Message,
+		ID:      comment.ID,
+		Likes:   comment.Likes,
+		PostId:  comment.PostId,
+		User: JSONUser{
+			UserID:   user.ID,
+			Username: user.Username,
+			// Image: user.FileData,
+		},
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"comment": jsonComment})
+}
+
+func DeleteComment(ctx *gin.Context) {
+	postID := ctx.Param("id")
+
+	postIdInt, err := strconv.Atoi(postID)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	commentID := ctx.Param("comment_id")
+
+	commentIdInt, err := strconv.Atoi(commentID)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"message": err})
+		return
+	}
+
+	comment, err := models.FetchSpecificComment(postIdInt, commentIdInt)
+	if err != nil {
+		SendInternalError(ctx, err)
+		return
+	}
+
+	// Check if the comment is nil
+	if comment == nil {
+		ctx.JSON(http.StatusNotFound, gin.H{"error": "Comment not found"})
+		return
+	}
+
+	// Delete post from database
+	DeletedComment, err := comment.Delete()
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete comment"})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"success": true, "message": "Comment deleted successfully", "deleted comment": DeletedComment})
+}