789 lines
24 KiB
Go
789 lines
24 KiB
Go
package event
|
||
|
||
import (
|
||
"fmt"
|
||
"regexp"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"git.rosy.net.cn/jx-callback/business/jxstore/financial"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
|
||
"git.rosy.net.cn/jx-callback/business/model"
|
||
"git.rosy.net.cn/jx-callback/business/model/dao"
|
||
"git.rosy.net.cn/jx-callback/globals"
|
||
"github.com/gorilla/websocket"
|
||
)
|
||
|
||
var (
|
||
NoUseEventMap = map[string]string{
|
||
"CreateQrOrBarCode": "CreateQrOrBarCode",
|
||
"StatisticsReportForOrders": "StatisticsReportForOrders",
|
||
"UpdateUser": "UpdateUser",
|
||
}
|
||
regexpToken = regexp.MustCompile(`,"token":".*"`)
|
||
wsClient = &WSClient{}
|
||
//广播频道(通道)
|
||
broadcast = make(chan *model.ImMessageRecord)
|
||
)
|
||
|
||
const (
|
||
sysMessageTitle = ""
|
||
)
|
||
|
||
//连接的客户端,吧每个客户端都放进来
|
||
type WSClient struct {
|
||
Clients map[int]map[string]*websocket.Conn
|
||
ClientsHeart map[string]*websocket.Conn
|
||
s *sync.RWMutex
|
||
}
|
||
|
||
func init() {
|
||
clients := make(map[int]map[string]*websocket.Conn)
|
||
clientsHeart := make(map[string]*websocket.Conn)
|
||
wsClient.Clients = clients
|
||
wsClient.ClientsHeart = clientsHeart
|
||
wsClient.s = new(sync.RWMutex)
|
||
go handleMessages()
|
||
}
|
||
|
||
//广播推送消息
|
||
func handleMessages() {
|
||
for {
|
||
//读取通道中的消息
|
||
msg := <-broadcast
|
||
if msg.GroupID == 0 {
|
||
// globals.SugarLogger.Debugf("heart %v", utils.Format4Output(msg, false))
|
||
if wsClient.ClientsHeart[msg.UserID] != nil {
|
||
if err := wsClient.ClientsHeart[msg.UserID].WriteJSON(&model.ImMessageRecord{
|
||
Key: "pang",
|
||
}); err != nil {
|
||
globals.SugarLogger.Debugf("heart client.WriteJSON error: %v", err)
|
||
wsClient.ClientsHeart[msg.UserID].Close() //关闭
|
||
delete(wsClient.ClientsHeart, msg.UserID)
|
||
}
|
||
}
|
||
} else {
|
||
globals.SugarLogger.Debugf("clients len %v", len(wsClient.Clients))
|
||
//循环map客户端
|
||
for userID, client := range wsClient.Clients[msg.GroupID] {
|
||
//把通道中的消息发送给客户端
|
||
user, err := dao.GetUser(dao.GetDB(), msg.UserID)
|
||
if err == nil {
|
||
msg.UserInfo = user
|
||
}
|
||
globals.SugarLogger.Debugf("msg %v", utils.Format4Output(msg, false))
|
||
if msg.CreatedAt == utils.ZeroTimeValue {
|
||
msg.CreatedAt = time.Now()
|
||
}
|
||
err = client.WriteJSON(msg)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("client.WriteJSON error: %v", err)
|
||
client.Close() //关闭
|
||
delete(wsClient.Clients[msg.GroupID], userID)
|
||
// delete(clients, client) //删除map中的客户端
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func ImMessage(userID string, ws *websocket.Conn) (err error) {
|
||
var (
|
||
clientUser = make(map[string]*websocket.Conn)
|
||
db = dao.GetDB()
|
||
)
|
||
//将当前客户端放入map中
|
||
messageGroups, _ := dao.GetUserMessageGroups(dao.GetDB(), userID)
|
||
if len(messageGroups) == 0 {
|
||
return
|
||
}
|
||
wsClient.s.Lock()
|
||
clientUser[userID] = ws
|
||
wsClient.ClientsHeart[userID] = ws
|
||
for _, v := range messageGroups {
|
||
if len(wsClient.Clients[v.GroupID]) > 0 {
|
||
wsClient.Clients[v.GroupID][userID] = ws
|
||
} else {
|
||
wsClient.Clients[v.GroupID] = clientUser
|
||
}
|
||
}
|
||
wsClient.s.Unlock()
|
||
globals.SugarLogger.Debugf("userID :%v ,clients :%v", userID, utils.Format4Output(wsClient.Clients, false))
|
||
|
||
var s *model.ImMessageRecord
|
||
for {
|
||
//接收客户端的消息
|
||
err := ws.ReadJSON(&s)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("页面可能断开啦 ws.ReadJSON error: %v", err.Error())
|
||
for k, _ := range wsClient.Clients {
|
||
delete(wsClient.Clients[k], userID)
|
||
}
|
||
delete(wsClient.ClientsHeart, userID)
|
||
// delete(clients, ws) //删除map中的客户端
|
||
break //结束循环
|
||
} else {
|
||
//接受消息 业务逻辑
|
||
broadcast <- s
|
||
if s.GroupID != 0 {
|
||
if s.GroupID != model.SysGroupID {
|
||
//发聊天消息时，这个组所有的成员包括创建者都在userIDs里
|
||
userIDs := []string{}
|
||
if results, err := dao.GetMessageGroups(db, "", s.GroupID, 0, true, ""); err == nil {
|
||
for _, v := range results {
|
||
userIDs = append(userIDs, v.UserID)
|
||
for _, vv := range v.MessageGroupMembers {
|
||
userIDs = append(userIDs, vv.UserID)
|
||
}
|
||
}
|
||
}
|
||
//如果这些人不在这个组的ws池子里就打上未读标记
|
||
for _, v := range userIDs {
|
||
if wsClient.ClientsHeart[v] == nil {
|
||
messageGroupReads, _ := dao.GetMessageGroupRead(db, v, s.GroupID)
|
||
for _, vv := range messageGroupReads {
|
||
vv.UnReadCount++
|
||
dao.UpdateEntity(db, vv, "UnReadCount")
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if wsClient.ClientsHeart[s.ToUserID] == nil {
|
||
messageGroupReads, _ := dao.GetMessageGroupRead(db, s.ToUserID, s.GroupID)
|
||
for _, vv := range messageGroupReads {
|
||
vv.UnReadCount++
|
||
dao.UpdateEntity(db, vv, "UnReadCount")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
utils.CallFuncAsync(func() {
|
||
if s.GroupID != 0 {
|
||
dao.WrapAddIDCULDEntity(s, "")
|
||
dao.CreateEntity(db, s)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
ws.Close()
|
||
return err
|
||
}
|
||
|
||
func GetOnlineUserCount() (count int) {
|
||
wsClient.s.RLock()
|
||
count = len(wsClient.ClientsHeart)
|
||
wsClient.s.RUnlock()
|
||
return count
|
||
}
|
||
|
||
func AddOperateEvent(ctx *jxcontext.Context, accessUUID, jsonData string, errCode, errMsg string, useTime int, apiFunctionSpec string) (err error) {
|
||
var (
|
||
apiFunction string
|
||
db = dao.GetDB()
|
||
)
|
||
// if ctx.GetRequest() == nil {
|
||
// return nil
|
||
// }
|
||
if apiFunctionSpec == "" {
|
||
url := ctx.GetRequest().URL.Path
|
||
if url != "" {
|
||
apiFunction = url[strings.LastIndex(url, "/")+1 : len(url)]
|
||
}
|
||
} else {
|
||
apiFunction = apiFunctionSpec
|
||
}
|
||
if apiFunction != "" {
|
||
if apiFunction[0:3] == "Get" || NoUseEventMap[apiFunction] != "" {
|
||
return err
|
||
}
|
||
}
|
||
if accessUUID != "" {
|
||
accessUUID = accessUUID[0:strings.Index(accessUUID, ",")]
|
||
}
|
||
jsonData = strings.ReplaceAll(jsonData, regexpToken.FindString(jsonData), "")
|
||
jsonData = utils.LimitUTF8StringLen(jsonData, 3200)
|
||
errMsg = utils.LimitUTF8StringLen(errMsg, 9999)
|
||
event := &model.OperateEvent{
|
||
CreatedAt: time.Now(),
|
||
LastOperator: ctx.GetUserName(),
|
||
APIFunction: apiFunction,
|
||
UserID: ctx.GetUserID(),
|
||
AccessUUID: accessUUID,
|
||
JsonData: jsonData,
|
||
ErrCode: errCode,
|
||
ErrMsg: errMsg,
|
||
UseTime: useTime,
|
||
}
|
||
txDB, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, txDB)
|
||
panic(r)
|
||
}
|
||
}()
|
||
err = dao.CreateEntity(db, event)
|
||
dao.Commit(db, txDB)
|
||
return err
|
||
}
|
||
|
||
func AddOperateEventDetail(db *dao.DaoDB, operateEventDetail *model.OperateEventDetail) (err error) {
|
||
txDB, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, txDB)
|
||
panic(r)
|
||
}
|
||
}()
|
||
operateEventDetail.BeforeData = utils.LimitUTF8StringLen(operateEventDetail.BeforeData, 3200)
|
||
operateEventDetail.AfterData = utils.LimitUTF8StringLen(operateEventDetail.AfterData, 3200)
|
||
err = dao.CreateEntity(db, operateEventDetail)
|
||
dao.Commit(db, txDB)
|
||
return err
|
||
}
|
||
|
||
func DeleteOperateEventAndDetail(ctx *jxcontext.Context, deleteTime time.Time) (err error) {
|
||
db := dao.GetDB()
|
||
txDB, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, txDB)
|
||
panic(r)
|
||
}
|
||
}()
|
||
dao.DeleteOperateEventDetail(db, deleteTime)
|
||
dao.DeleteOperateEvent(db, deleteTime)
|
||
dao.Commit(db, txDB)
|
||
return err
|
||
}
|
||
|
||
func GetOperateEvents(ctx *jxcontext.Context, name string, apiFunctions []string, operateTypes, skuIDs, storeIDs []int, fromTime, toTime, keyword string, errType, offset, pageSize int) (pageInfo *model.PagedInfo, err error) {
|
||
var (
|
||
fromTimeP time.Time
|
||
toTimeP time.Time
|
||
)
|
||
db := dao.GetDB()
|
||
if fromTime != "" {
|
||
fromTimeP = utils.Str2Time(fromTime)
|
||
}
|
||
if toTime != "" {
|
||
toTimeP = utils.Str2Time(toTime)
|
||
}
|
||
pageSize = jxutils.FormalizePageSize(pageSize)
|
||
offset = jxutils.FormalizePageOffset(offset)
|
||
operateEventExt, totalCount, err := dao.GetOperateEvents(db, name, apiFunctions, operateTypes, skuIDs, storeIDs, fromTimeP, toTimeP, keyword, errType, offset, pageSize)
|
||
if err != nil {
|
||
return pageInfo, err
|
||
}
|
||
pageInfo = &model.PagedInfo{
|
||
Data: operateEventExt,
|
||
TotalCount: totalCount,
|
||
}
|
||
return pageInfo, err
|
||
}
|
||
|
||
func CreateMessageGroup(ctx *jxcontext.Context, userID, userID2, groupName string, dividePercentage, quitPrice int) (messageGroupResult *dao.GetMessageGroupsResult, err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
groupID int
|
||
)
|
||
for {
|
||
groupID = jxutils.GenRand6()
|
||
temp := &model.MessageGroup{
|
||
GroupID: groupID,
|
||
}
|
||
dao.GetEntity(db, temp, "GroupID")
|
||
if temp.UserID == "" {
|
||
break
|
||
}
|
||
}
|
||
if userID2 != "" {
|
||
messageGroups, err := dao.GetMessageGroups(db, userID, 0, model.GroupTypeSingle, true, userID2)
|
||
if len(messageGroups) > 0 && len(messageGroups[0].MessageGroupMembers) > 0 {
|
||
return messageGroups[0], err
|
||
}
|
||
user, err := dao.GetUserByID(db, "user_id", userID2)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if user == nil {
|
||
return nil, fmt.Errorf("无法找到要联系的用户！")
|
||
}
|
||
messageGroup := &model.MessageGroup{
|
||
GroupID: groupID,
|
||
UserID: userID,
|
||
// Name: user.Name,
|
||
Type: model.GroupTypeSingle,
|
||
MaxCount: 2,
|
||
}
|
||
messageGroupMember := &model.MessageGroupMember{
|
||
GroupID: groupID,
|
||
MemberUserID: userID2,
|
||
Type: model.GroupMemberTypeNormal,
|
||
}
|
||
dao.WrapAddIDCULDEntity(messageGroup, ctx.GetUserName())
|
||
dao.WrapAddIDCULDEntity(messageGroupMember, ctx.GetUserName())
|
||
err = dao.CreateEntity(db, messageGroup)
|
||
err = dao.CreateEntity(db, messageGroupMember)
|
||
if err == nil {
|
||
messageGroupRead := &model.MessageGroupRead{
|
||
GroupID: groupID,
|
||
UserID: userID,
|
||
}
|
||
dao.WrapAddIDCULEntity(messageGroupRead, ctx.GetUserName())
|
||
messageGroupRead2 := messageGroupRead
|
||
messageGroupRead2.UserID = userID2
|
||
dao.CreateEntity(db, messageGroupRead)
|
||
if err = dao.CreateEntity(db, messageGroupRead2); err == nil {
|
||
if messageGroupReads, err := dao.GetMessageGroupRead(db, userID2, model.SysGroupID); len(messageGroupReads) == 0 && err == nil {
|
||
messageGroupRead := &model.MessageGroupRead{
|
||
GroupID: model.SysGroupID,
|
||
UserID: userID2,
|
||
}
|
||
dao.WrapAddIDCULEntity(messageGroupRead, ctx.GetUserName())
|
||
dao.CreateEntity(db, messageGroupRead)
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
userMembers, err := dao.GetUserMember(db, userID, model.MemberTypeNormal)
|
||
messageGroupsResult, err := dao.GetMessageGroups(db, userID, 0, model.GroupTypeMulit, false, "")
|
||
messageGroupMembers, err := dao.GetMessageGroupMembers(db, 0, model.GroupTypeMulit, userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if len(userMembers) == 0 {
|
||
return nil, fmt.Errorf("抱歉，只有会员才能创建群聊！")
|
||
}
|
||
if len(messageGroupsResult) > 0 {
|
||
return nil, fmt.Errorf("您已经有群组了，请勿重复创建！群号为：%d", messageGroupsResult[0].GroupID)
|
||
}
|
||
if len(messageGroupMembers) > 0 {
|
||
return nil, fmt.Errorf("您已加入了[%v]群，请先退出后再创建！", messageGroupMembers[0].GroupID)
|
||
}
|
||
messageGroup := &model.MessageGroup{
|
||
GroupID: groupID,
|
||
UserID: userID,
|
||
Name: groupName,
|
||
Type: model.GroupTypeMulit,
|
||
MaxCount: 2000,
|
||
DividePercentage: dividePercentage,
|
||
QuitPrice: quitPrice,
|
||
}
|
||
user, err := dao.GetUserByID(db, "user_id", userID)
|
||
if groupName == "" {
|
||
messageGroup.Name = user.Name + "的集团"
|
||
}
|
||
dao.WrapAddIDCULDEntity(messageGroup, ctx.GetUserName())
|
||
if err = dao.CreateEntity(db, messageGroup); err == nil {
|
||
messageGroupRead := &model.MessageGroupRead{
|
||
GroupID: groupID,
|
||
UserID: userID,
|
||
}
|
||
dao.WrapAddIDCULEntity(messageGroupRead, ctx.GetUserName())
|
||
dao.CreateEntity(db, messageGroupRead)
|
||
}
|
||
}
|
||
if err == nil {
|
||
if messageGroupReads, err := dao.GetMessageGroupRead(db, userID, model.SysGroupID); len(messageGroupReads) == 0 && err == nil {
|
||
messageGroupRead := &model.MessageGroupRead{
|
||
GroupID: model.SysGroupID,
|
||
UserID: userID,
|
||
}
|
||
dao.WrapAddIDCULEntity(messageGroupRead, ctx.GetUserName())
|
||
dao.CreateEntity(db, messageGroupRead)
|
||
}
|
||
}
|
||
return messageGroupResult, err
|
||
}
|
||
|
||
func GetMessageGroupByUser(ctx *jxcontext.Context, userID string) (messageGroupResult []*dao.GetMessageGroupsResult, err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
)
|
||
messageGroups, err := dao.GetMessageGroups(db, "", model.SysGroupID, 0, false, "")
|
||
messageGroups2, err := dao.GetMessageGroups(db, userID, 0, 0, true, "")
|
||
messageGroups = append(messageGroups, messageGroups2...)
|
||
messageGroupMembers, err := dao.GetMessageGroupMembers(db, 0, 0, userID)
|
||
for _, v := range messageGroupMembers {
|
||
if messageGroupList, err := dao.GetMessageGroups(db, "", v.GroupID, 0, false, ""); err == nil {
|
||
messageGroups = append(messageGroups, messageGroupList...)
|
||
}
|
||
}
|
||
for _, v := range messageGroups {
|
||
//是这个人创建的群聊，如果是单聊就返回对方的头像
|
||
if v.Type == model.GroupTypeSingle {
|
||
var userID2 string
|
||
if v.UserID == userID {
|
||
userID2 = v.MessageGroupMembers[0].MemberUserID
|
||
} else {
|
||
userID2 = userID
|
||
}
|
||
if user, err := dao.GetUserByID(db, "user_id", userID2); err == nil {
|
||
v.Avatar = user.Avatar
|
||
v.Name = user.Name
|
||
}
|
||
}
|
||
var (
|
||
imMessageRecord *model.ImMessageRecord
|
||
sql string
|
||
sqlParams = []interface{}{}
|
||
)
|
||
if v.GroupID != model.SysGroupID {
|
||
//最后一条记录和时间和人
|
||
sql = `
|
||
SELECT * FROM im_message_record WHERE group_id = ? ORDER BY created_at DESC LIMIT 1
|
||
`
|
||
sqlParams = append(sqlParams, v.GroupID)
|
||
} else {
|
||
//最后一条记录和时间和人
|
||
sql = `
|
||
SELECT * FROM im_message_record WHERE group_id = ? AND to_user_id = ? ORDER BY created_at DESC LIMIT 1
|
||
`
|
||
sqlParams = append(sqlParams, v.GroupID, userID)
|
||
}
|
||
if err = dao.GetRow(db, &imMessageRecord, sql, sqlParams); err == nil {
|
||
v.LastTime = imMessageRecord.CreatedAt
|
||
v.LastContent = imMessageRecord.Content
|
||
v.LastMessageType = imMessageRecord.MessageType
|
||
if user3, err := dao.GetUserByID(db, "user_id", imMessageRecord.UserID); err == nil {
|
||
v.LastUserName = user3.Name
|
||
}
|
||
} else {
|
||
err = nil
|
||
}
|
||
//该用户各组的未读消息数
|
||
var unReadCount int
|
||
if messageGroupReads, err := dao.GetMessageGroupRead(db, userID, v.GroupID); err == nil && len(messageGroupReads) > 0 {
|
||
for _, vv := range messageGroupReads {
|
||
unReadCount += vv.UnReadCount
|
||
}
|
||
}
|
||
v.UnReadMessageCount = unReadCount
|
||
}
|
||
return messageGroups, err
|
||
}
|
||
|
||
func AddMessageGroup(ctx *jxcontext.Context, groupID int, userID string) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
)
|
||
messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, 0, userID)
|
||
messageGroupMembers3, err := dao.GetMessageGroupMembers(db, 0, 0, userID)
|
||
messageGroupsResult, err := dao.GetMessageGroups(db, userID, groupID, model.GroupTypeMulit, false, "")
|
||
messageGroupsResult2, err := dao.GetMessageGroups(db, "", groupID, model.GroupTypeMulit, false, "")
|
||
//messageGroupsResult3, err := dao.GetMessageGroups(db, userID, 0, model.GroupTypeMulit, false, "")
|
||
messageGroupMembers2, err := dao.GetMessageGroupMembers(db, groupID, 0, "")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if len(messageGroupMembers) > 0 {
|
||
return fmt.Errorf("此用户已经在该群组中了！")
|
||
}
|
||
//if len(messageGroupMembers3) > 0 {
|
||
// return fmt.Errorf("您已经有群组[%v]了，不能申请加入其它群！", messageGroupMembers3[0].GroupID)
|
||
//}
|
||
if len(messageGroupsResult) > 0 {
|
||
return fmt.Errorf("请不要加入自己创建的群！")
|
||
}
|
||
if len(messageGroupsResult2) > 0 && len(messageGroupMembers2) > 0 {
|
||
if len(messageGroupMembers2)+1 > messageGroupsResult2[0].MaxCount {
|
||
return fmt.Errorf("抱歉该群组已经满员了！")
|
||
}
|
||
}
|
||
//if len(messageGroupsResult3) > 0 {
|
||
// return fmt.Errorf("您已经拥有[%v]群了，不能再加入其它群！", messageGroupsResult3[0].GroupID)
|
||
//}
|
||
|
||
messageGroupMember := &model.MessageGroupMember{
|
||
GroupID: groupID,
|
||
MemberUserID: userID,
|
||
Type: model.GroupMemberTypeNormal,
|
||
}
|
||
dao.WrapAddIDCULDEntity(messageGroupMember, ctx.GetUserName())
|
||
if err = dao.CreateEntity(db, messageGroupMember); err == nil {
|
||
messageGroupRead := &model.MessageGroupRead{
|
||
GroupID: groupID,
|
||
UserID: userID,
|
||
}
|
||
dao.WrapAddIDCULEntity(messageGroupRead, ctx.GetUserName())
|
||
if err = dao.CreateEntity(db, messageGroupRead); err == nil {
|
||
if messageGroupReads, err := dao.GetMessageGroupRead(db, userID, model.SysGroupID); len(messageGroupReads) == 0 && err == nil {
|
||
messageGroupRead := &model.MessageGroupRead{
|
||
GroupID: model.SysGroupID,
|
||
UserID: userID,
|
||
}
|
||
dao.WrapAddIDCULEntity(messageGroupRead, ctx.GetUserName())
|
||
dao.CreateEntity(db, messageGroupRead)
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func UpdateMessageGroup(ctx *jxcontext.Context, groupID int, payload map[string]interface{}) (num int64, err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
messageGroup = &model.MessageGroup{
|
||
GroupID: groupID,
|
||
}
|
||
)
|
||
if err = dao.GetEntity(db, messageGroup, "GroupID"); err != nil {
|
||
return 0, err
|
||
}
|
||
if messageGroup.UserID != ctx.GetUserID() {
|
||
return 0, fmt.Errorf("只有群主才能修改群信息！")
|
||
}
|
||
valid := dao.StrictMakeMapByStructObject(payload, messageGroup, ctx.GetUserName())
|
||
if len(valid) > 0 {
|
||
txDB, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, txDB)
|
||
panic(r)
|
||
}
|
||
}()
|
||
if num, err = dao.UpdateEntityLogically(db, messageGroup, valid, ctx.GetUserName(), nil); err != nil {
|
||
dao.Rollback(db, txDB)
|
||
return 0, err
|
||
}
|
||
dao.Commit(db, txDB)
|
||
}
|
||
return num, err
|
||
}
|
||
|
||
func DeleteMessageGroup(ctx *jxcontext.Context, groupID int, userID string, flag bool) (errCode string, err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
messageGroup = &model.MessageGroup{
|
||
GroupID: groupID,
|
||
}
|
||
)
|
||
if err = dao.GetEntity(db, messageGroup, "GroupID"); err != nil {
|
||
return errCode, err
|
||
}
|
||
//解散群
|
||
if flag {
|
||
if messageGroup.UserID != ctx.GetUserID() {
|
||
return errCode, fmt.Errorf("只有群主才能解散群！")
|
||
}
|
||
messageGroup.DeletedAt = time.Now()
|
||
messageGroup.LastOperator = ctx.GetUserName()
|
||
dao.UpdateEntity(db, messageGroup, "DeletedAt", "LastOperator")
|
||
messageGroupMembers, _ := dao.GetMessageGroupMembers(db, groupID, 0, "")
|
||
for _, v := range messageGroupMembers {
|
||
v.DeletedAt = time.Now()
|
||
v.LastOperator = ctx.GetUserName()
|
||
dao.UpdateEntity(db, v, "DeletedAt", "LastOperator")
|
||
}
|
||
} else {
|
||
//token中用户与传入user不一致就判定为踢人
|
||
if ctx.GetUserID() != userID {
|
||
if messageGroup.UserID != ctx.GetUserID() {
|
||
messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, 0, ctx.GetUserID())
|
||
if err != nil {
|
||
return errCode, err
|
||
}
|
||
if messageGroupMembers[0].Type == model.GroupMemberTypeNormal {
|
||
return errCode, fmt.Errorf("只有创建者和管理员才能踢人！")
|
||
}
|
||
}
|
||
} else {
|
||
quitPrice := messageGroup.QuitPrice
|
||
userBill, err := dao.GetUserBill(db, userID, "")
|
||
userBillGroupMaster, err := dao.GetUserBill(db, messageGroup.UserID, "")
|
||
if err != nil {
|
||
return errCode, err
|
||
}
|
||
if userBill.AccountBalance < quitPrice {
|
||
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("用户余额不足，请充值！")
|
||
}
|
||
txDB, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, txDB)
|
||
panic(r)
|
||
}
|
||
}()
|
||
//账户支出
|
||
if err = financial.AddExpendUpdateAccount(txDB, userBill, model.BillTypeQuitGroup, quitPrice, 0); err != nil {
|
||
dao.Rollback(db, txDB)
|
||
return errCode, err
|
||
}
|
||
//群主收到退团金额
|
||
if err = financial.AddIncomeUpdateAccount(txDB, userBillGroupMaster, model.BillTypeQuitGroup, quitPrice, 0); err != nil {
|
||
dao.Rollback(db, txDB)
|
||
return errCode, err
|
||
}
|
||
dao.Commit(db, txDB)
|
||
}
|
||
messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, 0, userID)
|
||
if err != nil {
|
||
return errCode, err
|
||
}
|
||
messageGroupMembers[0].DeletedAt = time.Now()
|
||
messageGroupMembers[0].LastOperator = ctx.GetUserName()
|
||
dao.UpdateEntity(db, messageGroupMembers[0], "DeletedAt", "LastOperator")
|
||
}
|
||
return errCode, err
|
||
}
|
||
|
||
func TransferMessageGroupMaster(ctx *jxcontext.Context, groupID int, userID string) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
messageGroup = &model.MessageGroup{
|
||
GroupID: groupID,
|
||
}
|
||
)
|
||
if err = dao.GetEntity(db, messageGroup, "GroupID"); err != nil {
|
||
return err
|
||
}
|
||
if messageGroup.UserID != ctx.GetUserID() {
|
||
return fmt.Errorf("只有群主才能转让群主！")
|
||
}
|
||
//群主换成选的那个人
|
||
messageGroup.UserID = userID
|
||
messageGroup.LastOperator = ctx.GetUserName()
|
||
//之前那个群成员换成之前的群主
|
||
messageGroupMembers, err := dao.GetMessageGroupMembers(db, groupID, 0, userID)
|
||
if err != nil && len(messageGroupMembers) == 0 {
|
||
return err
|
||
}
|
||
messageGroupMember := messageGroupMembers[0]
|
||
messageGroupMember.MemberUserID = ctx.GetUserID()
|
||
messageGroupMember.LastOperator = ctx.GetUserName()
|
||
txDB, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, txDB)
|
||
panic(r)
|
||
}
|
||
}()
|
||
if _, err = dao.UpdateEntity(db, messageGroup, "UserID", "LastOperator"); err != nil {
|
||
dao.Rollback(db, txDB)
|
||
return err
|
||
}
|
||
if _, err = dao.UpdateEntity(db, messageGroupMember, "MemberUserID", "LastOperator"); err != nil {
|
||
dao.Rollback(db, txDB)
|
||
return err
|
||
}
|
||
dao.Commit(db, txDB)
|
||
return err
|
||
}
|
||
|
||
func SendSysMessageSimple(content, toUserID string) (err error) {
|
||
return SendSysMessage(jxcontext.AdminCtx, &model.ImMessageRecord{
|
||
Content: sysMessageTitle + " " + content,
|
||
ToUserID: toUserID,
|
||
GroupID: model.SysGroupID,
|
||
MessageType: 1, // 普通文字消息
|
||
})
|
||
}
|
||
|
||
func SendSysMessage(ctx *jxcontext.Context, imMessageRecord *model.ImMessageRecord) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
userID = imMessageRecord.ToUserID
|
||
groupID = imMessageRecord.GroupID
|
||
)
|
||
if groupID != model.SysGroupID {
|
||
return fmt.Errorf("只能给系统组发消息！")
|
||
}
|
||
imMessageRecord.CreatedAt = time.Now()
|
||
imMessageRecord.LastOperator = ctx.GetUserName()
|
||
imMessageRecord.DeletedAt = utils.DefaultTimeValue
|
||
imMessageRecord.UpdatedAt = utils.DefaultTimeValue
|
||
imMessageRecord.Seq = time.Now().Unix()
|
||
err = dao.CreateEntity(db, imMessageRecord)
|
||
if userID == "" {
|
||
//循环map客户端
|
||
for _, client := range wsClient.Clients[groupID] {
|
||
globals.SugarLogger.Debugf("msg %v", utils.Format4Output(imMessageRecord, false))
|
||
err = client.WriteJSON(imMessageRecord)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("client.WriteJSON error: %v", err)
|
||
client.Close() //关闭
|
||
// delete(wsClient.Clients[msg.GroupID], userID)
|
||
}
|
||
}
|
||
} else {
|
||
client := wsClient.Clients[groupID][userID]
|
||
globals.SugarLogger.Debugf("msg %v", utils.Format4Output(imMessageRecord, false))
|
||
if client == nil {
|
||
return
|
||
}
|
||
err = client.WriteJSON(imMessageRecord)
|
||
if err != nil {
|
||
globals.SugarLogger.Debugf("client.WriteJSON error: %v", err)
|
||
client.Close() //关闭
|
||
// delete(wsClient.Clients[msg.GroupID], userID)
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func DeleteMessageRecord(ctx *jxcontext.Context) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
)
|
||
sql := `
|
||
DELETE FROM im_message_record WHERE created_at < ? AND group_id <> ?
|
||
`
|
||
sqlParams := []interface{}{
|
||
time.Now().AddDate(0, 0, -3), model.SysGroupID,
|
||
}
|
||
_, err = dao.ExecuteSQL(db, sql, sqlParams)
|
||
return err
|
||
}
|
||
|
||
func UpdateUserMessageGroupRead(ctx *jxcontext.Context, reads []*model.MessageGroupRead) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
userID = ctx.GetUserID()
|
||
)
|
||
for _, v := range reads {
|
||
if messageReads, err := dao.GetMessageGroupRead(db, userID, v.GroupID); err == nil {
|
||
if len(messageReads) > 0 {
|
||
messageReads[0].UnReadCount += v.UnReadCount
|
||
dao.UpdateEntity(db, messageReads[0], "UnReadCount")
|
||
} else {
|
||
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
type GetUserStatisticsResult struct {
|
||
RegisterUserCount int `json:"registerUserCount"` //注册数
|
||
OnlineUserCount int `json:"onlineUserCount"` //在线用户数
|
||
ConsumeUserCount int `json:"consumeUserCount"` //消费用户数
|
||
MemberUserCount int `json:"memberUserCount"` //会员用户数
|
||
}
|
||
|
||
func GetUserStatistics(ctx *jxcontext.Context) (getUserStatisticsResult *GetUserStatisticsResult, err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
)
|
||
getUserStatisticsResult = &GetUserStatisticsResult{}
|
||
sql := `
|
||
SELECT a.member_user_count, b.consume_user_count FROM
|
||
( SELECT DISTINCT COUNT(a.user_id) member_user_count
|
||
FROM user a
|
||
JOIN user_member b ON a.user_id = b.user_id AND b.deleted_at = ? )a,
|
||
( SELECT DISTINCT COUNT(a.user_id) consume_user_count
|
||
FROM user a
|
||
JOIN ` + "`order`" + `b ON a.user_id = b.user_id AND b.status = ?)b
|
||
`
|
||
sqlParams := []interface{}{
|
||
utils.DefaultTimeValue, model.OrderStatusFinished,
|
||
}
|
||
err = dao.GetRow(db, &getUserStatisticsResult, sql, sqlParams)
|
||
paged, _ := dao.GetUsers2(db, "", "", 0, "", utils.ZeroTimeValue, utils.ZeroTimeValue, 0, nil, nil, 0, -1)
|
||
getUserStatisticsResult.RegisterUserCount = paged.TotalCount
|
||
getUserStatisticsResult.OnlineUserCount = GetOnlineUserCount()
|
||
return getUserStatisticsResult, err
|
||
}
|