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] }