anthrove/otter-space-sdk
Archived
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 10 Wiki Activity

Compare commits

base: anthrove:f66fc6b6d7a19cd0fd152734d85093b25288d211
Branches Tags
anthrove:main
anthrove:develop/master
anthrove:v2.2.0
anthrove:v2.1.0
anthrove:v2.0.0
anthrove:v1.5.0
anthrove:v1.4.0
anthrove:v1.3.1
anthrove:v1.3.0
anthrove:v1.2.0
anthrove:v1.1.0
anthrove:v1.0.0
..
compare: anthrove:63e74219ed245b6eabe1c5d8baec540d8aba31da
Branches Tags
anthrove:main
anthrove:develop/master
anthrove:v2.2.0
anthrove:v2.1.0
anthrove:v2.0.0
anthrove:v1.5.0
anthrove:v1.4.0
anthrove:v1.3.1
anthrove:v1.3.0
anthrove:v1.2.0
anthrove:v1.1.0
anthrove:v1.0.0

No commits in common. "f66fc6b6d7a19cd0fd152734d85093b25288d211" and "63e74219ed245b6eabe1c5d8baec540d8aba31da" have entirely different histories.
f66fc6b6d7 ... 63e74219ed

12 changed files with 183 additions and 393 deletions
Show Stats Expand all files Collapse all files

16
pkg/errors/database.go → error/database.go
View File

@ -1,25 +1,19 @@
package errors
package error
type EntityAlreadyExists struct{}
type NoDataWritten struct{}
type NoDataFound struct{}
func (e *EntityAlreadyExists) Error() string {
return "EntityAlreadyExists error"
}
type NoDataWritten struct{}
func (e *NoDataWritten) Error() string {
return "NoDataWritten error"
}
type NoDataFound struct{}
func (e *NoDataFound) Error() string {
return "NoDataFound error"
}
type NoRelationCreated struct{}
func (e *NoRelationCreated) Error() string {
return "relationship creation error"
}

7
error/validation.go Normal file
View File

@ -0,0 +1,7 @@
package error
type MissingAnthrovePostIDError struct{}
func (e *MissingAnthrovePostIDError) Error() string {
return "AnthrovePostID is empty"
}

59
internal/postgres/post.go
View File

@ -3,29 +3,24 @@ package postgres
import (
"context"
"errors"
errors2 "git.dragse.it/anthrove/otter-space-sdk/pkg/errors"
error2 "git.dragse.it/anthrove/otter-space-sdk/error"
"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
log "github.com/sirupsen/logrus"
"gorm.io/gorm"
)
func CreatePost(ctx context.Context, db *gorm.DB, anthrovePost *models.Post) error {
if anthrovePost == nil {
return &errors2.EntityValidationFailed{Reason: "anthrovePost is nil"}
}
result := db.WithContext(ctx).Create(&anthrovePost)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &errors2.EntityAlreadyExists{}
}
return result.Error
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
return &error2.NoDataWritten{}
}
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &error2.EntityAlreadyExists{}
}
}
log.WithFields(log.Fields{
@ -37,58 +32,44 @@ func CreatePost(ctx context.Context, db *gorm.DB, anthrovePost *models.Post) err
}
func GetPostByAnthroveID(ctx context.Context, db *gorm.DB, anthrovePostID models.AnthrovePostID) (*models.Post, error) {
if anthrovePostID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "anthrovePostID is not set"}
return nil, &error2.MissingAnthrovePostIDError{}
}
//TODO maybe check ofor id length too...?
var post models.Post
result := db.WithContext(ctx).First(&post, "id = ?", anthrovePostID)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
return nil, &error2.NoDataFound{}
}
return nil, result.Error
}
return &post, nil
}
func GetPostByURL(ctx context.Context, db *gorm.DB, sourceURL string) (*models.Post, error) {
if sourceURL == "" {
return nil, &errors2.EntityValidationFailed{Reason: "sourceURL is not set"}
}
var post models.Post
result := db.WithContext(ctx).Raw(`SELECT p.id AS id, p.rating as rating FROM "Post" AS p INNER JOIN "PostReference" AS pr ON p.id = pr.post_id AND pr.url = $1 LIMIT 1`, sourceURL).First(&post)
err := db.WithContext(ctx).Raw(`SELECT p.id AS id, p.rating as rating FROM "Post" AS p INNER JOIN "PostReference" AS pr ON p.id = pr.post_id AND pr.url = $1 LIMIT 1`, sourceURL).First(&post).Error
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
return nil, result.Error
return nil, err
}
return &post, nil
}
func GetPostBySourceID(ctx context.Context, db *gorm.DB, sourceID models.AnthroveSourceID) (*models.Post, error) {
if sourceID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "sourceID is not set"}
}
var post models.Post
result := db.WithContext(ctx).Raw(`SELECT p.id AS id, p.rating as rating FROM "Post" AS p INNER JOIN "PostReference" AS pr ON p.id = pr.post_id AND pr.source_id = $1 LIMIT 1`, sourceID).First(&post)
err := db.WithContext(ctx).Raw(`SELECT p.id AS id, p.rating as rating FROM "Post" AS p INNER JOIN "PostReference" AS pr ON p.id = pr.post_id AND pr.source_id = $1 LIMIT 1`, sourceID).First(&post).Error
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
return nil, result.Error
return nil, err
}
return &post, nil

8
internal/postgres/post_test.go
View File

@ -223,7 +223,7 @@ func TestGetPostBySourceURL(t *testing.T) {
sourceURL: "1234",
},
want: nil,
wantErr: true,
wantErr: false,
},
{
name: "Test 3: No sourceURL",
@ -233,7 +233,7 @@ func TestGetPostBySourceURL(t *testing.T) {
sourceURL: "",
},
want: nil,
wantErr: true,
wantErr: false,
},
}
for _, tt := range tests {
@ -323,7 +323,7 @@ func TestGetPostBySourceID(t *testing.T) {
sourceID: "1234",
},
want: nil,
wantErr: true,
wantErr: false,
},
{
name: "Test 3: No sourceID",
@ -333,7 +333,7 @@ func TestGetPostBySourceID(t *testing.T) {
sourceID: "",
},
want: nil,
wantErr: true,
wantErr: false,
},
}
for _, tt := range tests {

91
internal/postgres/relationships.go
View File

@ -2,8 +2,6 @@ package postgres
import (
"context"
"errors"
errors2 "git.dragse.it/anthrove/otter-space-sdk/pkg/errors"
"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
log "github.com/sirupsen/logrus"
"gorm.io/gorm"
@ -11,44 +9,23 @@ import (
func CreateReferenceBetweenPostAndSource(ctx context.Context, db *gorm.DB, anthrovePostID models.AnthrovePostID, sourceDomain models.AnthroveSourceDomain) error {
var source models.Source
if anthrovePostID == "" {
return &errors2.EntityValidationFailed{Reason: "anthrovePostID cannot be empty"}
}
if len(anthrovePostID) != 25 {
return &errors2.EntityValidationFailed{Reason: "anthrovePostID needs to be 25 characters long"}
}
if sourceDomain == "" {
return &errors2.EntityValidationFailed{Reason: "sourceDomain cannot be empty"}
}
var err error
// Find the source
result := db.WithContext(ctx).Where("domain = ?", sourceDomain).First(&source)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return &errors2.NoDataFound{}
}
return result.Error
err = db.WithContext(ctx).Where("domain = ?", sourceDomain).First(&source).Error
if err != nil {
return err
}
// Establish the relationship
result = db.WithContext(ctx).Create(models.PostReference{
err = db.WithContext(ctx).Create(models.PostReference{
PostID: string(anthrovePostID),
SourceID: string(source.ID),
URL: string(sourceDomain),
})
}).Error
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &errors2.EntityAlreadyExists{}
}
return result.Error
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
if err != nil {
return err
}
log.WithFields(log.Fields{
@ -60,34 +37,14 @@ func CreateReferenceBetweenPostAndSource(ctx context.Context, db *gorm.DB, anthr
}
func CreateReferenceBetweenUserAndPost(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, anthrovePostID models.AnthrovePostID) error {
if anthrovePostID == "" {
return &errors2.EntityValidationFailed{Reason: "anthrovePostID cannot be empty"}
}
if len(anthrovePostID) != 25 {
return &errors2.EntityValidationFailed{Reason: "anthrovePostID needs to be 25 characters long"}
}
if anthroveUserID == "" {
return &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
userFavorite := models.UserFavorites{
UserID: string(anthroveUserID),
PostID: string(anthrovePostID),
}
result := db.WithContext(ctx).Create(&userFavorite)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &errors2.EntityAlreadyExists{}
}
return result.Error
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
err := db.WithContext(ctx).Create(&userFavorite).Error
if err != nil {
return err
}
log.WithFields(log.Fields{
@ -100,29 +57,9 @@ func CreateReferenceBetweenUserAndPost(ctx context.Context, db *gorm.DB, anthrov
func CheckReferenceBetweenUserAndPost(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, anthrovePostID models.AnthrovePostID) (bool, error) {
var count int64
if anthrovePostID == "" {
return false, &errors2.EntityValidationFailed{Reason: "anthrovePostID cannot be empty"}
}
if len(anthrovePostID) != 25 {
return false, &errors2.EntityValidationFailed{Reason: "anthrovePostID needs to be 25 characters long"}
}
if anthroveUserID == "" {
return false, &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return false, &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
}
result := db.WithContext(ctx).Model(&models.UserFavorites{}).Where("user_id = ? AND post_id = ?", string(anthroveUserID), string(anthrovePostID)).Count(&count)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return false, &errors2.NoDataFound{}
}
return false, result.Error
err := db.WithContext(ctx).Model(&models.UserFavorites{}).Where("user_id = ? AND post_id = ?", string(anthroveUserID), string(anthrovePostID)).Count(&count).Error
if err != nil {
return false, err
}
exists := count > 0

48
internal/postgres/relationships_test.go
View File

@ -20,20 +20,14 @@ func TestCheckUserToPostLink(t *testing.T) {
defer container.Terminate(ctx)
// Setup Test
validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
invalidUserID := models.AnthroveUserID("XXX")
validPostID := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1"))
err = CreateUser(ctx, gormDB, validUserID)
err = CreateUser(ctx, gormDB, "1")
if err != nil {
t.Fatal(err)
}
post := &models.Post{
BaseModel: models.BaseModel[models.AnthrovePostID]{
ID: validPostID,
ID: models.AnthrovePostID(fmt.Sprintf("%025s", "1")),
},
Rating: "safe",
}
@ -43,7 +37,7 @@ func TestCheckUserToPostLink(t *testing.T) {
t.Fatal(err)
}
err = CreateReferenceBetweenUserAndPost(ctx, gormDB, validUserID, post.ID)
err = CreateReferenceBetweenUserAndPost(ctx, gormDB, "1", models.AnthrovePostID(post.ID))
if err != nil {
t.Fatal(err)
}
@ -66,7 +60,7 @@ func TestCheckUserToPostLink(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
anthrovePostID: post.ID,
},
want: true,
@ -77,33 +71,33 @@ func TestCheckUserToPostLink(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
anthrovePostID: "qadw",
},
want: false,
wantErr: true,
wantErr: false,
},
{
name: "Test 3: Valid AnthrovePostID and invalid AnthroveUserID",
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthroveUserID: "123",
anthrovePostID: post.ID,
},
want: false,
wantErr: true,
wantErr: false,
},
{
name: "Test 4: Invalid AnthrovePostID and invalid AnthroveUserID",
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthroveUserID: "123",
anthrovePostID: "123456",
},
want: false,
wantErr: true,
wantErr: false,
},
}
for _, tt := range tests {
@ -225,20 +219,14 @@ func TestEstablishUserToPostLink(t *testing.T) {
defer container.Terminate(ctx)
// Setup Test
validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
invalidUserID := models.AnthroveUserID("XXX")
validPostID := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1"))
err = CreateUser(ctx, gormDB, validUserID)
err = CreateUser(ctx, gormDB, "1")
if err != nil {
t.Fatal(err)
}
post := &models.Post{
BaseModel: models.BaseModel[models.AnthrovePostID]{
ID: validPostID,
ID: models.AnthrovePostID(fmt.Sprintf("%025s", "1")),
},
Rating: "safe",
}
@ -265,7 +253,7 @@ func TestEstablishUserToPostLink(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
anthrovePostID: post.ID,
},
wantErr: false,
@ -275,18 +263,18 @@ func TestEstablishUserToPostLink(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
anthrovePostID: "123456",
},
wantErr: true,
},
{
name: "Test 3: invalid AnthroveUserID and valid AnthrovePostID",
name: "Test 3: Valid AnthrovePostID and invalid AnthroveUserID",
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthrovePostID: post.ID,
anthroveUserID: "123",
anthrovePostID: "1234",
},
wantErr: true,
},
@ -295,7 +283,7 @@ func TestEstablishUserToPostLink(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthroveUserID: "123",
anthrovePostID: "123456",
},
wantErr: true,

20
internal/postgres/source.go
View File

@ -2,8 +2,7 @@ package postgres
import (
"context"
"errors"
errors2 "git.dragse.it/anthrove/otter-space-sdk/pkg/errors"
"fmt"
"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
log "github.com/sirupsen/logrus"
@ -14,22 +13,15 @@ import (
func CreateSource(ctx context.Context, db *gorm.DB, anthroveSource *models.Source) error {
if anthroveSource.Domain == "" {
return &errors2.EntityValidationFailed{Reason: "Domain is required"}
return fmt.Errorf("anthroveSource domain is required")
}
result := db.WithContext(ctx).Where(models.Source{Domain: anthroveSource.Domain}).FirstOrCreate(anthroveSource)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &errors2.EntityAlreadyExists{}
}
return result.Error
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
}
log.WithFields(log.Fields{
"node_source_url": anthroveSource.Domain,
"node_source_displayName": anthroveSource.DisplayName,
@ -46,9 +38,6 @@ func GetAllSource(ctx context.Context, db *gorm.DB) ([]models.Source, error) {
result := db.WithContext(ctx).Find(&sources)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
} // TODO really...? i don't think this error handling should be here..? / not possible
return nil, result.Error
}
@ -64,15 +53,12 @@ func GetSourceByDomain(ctx context.Context, db *gorm.DB, sourceDomain models.Ant
var sources models.Source
if sourceDomain == "" {
return nil, &errors2.EntityValidationFailed{Reason: "AnthroveSourceDomain is not set"}
return nil, fmt.Errorf("domain is required")
}
result := db.WithContext(ctx).Where("domain = ?", sourceDomain).First(&sources)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
}

6
internal/postgres/source_test.go
View File

@ -2,7 +2,6 @@ package postgres
import (
"context"
"fmt"
"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
"git.dragse.it/anthrove/otter-space-sdk/test"
"gorm.io/gorm"
@ -20,10 +19,7 @@ func TestCreateSourceNode(t *testing.T) {
// Setup Test
validPostID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Post1"))
validSource := &models.Source{
BaseModel: models.BaseModel[models.AnthroveSourceID]{ID: validPostID},
DisplayName: "e621",
Domain: "e621.net",
Icon: "icon.e621.net",
@ -69,7 +65,7 @@ func TestCreateSourceNode(t *testing.T) {
db: gormDB,
anthroveSource: validSource,
},
wantErr: true,
wantErr: false,
},
}
for _, tt := range tests {

46
internal/postgres/tag.go
View File

@ -2,8 +2,7 @@ package postgres
import (
"context"
"errors"
errors2 "git.dragse.it/anthrove/otter-space-sdk/pkg/errors"
"fmt"
"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
log "github.com/sirupsen/logrus"
"gorm.io/gorm"
@ -11,20 +10,10 @@ import (
func CreateTag(ctx context.Context, db *gorm.DB, tag *models.Tag) error {
if tag == nil {
return &errors2.EntityValidationFailed{Reason: "Tag is nil"}
}
resultTag := db.WithContext(ctx).Where(tag).Create(tag)
result := db.WithContext(ctx).Where(tag).Create(tag)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &errors2.EntityAlreadyExists{}
}
return result.Error
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
if resultTag.Error != nil {
return resultTag.Error
}
log.WithFields(log.Fields{
@ -35,36 +24,30 @@ func CreateTag(ctx context.Context, db *gorm.DB, tag *models.Tag) error {
return nil
}
func CreateTagAndReferenceToPost(ctx context.Context, db *gorm.DB, anthrovePostID models.AnthrovePostID, tag *models.Tag) error {
func CreateTagAndReferenceToPost(ctx context.Context, db *gorm.DB, PostID models.AnthrovePostID, tag *models.Tag) error {
if anthrovePostID == "" {
return &errors2.EntityValidationFailed{Reason: "anthrovePostID cannot be empty"}
}
if len(anthrovePostID) != 25 {
return &errors2.EntityValidationFailed{Reason: "anthrovePostID needs to be 25 characters long"}
if PostID == "" {
return fmt.Errorf("PostID is empty")
}
if tag == nil {
return &errors2.EntityValidationFailed{Reason: "Tag is nil"}
return fmt.Errorf("tag is nill")
}
pgPost := models.Post{
BaseModel: models.BaseModel[models.AnthrovePostID]{
ID: anthrovePostID,
ID: PostID,
},
}
err := db.WithContext(ctx).Model(&pgPost).Association("Tags").Append(tag)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return &errors2.NoDataFound{}
}
return errors.Join(err, &errors2.NoRelationCreated{})
return err
}
log.WithFields(log.Fields{
"anthrove_post_id": anthrovePostID,
"anthrove_post_id": PostID,
"tag_name": tag.Name,
"tag_type": tag.Type,
}).Trace("database: created tag node")
@ -74,13 +57,8 @@ func CreateTagAndReferenceToPost(ctx context.Context, db *gorm.DB, anthrovePostI
func GetTags(ctx context.Context, db *gorm.DB) ([]models.Tag, error) {
var tags []models.Tag
result := db.WithContext(ctx).Find(&tags)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) { // TODO really...? i don't think this error handling should be here..? / not possible
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
}

222
internal/postgres/user.go
View File

@ -2,8 +2,7 @@ package postgres
import (
"context"
"errors"
errors2 "git.dragse.it/anthrove/otter-space-sdk/pkg/errors"
"fmt"
"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
log "github.com/sirupsen/logrus"
"gorm.io/gorm"
@ -12,11 +11,7 @@ import (
func CreateUser(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) error {
if anthroveUserID == "" {
return &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
return fmt.Errorf("anthroveUserID cannot be empty")
}
user := models.User{
@ -25,16 +20,12 @@ func CreateUser(ctx context.Context, db *gorm.DB, anthroveUserID models.Anthrove
},
}
result := db.WithContext(ctx).FirstOrCreate(&user)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &errors2.EntityAlreadyExists{}
}
return result.Error
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
err := db.WithContext(ctx).FirstOrCreate(&user).Error
if err != nil {
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
}).Error("database: failed to create user")
return err
}
return nil
@ -43,19 +34,15 @@ func CreateUser(ctx context.Context, db *gorm.DB, anthroveUserID models.Anthrove
func CreateUserWithRelationToSource(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, sourceID models.AnthroveSourceID, accountId string, accountUsername string) error {
if anthroveUserID == "" {
return &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
return fmt.Errorf("anthroveUserID cannot be empty")
}
if accountId == "" {
return &errors2.EntityValidationFailed{Reason: "accountID cannot be empty"}
return fmt.Errorf("account_id cannot be empty")
}
if accountUsername == "" {
return &errors2.EntityValidationFailed{Reason: "accountUsername cannot be empty"}
return fmt.Errorf("account_username cannot be empty")
}
err := CreateUser(ctx, db, anthroveUserID)
@ -67,12 +54,11 @@ func CreateUserWithRelationToSource(ctx context.Context, db *gorm.DB, anthroveUs
BaseModel: models.BaseModel[models.AnthroveSourceID]{ID: sourceID},
}
result := db.WithContext(ctx).Where(&source).First(&source)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return &errors2.NoDataFound{}
}
return result.Error
if err := db.WithContext(ctx).Where(&source).First(&source).Error; err != nil {
log.WithFields(log.Fields{
"source_id": sourceID,
}).Error("database: failed to find source")
return err
}
userSource := models.UserSource{
@ -83,13 +69,14 @@ func CreateUserWithRelationToSource(ctx context.Context, db *gorm.DB, anthroveUs
UserID: string(anthroveUserID),
}
result = db.WithContext(ctx).FirstOrCreate(&userSource)
if result.Error != nil {
return errors.Join(result.Error, &errors2.NoRelationCreated{})
}
if result.RowsAffected == 0 {
return &errors2.NoDataWritten{}
if err := db.WithContext(ctx).FirstOrCreate(&userSource).Error; err != nil {
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
"source_id": sourceID,
"account_username": accountUsername,
"account_id": accountId,
}).Error("database: failed to create user-source relationship")
return err
}
log.WithFields(log.Fields{
@ -103,22 +90,17 @@ func CreateUserWithRelationToSource(ctx context.Context, db *gorm.DB, anthroveUs
}
func GetUserFavoritesCount(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) (int64, error) {
var count int64
if anthroveUserID == "" {
return 0, &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
return 0, fmt.Errorf("anthroveUserID cannot be empty")
}
if len(anthroveUserID) != 25 {
return 0, &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
}
result := db.WithContext(ctx).Model(&models.UserFavorites{}).Where("user_id = ?", string(anthroveUserID)).Count(&count)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return 0, &errors2.NoDataFound{}
}
return 0, result.Error
var count int64
err := db.WithContext(ctx).Model(&models.UserFavorites{}).Where("user_id = ?", string(anthroveUserID)).Count(&count).Error
if err != nil {
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
}).Error("database: failed to get user favorites count")
return 0, err
}
log.WithFields(log.Fields{
@ -133,30 +115,22 @@ func GetUserSourceLinks(ctx context.Context, db *gorm.DB, anthroveUserID models.
var userSources []models.UserSource
userSourceMap := make(map[string]models.UserSource)
if anthroveUserID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
}
result := db.WithContext(ctx).Model(&models.UserSource{}).Where("user_id = ?", string(anthroveUserID)).Find(&userSources)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err := db.WithContext(ctx).Model(&models.UserSource{}).Where("user_id = ?", string(anthroveUserID)).Find(&userSources).Error
if err != nil {
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
}).Error("database: failed to get user source link")
return nil, err
}
for _, userSource := range userSources {
var source models.Source
result = db.WithContext(ctx).Model(&models.Source{}).Where("id = ?", userSource.SourceID).First(&source)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err = db.WithContext(ctx).Model(&models.Source{}).Where("id = ?", userSource.SourceID).First(&source).Error
if err != nil {
log.WithFields(log.Fields{
"source_id": userSource.SourceID,
}).Error("database: failed to get source")
return nil, err
}
userSourceMap[source.DisplayName] = models.UserSource{
@ -178,41 +152,34 @@ func GetUserSourceLinks(ctx context.Context, db *gorm.DB, anthroveUserID models.
}
func GetUserSourceBySourceID(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, sourceID models.AnthroveSourceID) (map[string]models.UserSource, error) {
var userSources []models.UserSource
userSourceMap := make(map[string]models.UserSource)
if anthroveUserID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
return nil, fmt.Errorf("anthroveUserID cannot be empty")
}
if sourceID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "sourceID cannot be empty"}
return nil, fmt.Errorf("sourceID cannot be empty")
}
if len(sourceID) != 25 {
return nil, &errors2.EntityValidationFailed{Reason: "sourceID needs to be 25 characters long"}
}
var userSources []models.UserSource
userSourceMap := make(map[string]models.UserSource)
result := db.WithContext(ctx).Model(&models.UserSource{}).InnerJoins("Source", db.Where("id = ?", sourceID)).Where("user_id = ?", string(anthroveUserID)).First(&userSources)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err := db.WithContext(ctx).Model(&models.UserSource{}).InnerJoins("Source", db.Where("id = ?", sourceID)).Where("user_id = ?", string(anthroveUserID)).First(&userSources).Error
if err != nil {
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
"source_id": sourceID,
}).Error("database: failed to get specified user source link")
return nil, err
}
for _, userSource := range userSources {
var source models.Source
result = db.WithContext(ctx).Model(&models.Source{}).Where("id = ?", userSource.SourceID).First(&source)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err = db.WithContext(ctx).Model(&models.Source{}).Where("id = ?", userSource.SourceID).First(&source).Error
if err != nil {
log.WithFields(log.Fields{
"source_id": userSource.SourceID,
}).Error("database: failed to get source")
return nil, err
}
userSourceMap[source.DisplayName] = models.UserSource{
@ -238,16 +205,14 @@ func GetAllAnthroveUserIDs(ctx context.Context, db *gorm.DB) ([]models.AnthroveU
var users []models.User
var userIDs []models.AnthroveUserID
result := db.WithContext(ctx).Model(&models.User{}).Find(&users)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err := db.WithContext(ctx).Model(&models.User{}).Find(&users).Error
if err != nil {
log.Error("database: failed to get all anthrove user IDs")
return nil, err
}
for _, user := range users {
userIDs = append(userIDs, user.ID)
userIDs = append(userIDs, models.AnthroveUserID(user.ID))
}
log.WithFields(log.Fields{
@ -261,19 +226,13 @@ func GetUserFavoriteWithPagination(ctx context.Context, db *gorm.DB, anthroveUse
var userFavorites []models.UserFavorites
var favoritePosts []models.Post
if anthroveUserID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
}
err := db.WithContext(ctx).Model(&models.UserFavorites{}).Where("user_id = ?", string(anthroveUserID)).Offset(skip).Limit(limit).Find(&userFavorites).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
"skip": skip,
"limit": limit,
}).Error("database: failed to get user favorites with pagination")
return nil, err
}
@ -281,9 +240,9 @@ func GetUserFavoriteWithPagination(ctx context.Context, db *gorm.DB, anthroveUse
var post models.Post
err = db.WithContext(ctx).Model(&models.Post{}).Where("id = ?", userFavorite.PostID).First(&post).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
log.WithFields(log.Fields{
"post_id": userFavorite.PostID,
}).Error("database: failed to get post")
return nil, err
}
@ -304,21 +263,12 @@ func GetUserFavoriteWithPagination(ctx context.Context, db *gorm.DB, anthroveUse
func GetUserTagWitRelationToFavedPosts(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) ([]models.TagsWithFrequency, error) {
var userFavorites []models.UserFavorites
if anthroveUserID == "" {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID cannot be empty"}
}
if len(anthroveUserID) != 25 {
return nil, &errors2.EntityValidationFailed{Reason: "anthroveUserID needs to be 25 characters long"}
}
result := db.WithContext(ctx).Where("user_id = ?", string(anthroveUserID)).Find(&userFavorites)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err := db.WithContext(ctx).Where("user_id = ?", string(anthroveUserID)).Find(&userFavorites).Error
if err != nil {
log.WithFields(log.Fields{
"anthrove_user_id": anthroveUserID,
}).Error("database: failed to get user favorites")
return nil, err
}
tagFrequency := make(map[struct {
@ -328,12 +278,12 @@ func GetUserTagWitRelationToFavedPosts(ctx context.Context, db *gorm.DB, anthrov
for _, userFavorite := range userFavorites {
var post models.Post
result = db.WithContext(ctx).Preload("Tags").First(&post, "id = ?", userFavorite.PostID)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &errors2.NoDataFound{}
}
return nil, result.Error
err = db.WithContext(ctx).Preload("Tags").First(&post, "id = ?", userFavorite.PostID).Error
if err != nil {
log.WithFields(log.Fields{
"post_id": userFavorite.PostID,
}).Error("database: failed to get post tags")
return nil, err
}
for _, tag := range post.Tags {

42
internal/postgres/user_test.go
View File

@ -21,9 +21,6 @@ func TestCreateUser(t *testing.T) {
// Setup Test
validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
invalidUserID := models.AnthroveUserID("XXX")
// Test
type args struct {
ctx context.Context
@ -40,7 +37,7 @@ func TestCreateUser(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
},
wantErr: false,
},
@ -49,7 +46,7 @@ func TestCreateUser(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthroveUserID: "",
},
wantErr: true,
},
@ -74,14 +71,9 @@ func TestCreateUserNodeWithSourceRelation(t *testing.T) {
// Setup Test
validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
invalidUserID := models.AnthroveUserID("XXX")
validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1"))
source := &models.Source{
BaseModel: models.BaseModel[models.AnthroveSourceID]{
ID: validSourceID,
ID: models.AnthroveSourceID(fmt.Sprintf("%025s", "1")),
},
DisplayName: "e621",
Domain: "e621.net",
@ -111,7 +103,7 @@ func TestCreateUserNodeWithSourceRelation(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
sourceID: source.ID,
userID: "e1",
username: "marius",
@ -123,7 +115,7 @@ func TestCreateUserNodeWithSourceRelation(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthroveUserID: "2",
sourceID: source.ID,
userID: "e1",
username: "marius",
@ -147,7 +139,7 @@ func TestCreateUserNodeWithSourceRelation(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
sourceID: "fa.net",
userID: "e1",
username: "marius",
@ -159,7 +151,7 @@ func TestCreateUserNodeWithSourceRelation(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
sourceID: source.ID,
userID: "",
username: "marius",
@ -171,7 +163,7 @@ func TestCreateUserNodeWithSourceRelation(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
sourceID: source.ID,
userID: "aa",
username: "",
@ -198,11 +190,8 @@ func TestGetAllAnthroveUserIDs(t *testing.T) {
defer container.Terminate(ctx)
// Setup Test
validUserID01 := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
validUserID02 := models.AnthroveUserID(fmt.Sprintf("%025s", "User2"))
validUserID03 := models.AnthroveUserID(fmt.Sprintf("%025s", "User3"))
users := []models.AnthroveUserID{validUserID01, validUserID02, validUserID03}
users := []models.AnthroveUserID{"1", "2", "3"}
for _, user := range users {
err = CreateUser(ctx, gormDB, user)
@ -257,9 +246,6 @@ func TestGetUserSourceBySourceID(t *testing.T) {
// Setup Test
validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1"))
invalidUserID := models.AnthroveUserID("XXX")
expectedResult := make(map[string]models.UserSource)
expectedResult["e621"] = models.UserSource{
UserID: "e1",
@ -283,7 +269,7 @@ func TestGetUserSourceBySourceID(t *testing.T) {
t.Fatal(err)
}
err = CreateUserWithRelationToSource(ctx, gormDB, validUserID, models.AnthroveSourceID(expectedResult["e621"].SourceID), expectedResult["e621"].UserID, expectedResult["e621"].AccountUsername)
err = CreateUserWithRelationToSource(ctx, gormDB, "1", models.AnthroveSourceID(expectedResult["e621"].SourceID), expectedResult["e621"].UserID, expectedResult["e621"].AccountUsername)
if err != nil {
t.Fatal(err)
}
@ -306,7 +292,7 @@ func TestGetUserSourceBySourceID(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
sourceID: source.ID,
},
want: expectedResult,
@ -317,7 +303,7 @@ func TestGetUserSourceBySourceID(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: invalidUserID,
anthroveUserID: "22",
sourceID: source.ID,
},
want: nil,
@ -328,7 +314,7 @@ func TestGetUserSourceBySourceID(t *testing.T) {
args: args{
ctx: ctx,
db: gormDB,
anthroveUserID: validUserID,
anthroveUserID: "1",
sourceID: "fa",
},
want: nil,
@ -382,8 +368,6 @@ func TestGetUserSourceBySourceID(t *testing.T) {
}
}
// TODO: FIX THE FOUR REMAINING TESTS
func TestGetUserFavoriteNodeWithPagination(t *testing.T) {
// Setup trow away containert
ctx := context.Background()

11
pkg/errors/validation.go
View File

@ -1,11 +0,0 @@
package errors
import "fmt"
type EntityValidationFailed struct {
Reason string
}
func (e EntityValidationFailed) Error() string {
return fmt.Sprintf("Entity validation failed: %s", e.Reason)
}