website/pkg/models/comment.go

package models

import (
	"errors"
	"math"
	"strings"
	"time"

	"code.nonshy.com/nonshy/website/pkg/log"
	"gorm.io/gorm"
)

// Comment table - in forum threads, on profiles or photos, etc.
type Comment struct {
	ID        uint64 `gorm:"primaryKey"`
	TableName string `gorm:"index"`
	TableID   uint64 `gorm:"index"`
	UserID    uint64 `gorm:"index"`
	User      User
	Message   string
	CreatedAt time.Time
	UpdatedAt time.Time
}

// CommentableTables are the set of table names that allow comments (via the
// generic "/comments" URI which accepts a table_name param)
var CommentableTables = map[string]interface{}{
	"photos":  nil,
	"threads": nil,
}

// Preload related tables for the forum (classmethod).
func (c *Comment) Preload() *gorm.DB {
	return DB.Preload("User.ProfilePhoto")
}

// GetComment by ID.
func GetComment(id uint64) (*Comment, error) {
	c := &Comment{}
	result := c.Preload().First(&c, id)
	return c, result.Error
}

// GetComments queries a set of comment IDs and returns them mapped.
func GetComments(IDs []uint64) (map[uint64]*Comment, error) {
	var (
		mt = map[uint64]*Comment{}
		ts = []*Comment{}
	)

	result := (&Comment{}).Preload().Where("id IN ?", IDs).Find(&ts)
	for _, row := range ts {
		mt[row.ID] = row
	}

	return mt, result.Error
}

// AddComment about anything.
func AddComment(user *User, tableName string, tableID uint64, message string) (*Comment, error) {
	c := &Comment{
		TableName: tableName,
		TableID:   tableID,
		User:      *user,
		Message:   message,
	}
	result := DB.Create(c)
	return c, result.Error
}

// CountCommentsByUser returns the total number of comments written by a user.
func CountCommentsByUser(user *User, tableName string) int64 {
	var count int64
	result := DB.Where(
		"table_name = ? AND user_id = ?",
		tableName, user.ID,
	).Model(&Comment{}).Count(&count)
	if result.Error != nil {
		log.Error("CountCommentsByUser(%d): %s", user.ID, result.Error)
	}
	return count
}

// CountCommentsReceived returns the total number of comments received on a user's photos.
func CountCommentsReceived(user *User) int64 {
	var count int64
	DB.Model(&Comment{}).Joins(
		"LEFT OUTER JOIN photos ON (comments.table_name = 'photos' AND comments.table_id = photos.id)",
	).Where(
		"comments.table_name = 'photos' AND photos.user_id = ?",
		user.ID,
	).Count(&count)
	return count
}

// PaginateComments provides a page of comments on something.
func PaginateComments(user *User, tableName string, tableID uint64, pager *Pagination) ([]*Comment, error) {
	var (
		cs             = []*Comment{}
		query          = (&Comment{}).Preload()
		blockedUserIDs = BlockedUserIDs(user)
		wheres         = []string{}
		placeholders   = []interface{}{}
	)

	wheres = append(wheres, "table_name = ? AND table_id = ?")
	placeholders = append(placeholders, tableName, tableID)

	if len(blockedUserIDs) > 0 {
		wheres = append(wheres, "user_id NOT IN ?")
		placeholders = append(placeholders, blockedUserIDs)
	}

	// Don't show comments from banned or disabled accounts.
	wheres = append(wheres, `
		EXISTS (
			SELECT 1
			FROM users
			WHERE users.id = comments.user_id
			AND users.status = 'active'
		)
	`)

	query = query.Where(
		strings.Join(wheres, " AND "),
		placeholders...,
	).Order(pager.Sort)

	query.Model(&Comment{}).Count(&pager.Total)
	result := query.Offset(pager.GetOffset()).Limit(pager.PerPage).Find(&cs)

	// Inject user relationships into these comments' authors.
	SetUserRelationshipsInComments(user, cs)

	return cs, result.Error
}

// FindPageByComment finds out what page a comment ID exists on for the current user, taking into
// account their block lists and comment visibility.
//
// Note: the comments are assumed ordered by created_at asc.
func FindPageByComment(user *User, comment *Comment, pageSize int) (int, error) {
	var (
		allCommentIDs  []uint64
		blockedUserIDs = BlockedUserIDs(user)
		wheres         = []string{}
		placeholders   = []interface{}{}
	)

	// Get the complete set of comment IDs that this comment is on a thread of.
	wheres = append(wheres, "table_name = ? AND table_id = ?")
	placeholders = append(placeholders, comment.TableName, comment.TableID)

	if len(blockedUserIDs) > 0 {
		wheres = append(wheres, "user_id NOT IN ?")
		placeholders = append(placeholders, blockedUserIDs)
	}

	result := DB.Table(
		"comments",
	).Select(
		"id",
	).Where(
		strings.Join(wheres, " AND "),
		placeholders...,
	).Order("created_at asc").Scan(&allCommentIDs)
	if result.Error != nil {
		return 0, result.Error
	}

	// Scan the comment thread to find it.
	for i, cid := range allCommentIDs {
		if cid == comment.ID {
			var page = int(math.Ceil(float64(i) / float64(pageSize)))
			if page == 0 {
				page = 1
			}
			return page, nil
		}
	}

	return -1, errors.New("comment not visible to current user")
}

// ListComments returns a complete set of comments without paging.
func ListComments(user *User, tableName string, tableID uint64) ([]*Comment, error) {
	var (
		cs             []*Comment
		blockedUserIDs = BlockedUserIDs(user)
		wheres         = []string{}
		placeholders   = []interface{}{}
	)

	wheres = append(wheres, "table_name = ? AND table_id = ?")
	placeholders = append(placeholders, tableName, tableID)

	if len(blockedUserIDs) > 0 {
		wheres = append(wheres, "user_id NOT IN ?")
		placeholders = append(placeholders, blockedUserIDs)
	}

	// Don't show comments from banned or disabled accounts.
	wheres = append(wheres, `
		EXISTS (
			SELECT 1
			FROM users
			WHERE users.id = comments.user_id
			AND users.status = 'active'
		)
	`)

	result := (&Comment{}).Preload().Where(
		strings.Join(wheres, " AND "),
		placeholders...,
	).Order("created_at asc").Find(&cs)
	return cs, result.Error
}

// Save a comment.
func (c *Comment) Save() error {
	return DB.Save(c).Error
}

// Delete a comment.
func (c *Comment) Delete() error {
	return DB.Delete(c).Error
}

// IsEdited returns if a comment was reasonably edited after it was created.
func (c *Comment) IsEdited() bool {
	return c.UpdatedAt.Sub(c.CreatedAt) > 5*time.Second
}

type CommentCountMap map[uint64]int64

// MapCommentCounts collects total numbers of comments over a set of table IDs. Returns a
// map of table ID (uint64) to comment counts for each (int64).
func MapCommentCounts(tableName string, tableIDs []uint64) CommentCountMap {
	var result = CommentCountMap{}

	// Initialize the result set.
	for _, id := range tableIDs {
		result[id] = 0
	}

	// Hold the result of the grouped count query.
	type group struct {
		ID       uint64
		Comments int64
	}
	var groups = []group{}

	// Map the counts of comments to each of these IDs.
	if res := DB.Table(
		"comments",
	).Select(
		"table_id AS id, count(id) AS comments",
	).Where(
		"table_name = ? AND table_id IN ?",
		tableName, tableIDs,
	).Group("table_id").Scan(&groups); res.Error != nil {
		log.Error("MapCommentCounts: count query: %s", res.Error)
	}

	// Map the counts back in.
	for _, row := range groups {
		result[row.ID] = row.Comments
	}

	return result
}

// Get a comment count for the given table ID from the map.
func (cc CommentCountMap) Get(id uint64) int64 {
	if value, ok := cc[id]; ok {
		return value
	}
	return 0
}