otter-space-sdk/internal/postgres/post.go

package postgres

import (
	"context"
	"errors"
	"fmt"
	"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
	"git.dragse.it/anthrove/otter-space-sdk/pkg/models/graphModels"
	log "github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

func CreateAnthrovePostNode(ctx context.Context, db *gorm.DB, anthrovePostID models.AnthrovePostID, anthroveRating models.Rating) error {
	post := models.Post{
		BaseModel: models.BaseModel{
			ID: string(anthrovePostID),
		},
		Rating: anthroveRating,
	}

	err := db.WithContext(ctx).Create(&post).Error
	if err != nil {
		return err
	}

	log.WithFields(log.Fields{
		"anthrove_post_id":     anthrovePostID,
		"anthrove_post_rating": anthroveRating,
	}).Trace("database: created anthrove post")

	return nil
}

func CheckIfAnthrovePostNodeExistsByAnthroveID(ctx context.Context, db *gorm.DB, anthrovePostID models.AnthrovePostID) (bool, error) {
	if anthrovePostID == "" {
		return false, fmt.Errorf("anthrovePostID is required")
	}

	return executeCheckQuery(ctx, db, "id = ?", string(anthrovePostID))
}

func CheckIfAnthrovePostNodeExistsBySourceURL(ctx context.Context, db *gorm.DB, sourceURL string) (*graphModels.AnthrovePost, bool, error) {
	postRef := models.PostReference{}
	err := db.WithContext(ctx).Model(&models.PostReference{}).Where("url = ?", sourceURL).First(&postRef).Error

	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, false, nil
		}
		return nil, false, err
	}

	var post models.Post
	err = db.WithContext(ctx).First(&post, "id = ?", postRef.PostID).Error

	if err != nil {
		return nil, false, err
	}

	pgPost := graphModels.AnthrovePost{
		PostID: models.AnthrovePostID(post.ID),
		Rating: post.Rating,
	}

	//TODO Now test it! :D
	// Naaa
	// D:
	return &pgPost, true, nil
}

func CheckIfAnthrovePostNodeExistsBySourceID(ctx context.Context, db *gorm.DB, sourceID string) (bool, error) {
	return executeCheckQuery(ctx, db, "source_id = ?", sourceID)
}

func executeCheckQuery(ctx context.Context, db *gorm.DB, query string, args ...interface{}) (bool, error) {
	var count int64

	err := db.WithContext(ctx).Model(&models.Post{}).Where(query, args...).Count(&count).Error
	if err != nil {
		return false, err
	}

	exists := count > 0

	log.WithFields(log.Fields{
		"query":  query,
		"args":   args,
		"exists": exists,
	}).Trace("database: executed check query")

	return exists, nil
}