feat(tags): correctly inserting new tags and adding them to images

backend/main.go

@@ -107,9 +107,23 @@ func main() {
 					log.Println("Finished processing image " + imageId)
 					log.Printf("Image attributes: %+v\n", imageInfo)
 
-					models.SaveImageTags(savedImage.ID.String(), imageInfo.Tags)
+					_, err = models.SaveImageTags(savedImage.ID.String(), imageInfo.Tags)
-					models.SaveImageLinks(savedImage.ID.String(), imageInfo.Links)
+					if err != nil {
-					models.SaveImageTexts(savedImage.ID.String(), imageInfo.Text)
+						log.Println("1")
+						log.Println(err)
+					}
+
+					_, err = models.SaveImageLinks(savedImage.ID.String(), imageInfo.Links)
+					if err != nil {
+						log.Println("2")
+						log.Println(err)
+					}
+
+					_, err = models.SaveImageTexts(savedImage.ID.String(), imageInfo.Text)
+					if err != nil {
+						log.Println("3")
+						log.Println(err)
+					}
 				}()
 			}
 		}

backend/models/image.go

@@ -42,6 +42,25 @@ func removeImageToProcess(imageId string) error {
 	return err
 }
 
+func getUserId(imageId uuid.UUID) (uuid.UUID, error) {
+	stmt := UserImages.SELECT(UserImages.UserID).WHERE(UserImages.ID.EQ(UUID(imageId)))
+
+	fmt.Println(stmt.DebugSql())
+
+	userIds := make([]string, 0)
+
+	err := stmt.Query(db, &userIds)
+	if err != nil {
+		return uuid.Nil, err
+	}
+
+	if len(userIds) != 1 {
+		return uuid.Nil, errors.New("expect only one user id per image id")
+	}
+
+	return uuid.Parse(userIds[0])
+}
+
 func SaveImage(imageId uuid.UUID) (model.UserImages, error) {
 	imageToProcess, err := GetImageToProcess(imageId.String())
 	if err != nil {
@@ -145,16 +164,39 @@ func GetUserImages(userId string) ([]UserImagesWithInfo, error) {
 func SaveImageTags(imageId string, tags []string) ([]model.ImageTags, error) {
 	id := uuid.MustParse(imageId)
 
-	stmt := ImageTags.INSERT(ImageTags.ImageID, ImageTags.Tag)
+	userId, err := getUserId(id)
+	if err != nil {
+		return []model.ImageTags{}, err
+	}
 
-	for _, t := range tags {
+	err = CreateTags(userId, tags)
-		stmt = stmt.VALUES(id, t)
+	if err != nil {
+		return []model.ImageTags{}, err
+	}
+
+	userTagsExpression := make([]Expression, 0)
+	for _, tag := range tags {
+		userTagsExpression = append(userTagsExpression, String(tag))
+	}
+
+	userTags := make([]model.UserTags, 0)
+
+	getTagsStmt := UserTags.SELECT(UserTags.ID, UserTags.Tag).WHERE(UserTags.Tag.IN(userTagsExpression...))
+	err = getTagsStmt.Query(db, &userTags)
+	if err != nil {
+		return []model.ImageTags{}, err
+	}
+
+	stmt := ImageTags.INSERT(ImageTags.ImageID, ImageTags.TagID)
+
+	for _, t := range userTags {
+		stmt = stmt.VALUES(id, t.ID)
 	}
 
 	stmt.RETURNING(ImageTags.AllColumns)
 
-	imageTags := []model.ImageTags{}
+	imageTags := make([]model.ImageTags, 0)
-	err := stmt.Query(db, &imageTags)
+	err = stmt.Query(db, &imageTags)
 
 	return imageTags, err
 }
@@ -162,7 +204,7 @@ func SaveImageTags(imageId string, tags []string) ([]model.ImageTags, error) {
 func SaveImageLinks(imageId string, links []string) ([]model.ImageLinks, error) {
 	id := uuid.MustParse(imageId)
 
-	stmt := ImageTags.INSERT(ImageLinks.ImageID, ImageLinks.Link)
+	stmt := ImageLinks.INSERT(ImageLinks.ImageID, ImageLinks.Link)
 
 	for _, t := range links {
 		stmt = stmt.VALUES(id, t)

backend/models/tags.go

@@ -1,6 +1,7 @@
 package models
 
 import (
+	"fmt"
 	"screenmark/screenmark/.gen/haystack/haystack/model"
 	. "screenmark/screenmark/.gen/haystack/haystack/table"
 
@@ -20,20 +21,53 @@ import (
 // |           --         --
 // |       ----      IQ     ----
 func getNonExistantTags(userId uuid.UUID, tags []string) ([]string, error) {
-	stmt, err := db.Prepare(`WITH given_tags 
+	values := ""
-        AS (SELECT given_tags.tag FROM (VALUES ('a'), ('b'), ('c')) AS given_tags (tag))
+	counter := 1
+	// big big SQL injection problem here?
+	for counter = 1; counter <= len(tags); counter++ {
+		values += fmt.Sprintf("($%d),", counter)
+	}
+	values = values[0 : len(values)-1]
+
+	/*
+		WITH given_tags
+		        AS (SELECT given_tags.tag FROM (VALUES ('c')) AS given_tags (tag)),
+		this_user_tags as (
+			SELECT id, tag
+		                FROM haystack.user_tags
+		                where user_tags.user_id = 'fcc22dbb-7792-4595-be8e-d0439e13990a'
+		)
+		select given_tags.tag from given_tags
+		                LEFT OUTER JOIN this_user_tags ON this_user_tags.tag = given_tags.tag
+		                where this_user_tags.tag is null;
+	*/
+
+	withStuff := fmt.Sprintf(`WITH given_tags 
+        AS (SELECT given_tags.tag FROM (VALUES `+values+`) AS given_tags (tag)),
+        this_user_tags AS 
+        (SELECT id, tag FROM haystack.user_tags WHERE user_tags.user_id = $%d)
 		SELECT given_tags.tag
 		FROM given_tags
-		LEFT OUTER JOIN haystack.user_tags ON haystack.user_tags.tag = a.tag
+		LEFT OUTER JOIN haystack.user_tags ON haystack.user_tags.tag = given_tags.tag
-		where user_tags.tag is null;`)
+		where user_tags.tag is null`, counter)
+
+	stmt, err := db.Prepare(withStuff)
+	fmt.Println(withStuff)
 
 	if err != nil {
+		fmt.Println("failing to prepare stmt")
 		return []string{}, err
 	}
 
 	defer stmt.Close()
 
-	rows, err := stmt.Query()
+	args := make([]any, counter)
+	for i, v := range tags {
+		args[i] = v
+	}
+	args[counter-1] = userId.String()
+
+	rows, err := stmt.Query(args...)
 	if err != nil {
 		return []string{}, err
 	}
@@ -56,6 +90,10 @@ func CreateTags(userId uuid.UUID, tags []string) error {
 		return err
 	}
 
+	if len(tagsToInsert) == 0 {
+		return nil
+	}
+
 	stmt := UserTags.INSERT(UserTags.UserID, UserTags.Tag)
 
 	for _, tag := range tagsToInsert {