feat(postgres): added GetUserTagsTroughFavedPosts

internal/postgres/user.go

@@ -0,0 +1,318 @@
+package postgres
+
+import (
+	"context"
+	"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
+	"git.dragse.it/anthrove/otter-space-sdk/pkg/models/graphModels"
+	"git.dragse.it/anthrove/otter-space-sdk/pkg/models/pgModels"
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+)
+
+func CreateUserNodeWithSourceRelation(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, sourceDomain string, userID string, username string) error {
+	user := pgModels.User{
+		BaseModel: pgModels.BaseModel{
+			ID: string(anthroveUserID),
+		},
+	}
+
+	if err := db.WithContext(ctx).FirstOrCreate(&user).Error; err != nil {
+		log.WithFields(log.Fields{
+			"anthrove_user_id": anthroveUserID,
+		}).Error("database: failed to find or create user")
+		return err
+	}
+
+	source := pgModels.Source{
+		Domain: sourceDomain,
+	}
+
+	if err := db.WithContext(ctx).Where(&source).First(&source).Error; err != nil {
+		log.WithFields(log.Fields{
+			"source_domain": sourceDomain,
+		}).Error("database: failed to find source")
+		return err
+	}
+
+	userSource := pgModels.UserSource{
+		UserID:          user.ID,
+		SourceID:        source.ID,
+		AccountUsername: username,
+		AccountID:       userID,
+	}
+
+	if err := db.WithContext(ctx).Create(&userSource).Error; err != nil {
+		log.WithFields(log.Fields{
+			"anthrove_user_id": anthroveUserID,
+			"source_domain":    sourceDomain,
+			"account_username": username,
+			"account_id":       userID,
+		}).Error("database: failed to create user-source relationship")
+		return err
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id": anthroveUserID,
+		"source_domain":    sourceDomain,
+		"account_username": username,
+		"account_id":       userID,
+	}).Trace("database: created user-source relationship")
+
+	return nil
+}
+
+func GetUserFavoritesCount(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) (int64, error) {
+	var count int64
+	err := db.WithContext(ctx).Model(&pgModels.UserFavorite{}).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{
+		"anthrove_user_id":        anthroveUserID,
+		"anthrove_user_fav_count": count,
+	}).Trace("database: got user favorite count")
+
+	return count, nil
+}
+
+func GetUserSourceLink(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) (map[string]graphModels.AnthroveUserRelationship, error) {
+	var userSources []pgModels.UserSource
+	userSourceMap := make(map[string]graphModels.AnthroveUserRelationship)
+
+	err := db.WithContext(ctx).Model(&pgModels.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 pgModels.Source
+		err = db.WithContext(ctx).Model(&pgModels.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] = graphModels.AnthroveUserRelationship{
+			UserID:   userSource.AccountID,
+			Username: userSource.AccountUsername,
+			Source: graphModels.AnthroveSource{
+				DisplayName: source.DisplayName,
+				Domain:      source.Domain,
+				Icon:        source.Icon,
+			},
+		}
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id": anthroveUserID,
+	}).Trace("database: got user source link")
+
+	return userSourceMap, nil
+}
+
+func GetSpecifiedUserSourceLink(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, sourceDisplayName string) (map[string]graphModels.AnthroveUserRelationship, error) {
+	var userSources []pgModels.UserSource
+	userSourceMap := make(map[string]graphModels.AnthroveUserRelationship)
+
+	err := db.WithContext(ctx).Model(&pgModels.UserSource{}).Joins("Source").Where("user_id = ? AND display_name = ?", string(anthroveUserID), sourceDisplayName).Find(&userSources).Error
+	if err != nil {
+		log.WithFields(log.Fields{
+			"anthrove_user_id":    anthroveUserID,
+			"source_display_name": sourceDisplayName,
+		}).Error("database: failed to get specified user source link")
+		return nil, err
+	}
+
+	for _, userSource := range userSources {
+		var source pgModels.Source
+		err = db.WithContext(ctx).Model(&pgModels.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] = graphModels.AnthroveUserRelationship{
+			UserID:   userSource.AccountID,
+			Username: userSource.AccountUsername,
+			Source: graphModels.AnthroveSource{
+				DisplayName: source.DisplayName,
+				Domain:      source.Domain,
+				Icon:        source.Icon,
+			},
+		}
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id":    anthroveUserID,
+		"source_display_name": sourceDisplayName,
+	}).Trace("database: got specified user source link")
+
+	return userSourceMap, nil
+}
+
+func GetAnthroveUser(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) (*graphModels.AnthroveUser, error) {
+	var user pgModels.User
+	var userSources []pgModels.UserSource
+	anthroveUser := &graphModels.AnthroveUser{
+		UserID: anthroveUserID,
+	}
+
+	err := db.WithContext(ctx).First(&user, "id = ?", string(anthroveUserID)).Error
+	if err != nil {
+		log.WithFields(log.Fields{
+			"anthrove_user_id": anthroveUserID,
+		}).Error("database: failed to get user")
+		return nil, err
+	}
+
+	err = db.WithContext(ctx).Model(&pgModels.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 sources")
+		return nil, err
+	}
+
+	for _, userSource := range userSources {
+		var source pgModels.Source
+		err = db.WithContext(ctx).Model(&pgModels.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
+		}
+
+		anthroveUser.Relationship = append(anthroveUser.Relationship, graphModels.AnthroveUserRelationship{
+			UserID:   userSource.AccountID,
+			Username: userSource.AccountUsername,
+			Source: graphModels.AnthroveSource{
+				DisplayName: source.DisplayName,
+				Domain:      source.Domain,
+				Icon:        source.Icon,
+			},
+		})
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id": anthroveUserID,
+	}).Trace("database: got anthrove user")
+
+	return anthroveUser, nil
+}
+
+func GetAllAnthroveUserIDs(ctx context.Context, db *gorm.DB) ([]models.AnthroveUserID, error) {
+	var users []pgModels.User
+	var userIDs []models.AnthroveUserID
+
+	err := db.WithContext(ctx).Model(&pgModels.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, models.AnthroveUserID(user.ID))
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id_count": len(userIDs),
+	}).Trace("database: got all anthrove user IDs")
+
+	return userIDs, nil
+}
+
+func GetUserFavoriteNodeWithPagination(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID, skip int, limit int) (*graphModels.FavoriteList, error) {
+	var userFavorites []pgModels.UserFavorite
+	var favoritePosts []graphModels.FavoritePost
+
+	err := db.WithContext(ctx).Model(&pgModels.UserFavorite{}).Where("user_id = ?", string(anthroveUserID)).Offset(skip).Limit(limit).Find(&userFavorites).Error
+	if err != nil {
+		log.WithFields(log.Fields{
+			"anthrove_user_id": anthroveUserID,
+			"skip":             skip,
+			"limit":            limit,
+		}).Error("database: failed to get user favorites with pagination")
+		return nil, err
+	}
+
+	for _, userFavorite := range userFavorites {
+		var post pgModels.Post
+		err = db.WithContext(ctx).Model(&pgModels.Post{}).Where("id = ?", userFavorite.PostID).First(&post).Error
+		if err != nil {
+			log.WithFields(log.Fields{
+				"post_id": userFavorite.PostID,
+			}).Error("database: failed to get post")
+			return nil, err
+		}
+
+		favoritePosts = append(favoritePosts, graphModels.FavoritePost{
+			AnthrovePost: graphModels.AnthrovePost{
+				PostID: models.AnthrovePostID(post.ID),
+				Rating: post.Rating,
+			},
+		})
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id":        anthroveUserID,
+		"anthrove_user_fav_count": len(favoritePosts),
+	}).Trace("database: got all anthrove user favorites")
+
+	return &graphModels.FavoriteList{Posts: favoritePosts}, nil
+}
+
+func GetUserTagNodeWitRelationToFavedPosts(ctx context.Context, db *gorm.DB, anthroveUserID models.AnthroveUserID) ([]graphModels.TagsWithFrequency, error) {
+	var userFavorites []pgModels.UserFavorite
+	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[string]int)
+	for _, userFavorite := range userFavorites {
+		var postTags []pgModels.Tag
+		err = db.WithContext(ctx).Model(&pgModels.Post{}).Where("id = ?", userFavorite.PostID).Association("Tags").Find(&postTags)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"post_id": userFavorite.PostID,
+			}).Error("database: failed to get post tags")
+			return nil, err
+		}
+
+		for _, tag := range postTags {
+			tagFrequency[tag.Name]++
+		}
+	}
+
+	var tagsWithFrequency []graphModels.TagsWithFrequency
+	for tagName, frequency := range tagFrequency {
+		tagsWithFrequency = append(tagsWithFrequency, graphModels.TagsWithFrequency{
+			Frequency: int64(frequency),
+			Tags: graphModels.AnthroveTag{
+				Name: tagName,
+			},
+		})
+	}
+
+	log.WithFields(log.Fields{
+		"anthrove_user_id": anthroveUserID,
+		"tag_amount":       len(tagsWithFrequency),
+	}).Trace("database: got user tag node with relation to faved posts")
+
+	return tagsWithFrequency, nil
+}

pkg/database/postgres.go

@@ -54,8 +54,7 @@ func (p *postgresqlConnection) Connect(_ context.Context, endpoint string, usern
 }
 
 func (p *postgresqlConnection) AddUserWithRelationToSource(ctx context.Context, anthroveUserID models.AnthroveUserID, sourceDomain string, userID string, username string) error {
-	//TODO implement me
+	return postgres.CreateUserNodeWithSourceRelation(ctx, p.db, anthroveUserID, userID, sourceDomain, userID)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) AddSource(ctx context.Context, anthroveSource *graphModels.AnthroveSource) error {
@@ -103,38 +102,31 @@ func (p *postgresqlConnection) CheckPostNodeExistsBySourceID(ctx context.Context
 }
 
 func (p *postgresqlConnection) GetUserFavoriteCount(ctx context.Context, anthroveUserID models.AnthroveUserID) (int64, error) {
-	//TODO implement me
+	return postgres.GetUserFavoritesCount(ctx, p.db, anthroveUserID)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetUserSourceLinks(ctx context.Context, anthroveUserID models.AnthroveUserID) (map[string]graphModels.AnthroveUserRelationship, error) {
-	//TODO implement me
+	return postgres.GetUserSourceLink(ctx, p.db, anthroveUserID)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetSpecifiedUserSourceLink(ctx context.Context, anthroveUserID models.AnthroveUserID, sourceDisplayName string) (map[string]graphModels.AnthroveUserRelationship, error) {
-	//TODO implement me
+	return postgres.GetSpecifiedUserSourceLink(ctx, p.db, anthroveUserID, sourceDisplayName)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetAnthroveUser(ctx context.Context, anthroveUserID models.AnthroveUserID) (*graphModels.AnthroveUser, error) {
-	//TODO implement me
+	return postgres.GetAnthroveUser(ctx, p.db, anthroveUserID)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetAllAnthroveUserIDs(ctx context.Context) ([]models.AnthroveUserID, error) {
-	//TODO implement me
+	return postgres.GetAllAnthroveUserIDs(ctx, p.db)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetUserFavoritePostsWithPagination(ctx context.Context, anthroveUserID models.AnthroveUserID, skip int, limit int) (*graphModels.FavoriteList, error) {
-	//TODO implement me
+	return postgres.GetUserFavoriteNodeWithPagination(ctx, p.db, anthroveUserID, skip, limit)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetUserTagsTroughFavedPosts(ctx context.Context, anthroveUserID models.AnthroveUserID) ([]graphModels.TagsWithFrequency, error) {
-	//TODO implement me
+	return postgres.GetUserTagNodeWitRelationToFavedPosts(ctx, p.db, anthroveUserID)
-	panic("implement me")
 }
 
 func (p *postgresqlConnection) GetAllTags(ctx context.Context) ([]graphModels.TagsWithFrequency, error) {