updates to models and tags

internal/db/db.go

@@ -92,6 +92,11 @@ type DB interface {
 	// The given interface i will be set to the result of the query, whatever it is. Use a pointer or a slice.
 	Put(i interface{}) error
 
+	// Upsert stores or updates i based on the given conflict column, as in https://www.postgresqltutorial.com/postgresql-upsert/
+	// It is up to the implementation to figure out how to store it, and using what key.
+	// The given interface i will be set to the result of the query, whatever it is. Use a pointer or a slice.
+	Upsert(i interface{}, conflictColumn string) error
+
 	// UpdateByID updates i with id id.
 	// The given interface i will be set to the result of the query, whatever it is. Use a pointer or a slice.
 	UpdateByID(id string, i interface{}) error
@@ -192,15 +197,16 @@ type DB interface {
 	// checks in the database for the mentioned accounts, and returns a slice of mentions generated based on the given parameters.
 	//
 	// Note: this func doesn't/shouldn't do any manipulation of the accounts in the DB, it's just for checking
-	// if they exist in the db and conveniently returning them.
+	// if they exist in the db and conveniently returning them if they do.
 	MentionStringsToMentions(targetAccounts []string, originAccountID string, statusID string) ([]*gtsmodel.Mention, error)
 
 	// TagStringsToTags takes a slice of deduplicated, lowercase tags in the form "somehashtag", which have been
 	// used in a status. It takes the id of the account that wrote the status, and the id of the status itself, and then
-	// returns a slice of *model.Tag corresponding to the given tags.
+	// returns a slice of *model.Tag corresponding to the given tags. If the tag already exists in database, that tag
+	// will be returned. Otherwise a pointer to a new tag struct will be created and returned.
 	//
 	// Note: this func doesn't/shouldn't do any manipulation of the tags in the DB, it's just for checking
-	// if they exist in the db and conveniently returning them.
+	// if they exist in the db already, and conveniently returning them, or creating new tag structs.
 	TagStringsToTags(tags []string, originAccountID string, statusID string) ([]*gtsmodel.Tag, error)
 
 	// EmojiStringsToEmojis takes a slice of deduplicated, lowercase emojis in the form ":emojiname:", which have been
@@ -208,7 +214,7 @@ type DB interface {
 	// returns a slice of *model.Emoji corresponding to the given emojis.
 	//
 	// Note: this func doesn't/shouldn't do any manipulation of the emoji in the DB, it's just for checking
-	// if they exist in the db and conveniently returning them.
+	// if they exist in the db and conveniently returning them if they do.
 	EmojiStringsToEmojis(emojis []string, originAccountID string, statusID string) ([]*gtsmodel.Emoji, error)
 }
 

internal/db/gtsmodel/mention.go

@@ -25,15 +25,15 @@ type Mention struct {
 	// ID of this mention in the database
 	ID string `pg:"type:uuid,default:gen_random_uuid(),pk,notnull,unique"`
 	// ID of the status this mention originates from
-	StatusID string
+	StatusID string `pg:",notnull"`
 	// When was this mention created?
 	CreatedAt time.Time `pg:"type:timestamp,notnull,default:now()"`
 	// When was this mention last updated?
 	UpdatedAt time.Time `pg:"type:timestamp,notnull,default:now()"`
 	// Who created this mention?
-	OriginAccountID string
+	OriginAccountID string `pg:",notnull"`
 	// Who does this mention target?
-	TargetAccountID string
+	TargetAccountID string `pg:",notnull"`
 	// Prevent this mention from generating a notification?
 	Silent bool
 }

internal/db/gtsmodel/status.go

@@ -31,7 +31,13 @@ type Status struct {
 	// the html-formatted content of this status
 	Content string
 	// Database IDs of any media attachments associated with this status
-	Attachments []string
+	Attachments []string `pg:",array"`
+	// Database IDs of any tags used in this status
+	Tags []string `pg:",array"`
+	// Database IDs of any mentions in this status
+	Mentions []string `pg:",array"`
+	// Database IDs of any emojis used in this status
+	Emojis []string `pg:",array"`
 	// when was this status created?
 	CreatedAt time.Time `pg:"type:timestamp,notnull,default:now()"`
 	// when was this status updated?

internal/db/gtsmodel/tag.go

@@ -20,17 +20,22 @@ package gtsmodel
 
 import "time"
 
+// Tag represents a hashtag for gathering public statuses together
 type Tag struct {
-	ID                string    `pg:"type:uuid,default:gen_random_uuid(),pk,notnull"`
-	Name              string    `pg:"unique,notnull"`
-	CreatedAt         time.Time `pg:"type:timestamp,notnull,default:now()"`
-	UpdatedAt         time.Time `pg:"type:timestamp,notnull,default:now()"`
-	Useable           bool
-	Trendable         bool
-	Listable          bool
-	ReviewedAt        time.Time
-	RequestedReviewAt time.Time
-	LastStatusAt      time.Time
-	MaxScore          float32
-	MaxScoreAt        time.Time
+	// id of this tag in the database
+	ID string `pg:",unique,type:uuid,default:gen_random_uuid(),pk,notnull"`
+	// name of this tag -- the tag without the hash part
+	Name string `pg:",unique,pk,notnull"`
+	// Which account ID is the first one we saw using this tag?
+	FirstSeenFromAccountID string
+	// when was this tag created
+	CreatedAt time.Time `pg:"type:timestamp,notnull,default:now()"`
+	// when was this tag last updated
+	UpdatedAt time.Time `pg:"type:timestamp,notnull,default:now()"`
+	// can our instance users use this tag?
+	Useable bool `pg:",notnull,default:true"`
+	// can our instance users look up this tag?
+	Listable bool `pg:",notnull,default:true"`
+	// when was this tag last used?
+	LastStatusAt time.Time `pg:"type:timestamp,notnull,default:now()"`
 }

internal/db/pg.go

@@ -34,6 +34,7 @@ import (
 	"github.com/go-pg/pg/extra/pgdebug"
 	"github.com/go-pg/pg/v10"
 	"github.com/go-pg/pg/v10/orm"
+	"github.com/google/uuid"
 	"github.com/sirupsen/logrus"
 	"github.com/superseriousbusiness/gotosocial/internal/config"
 	"github.com/superseriousbusiness/gotosocial/internal/db/gtsmodel"
@@ -273,8 +274,18 @@ func (ps *postgresService) Put(i interface{}) error {
 	return err
 }
 
+func (ps *postgresService) Upsert(i interface{}, conflictColumn string) error {
+	if _, err := ps.conn.Model(i).OnConflict(fmt.Sprintf("(%s) DO UPDATE", conflictColumn)).Insert(); err != nil {
+		if err == pg.ErrNoRows {
+			return ErrNoEntries{}
+		}
+		return err
+	}
+	return nil
+}
+
 func (ps *postgresService) UpdateByID(id string, i interface{}) error {
-	if _, err := ps.conn.Model(i).OnConflict("(id) DO UPDATE").Insert(); err != nil {
+	if _, err := ps.conn.Model(i).Where("id = ?", id).OnConflict("(id) DO UPDATE").Insert(); err != nil {
 		if err == pg.ErrNoRows {
 			return ErrNoEntries{}
 		}
@@ -765,15 +776,33 @@ func (ps *postgresService) MentionStringsToMentions(targetAccounts []string, ori
 	return menchies, nil
 }
 
-// for now this function doesn't really use the database, but it's here because:
-// A) it probably will later and
-// B) it's v. similar to MentionStringsToMentions
 func (ps *postgresService) TagStringsToTags(tags []string, originAccountID string, statusID string) ([]*gtsmodel.Tag, error) {
 	newTags := []*gtsmodel.Tag{}
 	for _, t := range tags {
-		newTags = append(newTags, &gtsmodel.Tag{
-			Name: t,
-		})
+		tag := &gtsmodel.Tag{}
+		// we can use selectorinsert here to create the new tag if it doesn't exist already
+		// inserted will be true if this is a new tag we just created
+		if err := ps.conn.Model(tag).Where("name = ?", t).Select(); err != nil {
+			if err == pg.ErrNoRows {
+				// tag doesn't exist yet so populate it
+				tag.ID = uuid.NewString()
+				tag.Name = t
+				tag.FirstSeenFromAccountID = originAccountID
+				tag.CreatedAt = time.Now()
+				tag.UpdatedAt = time.Now()
+				tag.Useable = true
+				tag.Listable = true
+			} else {
+				return nil, fmt.Errorf("error getting tag with name %s: %s", t, err)
+			}
+		}
+
+		// bail already if the tag isn't useable
+		if !tag.Useable {
+			continue
+		}
+		tag.LastStatusAt = time.Now()
+		newTags = append(newTags, tag)
 	}
 	return newTags, nil
 }