Haystack/backend/models/image.go

package models

import (
	"errors"
	"fmt"
	"screenmark/screenmark/.gen/haystack/haystack/model"
	. "screenmark/screenmark/.gen/haystack/haystack/table"

	. "github.com/go-jet/jet/v2/postgres"

	"github.com/google/uuid"
)

func SaveImageToProcess(userId string, imageName string, imageData []byte) (model.UserImagesToProcess, error) {
	insertImageStmt := Image.INSERT(Image.ImageName, Image.Image).VALUES(imageName, imageData).RETURNING(Image.ID)

	// TODO: should be a transaction

	image := model.Image{}
	err := insertImageStmt.Query(db, &image)
	if err != nil {
		return model.UserImagesToProcess{}, err
	}

	stmt := UserImagesToProcess.INSERT(UserImagesToProcess.UserID, UserImagesToProcess.ImageID).VALUES(userId, image.ID).RETURNING(UserImagesToProcess.AllColumns)

	userImage := model.UserImagesToProcess{}
	err = stmt.Query(db, &userImage)

	return userImage, err
}

func removeImageToProcess(imageId string) error {
	id := uuid.MustParse(imageId)

	stmt := UserImagesToProcess.DELETE().WHERE(UserImagesToProcess.ID.EQ(UUID(id)))

	fmt.Println(stmt.DebugSql())

	_, err := stmt.Exec(db)

	return err
}

func SaveImage(imageId uuid.UUID) (model.UserImages, error) {
	imageToProcess, err := GetImageToProcess(imageId.String())
	if err != nil {
		return model.UserImages{}, err
	}

	stmt := UserImages.INSERT(UserImages.UserID, UserImages.ImageID).VALUES(imageToProcess.UserID, imageToProcess.ImageID).RETURNING(UserImages.ID, UserImages.UserID, UserImages.ImageID)

	userImage := model.UserImages{}
	err = stmt.Query(db, &userImage)
	if err != nil {
		return model.UserImages{}, err
	}

	err = removeImageToProcess(imageId.String())
	if err != nil {
		return model.UserImages{}, err
	}

	return userImage, err
}

type ImageData struct {
	model.UserImages

	Image model.Image
}

func GetImage(imageId string) (ImageData, error) {
	id := uuid.MustParse(imageId)
	stmt := SELECT(UserImages.AllColumns, Image.AllColumns).FROM(UserImages.INNER_JOIN(Image, Image.ID.EQ(UserImages.ImageID))).WHERE(UserImages.ID.EQ(UUID(id)))

	images := []ImageData{}
	err := stmt.Query(db, &images)

	if len(images) != 1 {
		return ImageData{}, errors.New(fmt.Sprintf("Expected 1, got %d\n", len(images)))
	}

	return images[0], err
}

type ImageToProcessData struct {
	model.UserImagesToProcess

	Image model.Image
}

func GetImageToProcessWithData(imageId string) (ImageToProcessData, error) {
	id := uuid.MustParse(imageId)
	// stmt := UserImagesToProcess.SELECT(UserImages.AllColumns).WHERE(UserImages.ID.EQ(UUID(id)))

	// TODO: Image should be `Images`
	stmt := SELECT(UserImagesToProcess.AllColumns, Image.AllColumns).FROM(UserImagesToProcess.INNER_JOIN(Image, Image.ID.EQ(UserImagesToProcess.ImageID))).WHERE(UserImagesToProcess.ID.EQ(UUID(id)))

	images := []ImageToProcessData{}
	err := stmt.Query(db, &images)

	if len(images) != 1 {
		return ImageToProcessData{}, errors.New(fmt.Sprintf("Expected 1, got %d\n", len(images)))
	}

	return images[0], err
}

func GetImageToProcess(imageId string) (model.UserImagesToProcess, error) {
	id := uuid.MustParse(imageId)
	stmt := UserImagesToProcess.SELECT(UserImagesToProcess.AllColumns).WHERE(UserImagesToProcess.ID.EQ(UUID(id)))

	fmt.Println(stmt.DebugSql())

	images := []model.UserImagesToProcess{}
	err := stmt.Query(db, &images)

	if len(images) != 1 {
		return model.UserImagesToProcess{}, errors.New(fmt.Sprintf("Expected 1, got %d\n", len(images)))
	}

	return images[0], err
}

type UserImagesWithInfo struct {
	model.UserImages

	// TODO: this shit
	Image model.Image

	Tags  []model.ImageTags
	Links []model.ImageLinks
	Text  []model.ImageText
}

func GetUserImages(userId string) ([]UserImagesWithInfo, error) {
	id := uuid.MustParse(userId)
	stmt := SELECT(UserImages.AllColumns, ImageTags.AllColumns, ImageText.AllColumns, ImageLinks.AllColumns).FROM(UserImages.LEFT_JOIN(ImageTags, ImageTags.ImageID.EQ(UserImages.ID)).LEFT_JOIN(ImageText, ImageText.ImageID.EQ(UserImages.ID)).LEFT_JOIN(ImageLinks, ImageLinks.ImageID.EQ(UserImages.ID))).WHERE(UserImages.UserID.EQ(UUID(id)))

	images := []UserImagesWithInfo{}
	err := stmt.Query(db, &images)

	return images, err
}

func SaveImageTags(imageId string, tags []string) ([]model.ImageTags, error) {
	id := uuid.MustParse(imageId)

	stmt := ImageTags.INSERT(ImageTags.ImageID, ImageTags.Tag)

	for _, t := range tags {
		stmt = stmt.VALUES(id, t)
	}

	stmt.RETURNING(ImageTags.AllColumns)

	fmt.Println(stmt.DebugSql())

	imageTags := []model.ImageTags{}
	err := stmt.Query(db, &imageTags)

	return imageTags, err
}

func SaveImageLinks(imageId string, links []string) ([]model.ImageLinks, error) {
	id := uuid.MustParse(imageId)

	stmt := ImageTags.INSERT(ImageLinks.ImageID, ImageLinks.Link)

	for _, t := range links {
		stmt = stmt.VALUES(id, t)
	}

	stmt.RETURNING(ImageLinks.AllColumns)

	imageLinks := []model.ImageLinks{}
	err := stmt.Query(db, &imageLinks)

	return imageLinks, err
}

func SaveImageTexts(imageId string, texts []string) ([]model.ImageText, error) {
	id := uuid.MustParse(imageId)

	stmt := ImageText.INSERT(ImageText.ImageID, ImageText.ImageText)

	for _, t := range texts {
		stmt = stmt.VALUES(id, t)
	}

	stmt.RETURNING(ImageText.AllColumns)

	imageTags := []model.ImageText{}
	err := stmt.Query(db, &imageTags)

	return imageTags, err
}