huangguo_server/web/service/chat_message_ser/chat_message.go

package chat_message_ser

import (
	"91porn-server/common"
	"91porn-server/common/log"
	"91porn-server/common/stderr"
	"91porn-server/models/v/messagemod"
	"91porn-server/models/v/sessionmod"
	"91porn-server/models/v/usermod"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"time"
)

func List(req *messagemod.WebListRequest) (interface{}, stderr.Code) {
	var data = map[string]interface{}{
		"list":  []interface{}{},
		"count": 0,
	}
	count, err := messagemod.CountDocument(req.Filter())
	if err != nil {
		return nil, stderr.ErrDbQueryError
	}
	if count == 0 {
		return data, stderr.Success
	}
	list, err := messagemod.QueryAllDocument(req.Filter(), req.Options())
	if err != nil {
		return data, stderr.ErrDbQueryError
	}
	data["count"] = count
	data["list"] = list
	return data, stderr.Success
}

func Del(req *messagemod.WebDelReq) stderr.Code {
	data, err := messagemod.FindOneByFilter(req.Filter())
	if err != nil {
		return stderr.ErrDbQueryError
	}

	if data.ID.IsZero() {
		return stderr.CodeEmptyData
	}

	err = messagemod.RemoveDocument(req.Filter())
	if err != nil {
		return stderr.ErrDbUpdateError
	}
	return stderr.Success
}

// AddPrivateLetter 新增私信消息
func AddPrivateLetter(req *messagemod.SendMsg) stderr.Code {
	if req.Sender == 0 || req.Receiver == 0 {
		return stderr.ErrParamError
	}
	data, err := usermod.FindUserByUID(req.Sender)
	if err != nil || data == nil {
		log.Warn(fmt.Sprintf("messageser Sender is null"), log.Any("Sender", req.Sender))
		return stderr.CommentUserInfoErr
	}

	if req.Sender == req.Receiver {
		log.Warn(fmt.Sprintf("messageser req.Sender == req.Receiver"), log.Any("Sender", req.Sender), log.Any("Receiver", req.Receiver))
		return stderr.NoSelfAddMsg
	}

	//查询被私信的用户是否存在
	takeUser, err := usermod.FindUserByUID(req.Receiver)
	if err != nil {
		return stderr.CommentUserInfoErr
	}
	if takeUser == nil {
		log.Warn(fmt.Sprintf("messageser Receiver is null"), log.Any("Receiver", req.Receiver))
		return stderr.CommentUserInfoErr
	}
	//会话id
	sessionId := ""
	//新增私聊信息之前, 先查询是否有会话信息
	cond := bson.M{"$or": []bson.M{bson.M{"sendUid": req.Sender, "takeUid": req.Receiver}, bson.M{"sendUid": req.Receiver, "takeUid": req.Sender}}}
	session, err := sessionmod.FindOneByFilter(cond)
	if err != nil {
		log.Warn(fmt.Sprintf("messageser Add sessionmod.FindOneByFilter error:%+v:", err), log.Any("Sender", req.Sender), log.Any("Receiver", req.Receiver))
		return stderr.ErrDbQueryError
	}
	t := time.Now()
	if session.ID.IsZero() {
		sessionId = common.UUID()
		//新增session
		s := &sessionmod.Session{
			SendUid:   req.Sender,
			TakeUid:   req.Receiver,
			SessionId: sessionId,
			CreatedAt: t,
			UpdatedAt: t,
		}
		err := sessionmod.InsertOne(nil, s)
		if err != nil {
			log.Warn(fmt.Sprintf("messageser Add sessionmod.InsertOne error:%+v:", err), log.Any("session", s), log.Any("Sender", req.Sender), log.Any("Receiver", req.Receiver))
			return stderr.ErrDbInsertError
		}
	} else {
		sessionId = session.SessionId
	}

	code := PublicAddMsg(messagemod.PublicAddMsg{
		SendUid:   req.Sender,
		TakeUid:   req.Receiver,
		SessionId: sessionId,
		Content:   req.Content,
		//ImgUrl:    req.ImgUrl,// 暂时不支持图片
		MsgType: req.MsgType,
		ObjId:   req.ObjId,
		ObjName: req.ObjName,
	})
	if code != stderr.Success {
		return code
	}
	common.Go(func() {
		//更新会话预览消息
		content := req.Content
		// 暂时不支持图片
		//if len(req.ImgUrl) > 0 && content == "" {
		//	content = "发送了一张图片"
		//}
		err := sessionmod.UpdOneByFilter(nil, bson.M{"sessionId": sessionId}, bson.M{"$set": bson.M{"preContent": content, "updatedAt": t}})
		if err != nil {
			log.Warn(fmt.Sprintf("messageser Add messagemod.UpdOneByFilter error:%+v:", err), log.Any("sessionId", sessionId), log.Any("preContent", req.Content), log.Any("Sender", req.Sender), log.Any("Receiver", req.Receiver))
		}
	})
	return stderr.Success
}

// PublicAddMsg 添加消息公共方法
func PublicAddMsg(prams messagemod.PublicAddMsg) stderr.Code {
	//查询用户信息
	user, err := usermod.FindUserByUID(prams.SendUid)
	if err != nil {
		return stderr.ErrDbQueryError
	}
	if user == nil || user.HasLocked {
		return stderr.UserIsNotExists
	}
	now := time.Now()
	//新增消息
	msg := &messagemod.Message{
		SendUid:   prams.SendUid,
		TakeUid:   prams.TakeUid,
		MsgType:   prams.MsgType,
		Content:   prams.Content,
		ImgUrl:    prams.ImgUrl,
		IsRead:    false,
		CreatedAt: now,
		UpdatedAt: now,
		ObjId:     prams.ObjId,
		ObjName:   prams.ObjName,
	}
	// 是否加入未读提醒
	needTip := false
	switch prams.MsgType {
	case messagemod.PrivateLetterMsg:
		//私信
		msg.SessionId = prams.SessionId
		needTip = true
	case messagemod.OfficialPrivateLetterMsg:
		//官方私信
		msg.SessionId = prams.SessionId
		msg.ContentType = prams.ContentType
		needTip = true
	case messagemod.FollowMsg:
		//关注
		msg.Content = "关注了你"
		needTip = true
	case messagemod.LikeMsg:
		//点赞
		msg.Content = "点赞了你的帖子"
		msg.ObjId = prams.ObjId
		msg.ObjName = prams.ObjName
		needTip = true
	case messagemod.ForwardMsg: //转发
		msg.Content = "转发了你的帖子"
		msg.ObjId = prams.ObjId
		msg.ObjName = prams.ObjName
	case messagemod.CommentMsg: //评论
		msg.Content = "评论了你的帖子"
		msg.ObjId = prams.ObjId
		msg.ObjName = prams.ObjName
		needTip = true
	case messagemod.DesireMsg:
		msg.Content = "回复了你的工单"
		msg.ObjId = prams.ObjId
		msg.ObjName = prams.ObjName
		needTip = true
	case messagemod.LikeCommentMsg: // 点赞评论
		msg.Content = "点赞了你的评论"
		msg.ObjId = prams.ObjId
		msg.ObjName = prams.ObjName
	case messagemod.ReplyCommentMsg: // 回复评论
		msg.Content = "回复了你的评论"
		msg.ObjId = prams.ObjId
		msg.ObjName = prams.ObjName
		needTip = true
	}
	_, err = messagemod.InsertOne(nil, msg)
	if err != nil {
		log.Warn(fmt.Sprintf("messageser Add messagemod.InsertOne error:%+v:", err), log.Any("message", msg))
		return stderr.ErrDbQueryError
	}
	go func() {
		err = usermod.IncDynamic(prams.TakeUid)
	}()
	// 更新提示状态
	if needTip {
		//_ = message.SetTip(prams.TakeUid)
	}

	return stderr.Success
}