Passport/pkg/internal/services/relationships.go

160 lines
4.5 KiB
Go
Raw Normal View History

package services
import (
"errors"
"fmt"
"git.solsynth.dev/hydrogen/passport/pkg/internal/database"
"git.solsynth.dev/hydrogen/passport/pkg/internal/models"
2024-07-23 15:50:05 +00:00
"github.com/samber/lo"
"gorm.io/gorm"
)
func ListAllRelationship(user models.Account) ([]models.AccountRelationship, error) {
var relationships []models.AccountRelationship
if err := database.C.
Where("account_id = ?", user.ID).
Preload("Account").
Preload("Related").
Find(&relationships).Error; err != nil {
return relationships, err
}
return relationships, nil
}
func ListRelationshipWithFilter(user models.Account, status models.RelationshipStatus) ([]models.AccountRelationship, error) {
var relationships []models.AccountRelationship
if err := database.C.
Where("account_id = ? AND status = ?", user.ID, status).
Preload("Account").
Preload("Related").
Find(&relationships).Error; err != nil {
return relationships, err
}
return relationships, nil
}
func GetRelationship(otherId uint) (models.AccountRelationship, error) {
var relationship models.AccountRelationship
if err := database.C.
Where(&models.AccountRelationship{AccountID: otherId}).
Preload("Account").
Preload("Related").
First(&relationship).Error; err != nil {
return relationship, err
}
return relationship, nil
}
func GetRelationWithTwoNode(userId, relatedId uint, noPreload ...bool) (models.AccountRelationship, error) {
var tx *gorm.DB
if len(noPreload) > 0 && noPreload[0] {
tx = database.C
} else {
tx = database.C.Preload("Account").Preload("Related")
}
var relationship models.AccountRelationship
if err := tx.
Where(&models.AccountRelationship{AccountID: userId, RelatedID: relatedId}).
First(&relationship).Error; err != nil {
return relationship, err
}
return relationship, nil
}
2024-07-23 15:50:05 +00:00
func EditRelationship(relationship models.AccountRelationship) (models.AccountRelationship, error) {
if err := database.C.Save(&relationship).Error; err != nil {
return relationship, err
}
return relationship, nil
}
func DeleteRelationship(relationship models.AccountRelationship) error {
if err := database.C.Delete(&relationship).Error; err != nil {
return err
}
return nil
}
func NewFriend(userA models.Account, userB models.Account, skipPending ...bool) (models.AccountRelationship, error) {
relA := models.AccountRelationship{
AccountID: userA.ID,
RelatedID: userB.ID,
2024-07-23 15:50:05 +00:00
Status: models.RelationshipWaiting,
}
relB := models.AccountRelationship{
AccountID: userB.ID,
RelatedID: userA.ID,
Status: models.RelationshipPending,
}
if len(skipPending) > 0 && skipPending[0] {
2024-07-23 15:50:05 +00:00
relA.Status = models.RelationshipFriend
relB.Status = models.RelationshipFriend
}
if userA.ID == userB.ID {
2024-07-23 15:50:05 +00:00
return relA, fmt.Errorf("unable to make relationship with yourself")
} else if _, err := GetRelationWithTwoNode(userA.ID, userB.ID, true); err == nil || !errors.Is(err, gorm.ErrRecordNotFound) {
2024-07-23 15:50:05 +00:00
return relA, fmt.Errorf("unable to recreate a relationship with that user")
}
if err := database.C.Save(&relA).Error; err != nil {
return relA, err
} else if err = database.C.Save(&relB).Error; err != nil {
return relA, err
} else {
_ = NewNotification(models.Notification{
2024-07-23 15:50:05 +00:00
Title: "New Friend Request",
Subtitle: lo.ToPtr(fmt.Sprintf("New friend request from %s", userA.Name)),
Body: fmt.Sprintf("You got a new friend request from %s. Go to your account page and decide how to deal it.", userA.Nick),
2024-09-17 06:50:05 +00:00
Account: userB,
2024-07-15 16:05:09 +00:00
AccountID: userB.ID,
})
}
return relA, nil
}
2024-07-23 15:50:05 +00:00
func HandleFriend(userA models.Account, userB models.Account, isAccept bool) error {
relA, err := GetRelationWithTwoNode(userA.ID, userB.ID, true)
if err != nil {
return fmt.Errorf("relationship was not found: %v", err)
} else if relA.Status != models.RelationshipPending {
return fmt.Errorf("relationship already handled")
}
2024-07-23 15:50:05 +00:00
if isAccept {
relA.Status = models.RelationshipFriend
} else {
relA.Status = models.RelationshipBlocked
}
if err := database.C.Save(&relA).Error; err != nil {
return err
}
2024-07-23 15:50:05 +00:00
relB, err := GetRelationWithTwoNode(userB.ID, userA.ID, true)
if err == nil && relB.Status == models.RelationshipWaiting {
relB.Status = models.RelationshipFriend
if err := database.C.Save(&relB).Error; err != nil {
return err
}
_ = NewNotification(models.Notification{
Title: "Friend Request Processed",
Subtitle: lo.ToPtr(fmt.Sprintf("Your friend request to %s has been processsed.", userA.Name)),
Body: fmt.Sprintf("Your relationship status with %s has been updated, go check it out!", userA.Nick),
2024-09-17 06:50:05 +00:00
Account: userB,
2024-07-23 15:50:05 +00:00
AccountID: userB.ID,
})
}
return nil
}