IUQT/acquaintances/biz/dal/mysql/user_relations.go

package mysql

import (
	"acquaintances/biz/model"
	"acquaintances/biz/model/user"
	"encoding/json"
	"errors"
	"gorm.io/gorm"
	"time"

	"github.com/cloudwego/hertz/pkg/common/hlog"
)

// 添加好友
func CreateUserRelations(relations user.CreateUserRelationsReq) error {
	// 参数校验
	if relations.UserID == "" || relations.FriendID == "" {
		return errors.New("用户ID和好友ID不能为空")
	}
	if relations.UserID == relations.FriendID {
		return errors.New("不能添加自己为好友")
	}
	var me model.UserRelations
	meFriends, err := getFriend(relations.UserID)
	if err != nil {
		hlog.Error("CreateUserRelations:", err)
		return err
	}
	if meFriends != nil {
		hlog.Info("CreateUserRelations friends exist", meFriends)
		// 检查是否已存在
		for _, friend := range meFriends {
			if friend.FriendID == relations.FriendID {
				return errors.New("已经是好友")
			}
		}
	} else {
		hlog.Info("CreateUserRelations friends not  exist")
		meFriends = make([]*model.Friend, 0)
	}
	// 不存在
	newMeFriends := model.Friend{
		FriendID:   relations.FriendID,
		Remark:     "",
		CreateTime: time.Now().Unix(),
	}
	meFriends = append(meFriends, &newMeFriends)
	me.FriendList, err = json.Marshal(&meFriends)
	if err != nil {
		hlog.Error("CreateUserRelations:", err)
		return err
	}
	me.FriendCount = int64(len(meFriends))

	var you model.UserRelations
	youFriends, err := getFriend(relations.FriendID)
	if err != nil {
		hlog.Error("CreateUserRelations:", err)
		return err
	}

	if youFriends != nil {
		hlog.Info("CreateUserRelations friends exist", meFriends)
		// 检查是否已存在
		for _, friend := range youFriends {
			if friend.FriendID == relations.UserID {
				return errors.New("已经是好友")
			}
		}
	} else {
		hlog.Info("CreateUserRelations friends not  exist")
		youFriends = make([]*model.Friend, 0)
	}

	newYouFriends := &model.Friend{
		FriendID:   relations.UserID,
		Remark:     "",
		CreateTime: time.Now().Unix(),
	}
	youFriends = append(youFriends, newYouFriends)
	you.FriendList, err = json.Marshal(&youFriends)
	if err != nil {
		hlog.Error("CreateUserRelations:", err)
		return err
	}
	you.FriendCount = int64(len(meFriends))
	errTransaction := DB.Transaction(func(tx *gorm.DB) error {
		err := tx.Where("user_id = ?", relations.UserID).Updates(&me).Error
		if err != nil {
			return err
		}
		err = tx.Where("user_id = ?", relations.FriendID).Updates(&you).Error
		if err != nil {
			return err
		}

		return nil
	})
	return errTransaction
}

// 删除好友
func DeleteUserRelations(relations user.DeleteUserRelationsReq) error {
	// 参数校验
	if relations.UserID == "" || relations.FriendID == "" {
		return errors.New("用户ID和好友ID不能为空")
	}
	friends, err := getFriend(relations.UserID)
	if err != nil {
		hlog.Error("DeleteUserRelations:", err)
		return err
	}
	var newFriends []*model.Friend
	for _, friend := range friends {
		if friend.FriendID != relations.FriendID {
			newFriends = append(newFriends, friend)
		}
	}

	maps := make(map[string]interface{})
	maps["friend_count"] = int64(len(newFriends))
	maps["friend_list"], err = json.Marshal(newFriends)
	if err != nil {
		hlog.Error("DeleteUserRelations:", err)
		return err
	}
	del := make(map[string]interface{})
	del["status"] = model.RelationshipBreakdown
	errTransaction := DB.Transaction(func(tx *gorm.DB) error {
		err := tx.Model(&model.UserRelations{}).Where("user_id = ?", relations.UserID).Updates(maps).Error
		if err != nil {
			return err
		}
		err = tx.Model(&model.FriendRelationship{}).Where("(applicant_id = ? and target_user_id = ?) or (applicant_id = ? and target_user_id = ?)", relations.UserID, relations.FriendID, relations.FriendID, relations.UserID).Updates(del).Error
		if err != nil {
			return err
		}
		return nil
	})
	return errTransaction
}

// 更新好友备注
func UpdateUserRelations(relations user.UpdateUserRelationsReq) error {
	// 参数校验
	if relations.UserID == "" || relations.FriendID == "" {
		return errors.New("用户ID和好友ID不能为空")
	}
	if relations.Remark == "" {
		return errors.New("备注信息不能为空")
	}
	db := DB.Model(&model.UserRelations{})
	friends, err := getFriend(relations.UserID)
	if err != nil {
		hlog.Error("UpdateUserRelations:", err)
		return err
	}
	for _, friend := range friends {
		if friend.FriendID == relations.FriendID {
			friend.Remark = relations.Remark
		}
	}
	maps := make(map[string]interface{})
	maps["friend_list"], err = json.Marshal(&friends)
	if err != nil {
		hlog.Error("UpdateUserRelations:", err)
		return err
	}
	return db.Where("user_id = ?", relations.UserID).Updates(maps).Error
}

// 获取好友列表
func GetUserListRelations(relations user.ListUserRelationsReq) (*user.ListUserRelationsRes, error) {
	res := new(user.ListUserRelationsRes)
	friends, err := getFriend(relations.UserID)
	if err != nil {
		hlog.Error("GetUserListRelations:", err)
		return nil, err
	}
	if len(friends) == 0 {
		return res, nil
	}
	var ids []string
	var remark []string
	for _, v := range friends {
		ids = append(ids, v.FriendID)
		remark = append(remark, v.Remark)
	}
	res.Users, err = GetUsersById(ids...)
	if err != nil {
		hlog.Error("GetUserListRelations:", err)
		return nil, err
	}
	for k, v := range res.Users {
		v.Remark = remark[k]
	}
	res.Total = int64(len(friends))
	return res, nil
}

func getFriend(userId string) ([]*model.Friend, error) {
	db := DB.Model(&model.UserRelations{})
	var beforeRes model.UserRelations
	if err := db.Where("user_id = ?", userId).Find(&beforeRes).Error; err != nil {
		hlog.Error("getFriend:", err)
		return nil, err
	}
	if beforeRes.FriendList == nil {
		return nil, nil
	}
	var friends []*model.Friend
	if err := json.Unmarshal(beforeRes.FriendList, &friends); err != nil {
		hlog.Error("getFriend:", err)
		return nil, err
	}
	return friends, nil
}