489 lines
15 KiB
Go
489 lines
15 KiB
Go
package event
|
|
|
|
import (
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
"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"
|
|
)
|
|
|
|
var (
|
|
NoUseEventMap = map[string]string{
|
|
"CreateQrOrBarCode": "CreateQrOrBarCode",
|
|
"StatisticsReportForOrders": "StatisticsReportForOrders",
|
|
"UpdateUser": "UpdateUser",
|
|
}
|
|
regexpToken = regexp.MustCompile(`,"token":".*"`)
|
|
)
|
|
|
|
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,
|
|
}
|
|
dao.Begin(db)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
dao.Rollback(db)
|
|
panic(r)
|
|
}
|
|
}()
|
|
err = dao.CreateEntity(db, event)
|
|
dao.Commit(db)
|
|
return err
|
|
}
|
|
|
|
func AddOperateEventDetail(db *dao.DaoDB, operateEventDetail *model.OperateEventDetail) (err error) {
|
|
dao.Begin(db)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
dao.Rollback(db)
|
|
panic(r)
|
|
}
|
|
}()
|
|
operateEventDetail.BeforeData = utils.LimitUTF8StringLen(operateEventDetail.BeforeData, 3200)
|
|
operateEventDetail.AfterData = utils.LimitUTF8StringLen(operateEventDetail.AfterData, 3200)
|
|
err = dao.CreateEntity(db, operateEventDetail)
|
|
dao.Commit(db)
|
|
return err
|
|
}
|
|
|
|
func DeleteOperateEventAndDetail(ctx *jxcontext.Context, deleteTime time.Time) (err error) {
|
|
db := dao.GetDB()
|
|
dao.Begin(db)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
dao.Rollback(db)
|
|
panic(r)
|
|
}
|
|
}()
|
|
dao.DeleteOperateEventDetail(db, deleteTime)
|
|
dao.DeleteOperateEvent(db, deleteTime)
|
|
dao.Commit(db)
|
|
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, "")
|
|
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)
|
|
}
|
|
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 := `
|
|
SELECT * FROM im_message_record WHERE group_id = ? ORDER BY created_at DESC LIMIT 1
|
|
`
|
|
sqlParams := []interface{}{v.GroupID}
|
|
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)
|
|
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(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
|
|
}
|
|
valid := dao.StrictMakeMapByStructObject(payload, messageGroup, ctx.GetUserName())
|
|
if len(valid) > 0 {
|
|
dao.Begin(db)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
dao.Rollback(db)
|
|
panic(r)
|
|
}
|
|
}()
|
|
if num, err = dao.UpdateEntityLogically(db, messageGroup, valid, ctx.GetUserName(), nil); err != nil {
|
|
dao.Rollback(db)
|
|
return 0, err
|
|
}
|
|
dao.Commit(db)
|
|
}
|
|
return num, err
|
|
}
|
|
|
|
func DeleteMessageGroup(ctx *jxcontext.Context, groupID int, userID string) (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
|
|
}
|
|
//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("只有创建者和管理员才能踢人！")
|
|
}
|
|
}
|
|
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")
|
|
} 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("用户余额不足，请充值！")
|
|
}
|
|
dao.Begin(db)
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
dao.Rollback(db)
|
|
panic(r)
|
|
}
|
|
}()
|
|
//账户支出
|
|
if err = financial.AddExpendUpdateAccount(db, userBill, model.BillTypeQuitGroup, quitPrice, 0); err != nil {
|
|
dao.Rollback(db)
|
|
return errCode, err
|
|
}
|
|
//群主收到退团金额
|
|
if err = financial.AddIncomeUpdateAccount(db, userBillGroupMaster, model.BillTypeQuitGroup, quitPrice, 0); err != nil {
|
|
dao.Rollback(db)
|
|
return errCode, err
|
|
}
|
|
dao.Commit(db)
|
|
}
|
|
return errCode, err
|
|
}
|
|
|
|
func SendSysMessage(ctx *jxcontext.Context, imMessageRecord *model.ImMessageRecord) (err error) {
|
|
var (
|
|
db = dao.GetDB()
|
|
userID = imMessageRecord.UserID
|
|
)
|
|
if userID == "" {
|
|
return fmt.Errorf("系统用户不存在！")
|
|
}
|
|
user, err := dao.GetUserByID(db, "user_id", userID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if user.Type != model.UserTypeBoss {
|
|
return fmt.Errorf("抱歉只有系统管理员才能发系统消息！")
|
|
}
|
|
dao.WrapAddIDCULDEntity(imMessageRecord, ctx.GetUserName())
|
|
err = dao.CreateEntity(db, imMessageRecord)
|
|
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
|
|
}
|