website/pkg/models/friend.go
2023-11-25 13:39:38 -08:00

496 lines
13 KiB
Go

package models
import (
"errors"
"strings"
"time"
"code.nonshy.com/nonshy/website/pkg/log"
"gorm.io/gorm"
)
// Friend table.
type Friend struct {
ID uint64 `gorm:"primaryKey"`
SourceUserID uint64 `gorm:"index"`
TargetUserID uint64 `gorm:"index"`
Approved bool `gorm:"index"`
Ignored bool
CreatedAt time.Time
UpdatedAt time.Time
}
// AddFriend sends a friend request or accepts one if there was already a pending one.
func AddFriend(sourceUserID, targetUserID uint64) error {
// Did we already send a friend request?
f := &Friend{}
forward := DB.Where(
"source_user_id = ? AND target_user_id = ?",
sourceUserID, targetUserID,
).First(&f).Error
// Is there a reverse friend request pending?
rev := &Friend{}
reverse := DB.Where(
"source_user_id = ? AND target_user_id = ?",
targetUserID, sourceUserID,
).First(&rev).Error
// If we have previously Ignored the friend request, we can not Accept it but only Reject it.
if reverse == nil && rev.Ignored {
return errors.New(
"you have previously ignored a friend request from this person and can not accept it now - " +
"please go to your Friends page, Ignored tab, and remove the ignored friend request there and try again",
)
}
// If the reverse exists (requested us) but not the forward, this completes the friendship.
if reverse == nil && forward != nil {
// Approve the reverse.
rev.Approved = true
rev.Ignored = false
rev.Save()
// Add the matching forward.
f = &Friend{
SourceUserID: sourceUserID,
TargetUserID: targetUserID,
Approved: true,
Ignored: false,
}
return DB.Create(f).Error
}
// If the forward already existed, error.
if forward == nil {
if f.Approved {
return errors.New("you are already friends")
}
return errors.New("a friend request had already been sent")
}
// Create the pending forward request.
f = &Friend{
SourceUserID: sourceUserID,
TargetUserID: targetUserID,
Approved: false,
}
return DB.Create(f).Error
}
// AreFriends quickly checks if two user IDs are friends.
func AreFriends(sourceUserID, targetUserID uint64) bool {
f := &Friend{}
DB.Where(
"source_user_id = ? AND target_user_id = ?",
sourceUserID, targetUserID,
).First(&f)
return f.Approved
}
// FriendStatus returns an indicator of friendship status: "none", "pending", "approved"
func FriendStatus(sourceUserID, targetUserID uint64) string {
f := &Friend{}
result := DB.Where(
"source_user_id = ? AND target_user_id = ?",
sourceUserID, targetUserID,
).First(&f)
if result.Error == nil {
if f.Approved {
return "approved"
}
return "pending"
}
return "none"
}
// FriendIDs returns all user IDs with approved friendship to the user.
func FriendIDs(userId uint64) []uint64 {
var (
fs = []*Friend{}
userIDs = []uint64{}
)
DB.Where("source_user_id = ? AND approved = ?", userId, true).Find(&fs)
for _, row := range fs {
userIDs = append(userIDs, row.TargetUserID)
}
return userIDs
}
// FilterFriendIDs can filter down a listing of user IDs and return only the ones who are your friends.
func FilterFriendIDs(userIDs []uint64, friendIDs []uint64) []uint64 {
var (
seen = map[uint64]interface{}{}
filtered = []uint64{}
)
// Map the friend IDs out.
for _, friendID := range friendIDs {
seen[friendID] = nil
}
// Filter the userIDs.
for _, userID := range userIDs {
if _, ok := seen[userID]; ok {
filtered = append(filtered, userID)
}
}
return filtered
}
// FilterFriendUsernames takes a list of usernames and returns only the ones who are your friends.
func FilterFriendUsernames(currentUser *User, usernames []string) []string {
var (
fs = []*Friend{}
userIDs = []uint64{}
userMap = map[uint64]string{}
result = []string{}
)
// Map usernames to user IDs.
users, err := GetUsersByUsernames(currentUser, usernames)
if err != nil {
log.Error("FilterFriendUsernames: GetUsersByUsernames: %s", err)
return result
}
for _, user := range users {
userIDs = append(userIDs, user.ID)
userMap[user.ID] = user.Username
}
if len(userIDs) == 0 {
return result
}
DB.Where("source_user_id = ? AND approved = ? AND target_user_id IN ?", currentUser.ID, true, userIDs).Find(&fs)
for _, row := range fs {
result = append(result, userMap[row.TargetUserID])
}
return result
}
// FriendIDsAreExplicit returns friend IDs who have opted-in for Explicit content,
// e.g. to notify only them when you uploaded a new Explicit photo so that non-explicit
// users don't need to see that notification.
func FriendIDsAreExplicit(userId uint64) []uint64 {
var (
userIDs = []uint64{}
)
err := DB.Table(
"friends",
).Joins(
"JOIN users ON (users.id = friends.target_user_id)",
).Select(
"friends.target_user_id AS friend_id",
).Where(
"friends.source_user_id = ? AND friends.approved = ? AND users.explicit = ?",
userId, true, true,
).Scan(&userIDs)
if err.Error != nil {
log.Error("SQL error collecting explicit FriendIDs for %d: %s", userId, err.Error)
}
return userIDs
}
// FriendIDsInCircle returns friend IDs who are part of the inner circle.
func FriendIDsInCircle(userId uint64) []uint64 {
var (
userIDs = []uint64{}
)
err := DB.Table(
"friends",
).Joins(
"JOIN users ON (users.id = friends.target_user_id)",
).Select(
"friends.target_user_id AS friend_id",
).Where(
"friends.source_user_id = ? AND friends.approved = ? AND (users.inner_circle = ? OR users.is_admin = ?)",
userId, true, true, true,
).Scan(&userIDs)
if err.Error != nil {
log.Error("SQL error collecting circle FriendIDs for %d: %s", userId, err.Error)
}
return userIDs
}
// FriendIDsInCircleAreExplicit returns the combined friend IDs who are in the inner circle + have opted in to explicit content.
// It is the combination of FriendIDsAreExplicit and FriendIDsInCircle.
func FriendIDsInCircleAreExplicit(userId uint64) []uint64 {
var (
userIDs = []uint64{}
)
err := DB.Table(
"friends",
).Joins(
"JOIN users ON (users.id = friends.target_user_id)",
).Select(
"friends.target_user_id AS friend_id",
).Where(
"friends.source_user_id = ? AND friends.approved = ? AND users.explicit = ? AND (users.inner_circle = ? OR users.is_admin = ?)",
userId, true, true, true, true,
).Scan(&userIDs)
if err.Error != nil {
log.Error("SQL error collecting explicit FriendIDs for %d: %s", userId, err.Error)
}
return userIDs
}
// CountFriendRequests gets a count of pending requests for the user.
func CountFriendRequests(userID uint64) (int64, error) {
var count int64
result := DB.Where(
"target_user_id = ? AND approved = ? AND ignored IS NOT true",
userID,
false,
).Model(&Friend{}).Count(&count)
return count, result.Error
}
// CountIgnoredFriendRequests gets a count of ignored pending friend requests for the user.
func CountIgnoredFriendRequests(userID uint64) (int64, error) {
var count int64
result := DB.Where(
"target_user_id = ? AND approved = ? AND ignored = ?",
userID,
false,
true,
).Model(&Friend{}).Count(&count)
return count, result.Error
}
// CountFriends gets a count of friends for the user.
func CountFriends(userID uint64) int64 {
var count int64
result := DB.Where(
"target_user_id = ? AND approved = ? AND EXISTS (SELECT 1 FROM users WHERE users.id = friends.source_user_id AND users.status = 'active')",
userID,
true,
).Model(&Friend{}).Count(&count)
if result.Error != nil {
log.Error("CountFriends(%d): %s", userID, result.Error)
}
return count
}
/*
PaginateFriends gets a page of friends (or pending friend requests) as User objects ordered
by friendship date.
The `requests` and `sent` bools are mutually exclusive (use only one, or neither). `requests`
asks for unanswered friend requests to you, and `sent` returns the friend requests that you
have sent and have not been answered.
*/
func PaginateFriends(user *User, requests bool, sent bool, ignored bool, pager *Pagination) ([]*User, error) {
// We paginate over the Friend table.
var (
fs = []*Friend{}
userIDs = []uint64{}
query *gorm.DB
)
if requests && sent && ignored {
return nil, errors.New("requests and sent are mutually exclusive options, use one or neither")
}
if requests {
query = DB.Where(
"target_user_id = ? AND approved = ? AND ignored IS NOT true",
user.ID, false,
)
} else if sent {
query = DB.Where(
"source_user_id = ? AND approved = ? AND ignored IS NOT true",
user.ID, false,
)
} else if ignored {
query = DB.Where(
"target_user_id = ? AND approved = ? AND ignored = ?",
user.ID, false, true,
)
} else {
query = DB.Where(
"source_user_id = ? AND approved = ?",
user.ID, true,
)
}
query = query.Order(pager.Sort)
query.Model(&Friend{}).Count(&pager.Total)
result := query.Offset(pager.GetOffset()).Limit(pager.PerPage).Find(&fs)
if result.Error != nil {
return nil, result.Error
}
// Now of these friends get their User objects.
for _, friend := range fs {
if requests || ignored {
userIDs = append(userIDs, friend.SourceUserID)
} else {
userIDs = append(userIDs, friend.TargetUserID)
}
}
return GetUsers(user, userIDs)
}
/*
PaginateOtherUserFriends gets a page of friends from another user, for their profile page.
*/
func PaginateOtherUserFriends(currentUser *User, user *User, pager *Pagination) ([]*User, error) {
// We paginate over the Friend table.
var (
fs = []*Friend{}
blockedUserIDs = BlockedUserIDs(currentUser)
userIDs = []uint64{}
wheres = []string{}
placeholders = []interface{}{}
query = DB.Model(&Friend{})
)
// Get friends of the target user.
wheres = append(wheres, "source_user_id = ? AND approved = ?")
placeholders = append(placeholders, user.ID, true)
// Don't show our blocked users in the result.
if len(blockedUserIDs) > 0 {
wheres = append(wheres, "target_user_id NOT IN ?")
placeholders = append(placeholders, blockedUserIDs)
}
// Don't show disabled or banned users.
wheres = append(wheres, `
EXISTS (
SELECT 1
FROM users
WHERE users.id = friends.target_user_id
AND users.status = 'active'
)
`)
query = query.Where(
strings.Join(wheres, " AND "),
placeholders...,
).Order(pager.Sort)
// Get the total count.
query.Count(&pager.Total)
// Get the page.
result := query.Offset(pager.GetOffset()).Limit(pager.PerPage).Find(&fs)
if result.Error != nil {
return nil, result.Error
}
// Now of these friends get their User objects.
for _, friend := range fs {
userIDs = append(userIDs, friend.TargetUserID)
}
return GetUsers(currentUser, userIDs)
}
// GetFriendRequests returns all pending friend requests for a user.
func GetFriendRequests(userID uint64) ([]*Friend, error) {
var fs = []*Friend{}
result := DB.Where(
"target_user_id = ? AND approved = ?",
userID,
false,
).Find(&fs)
return fs, result.Error
}
// IgnoreFriendRequest ignores a pending friend request that was sent to targetUserID.
func IgnoreFriendRequest(currentUser *User, fromUser *User) error {
// Is there a reverse friend request pending? (The one we ideally hope to mark Ignored)
rev := &Friend{}
reverse := DB.Where(
"source_user_id = ? AND target_user_id = ?",
fromUser.ID, currentUser.ID,
).First(&rev).Error
// If the reverse exists (requested us) mark it as Ignored.
if reverse == nil {
// Ignore the reverse friend request (happy path).
log.Error("%s ignoring friend request from %s", currentUser.Username, fromUser.Username)
rev.Approved = false
rev.Ignored = true
return rev.Save()
}
log.Error("rev: %+v", rev)
return errors.New("unexpected error while ignoring friend request")
}
// RemoveFriend severs a friend connection both directions, used when
// rejecting a request or removing a friend.
func RemoveFriend(sourceUserID, targetUserID uint64) error {
result := DB.Where(
"(source_user_id = ? AND target_user_id = ?) OR "+
"(target_user_id = ? AND source_user_id = ?)",
sourceUserID, targetUserID,
sourceUserID, targetUserID,
).Delete(&Friend{})
return result.Error
}
// Save photo.
func (f *Friend) Save() error {
result := DB.Save(f)
return result.Error
}
// FriendMap maps user IDs to friendship status for the current user.
type FriendMap map[uint64]bool
// MapFriends looks up a set of user IDs in bulk and returns a FriendMap suitable for templates.
func MapFriends(currentUser *User, users []*User) FriendMap {
var (
usermap = FriendMap{}
set = map[uint64]interface{}{}
distinct = []uint64{}
)
// Uniqueify users.
for _, user := range users {
if _, ok := set[user.ID]; ok {
continue
}
set[user.ID] = nil
distinct = append(distinct, user.ID)
}
var (
matched = []*Friend{}
result = DB.Model(&Friend{}).Where(
"source_user_id = ? AND target_user_id IN ? AND approved = ?",
currentUser.ID, distinct, true,
).Find(&matched)
)
if result.Error == nil {
for _, row := range matched {
usermap[row.TargetUserID] = true
}
}
return usermap
}
// Get a user from the FriendMap.
func (um FriendMap) Get(id uint64) bool {
return um[id]
}