146 lines
3.2 KiB
Go
146 lines
3.2 KiB
Go
package chat
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
"gitlab.33.cn/chat/imparse"
|
|
biz "gitlab.33.cn/chat/imparse/proto"
|
|
"gitlab.33.cn/chat/imparse/util"
|
|
)
|
|
|
|
//private
|
|
type GroupFrame struct {
|
|
*StandardFrame
|
|
base *biz.Common
|
|
|
|
stored bool
|
|
}
|
|
|
|
func NewGroupFrame(standardFrame *StandardFrame, bizPro *biz.Common) *GroupFrame {
|
|
frame := &GroupFrame{
|
|
StandardFrame: standardFrame,
|
|
base: bizPro,
|
|
}
|
|
frame.SetBody(frame)
|
|
bizPro.From = frame.GetFrom()
|
|
frame.SetTarget(bizPro.GetTarget())
|
|
frame.SetTransmissionMethod(imparse.GroupCast)
|
|
return frame
|
|
}
|
|
|
|
func (p *GroupFrame) Type() imparse.FrameType {
|
|
return GroupFrameType
|
|
}
|
|
|
|
func (p *GroupFrame) Filter(ctx context.Context, db imparse.Cache, filters ...imparse.Filter) (uint64, error) {
|
|
//查询是否有重复消息
|
|
msg, err := db.GetMsg(ctx, p.GetFrom(), p.base.GetSeq())
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if msg != nil {
|
|
p.stored = true
|
|
p.base.Mid, err = strconv.ParseInt(msg.Mid, 10, 64)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
p.base.Datetime = msg.CreateTime
|
|
} else {
|
|
for _, filter := range filters {
|
|
err = filter(ctx, p)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
|
|
p.stored = false
|
|
p.base.Mid, err = db.GetMid(ctx)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
p.base.Datetime = uint64(util.TimeNowUnixNano() / int64(time.Millisecond))
|
|
err := db.AddMsg(ctx, p.GetFrom(), &imparse.MsgIndex{
|
|
Mid: strconv.FormatInt(p.base.GetMid(), 10),
|
|
Seq: p.base.GetSeq(),
|
|
SenderId: p.GetFrom(),
|
|
CreateTime: p.base.GetDatetime(),
|
|
})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
return p.base.GetDatetime(), nil
|
|
}
|
|
|
|
func (p *GroupFrame) Transport(ctx context.Context, exec imparse.Exec) error {
|
|
if p.stored {
|
|
return nil
|
|
}
|
|
data, err := p.PushData()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return exec.Transport(ctx, p.base.GetMid(), p.GetKey(), p.GetFrom(), p.GetTarget(), p.GetTransmissionMethod(), p.Type(), data)
|
|
}
|
|
|
|
func (p *GroupFrame) Ack(ctx context.Context, exec imparse.Exec) (int64, error) {
|
|
ackBytes, err := p.AckData()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return p.base.GetMid(), exec.RevAck(ctx, p.base.GetMid(), []string{p.GetKey()}, ackBytes)
|
|
}
|
|
|
|
func (p *GroupFrame) AckBody() ([]byte, error) {
|
|
body, err := proto.Marshal(&biz.CommonAck{
|
|
Mid: p.base.GetMid(),
|
|
Datetime: p.base.GetDatetime(),
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshal CommonAck err: %v", err)
|
|
}
|
|
data, err := proto.Marshal(&biz.Proto{
|
|
EventType: biz.Proto_commonAck,
|
|
Body: body,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshal Proto err: %v", err)
|
|
}
|
|
return data, err
|
|
}
|
|
|
|
func (p *GroupFrame) PushBody() ([]byte, error) {
|
|
var err error
|
|
var data []byte
|
|
pro := biz.Proto{
|
|
EventType: biz.Proto_common,
|
|
}
|
|
pro.Body, err = proto.Marshal(p.base)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshal Common err: %v", err)
|
|
}
|
|
data, err = proto.Marshal(&pro)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshal Proto err: %v", err)
|
|
}
|
|
return data, err
|
|
}
|
|
|
|
//
|
|
func (p *GroupFrame) GetChannelType() biz.Channel {
|
|
return p.base.ChannelType
|
|
}
|
|
|
|
func (p *GroupFrame) GetMsgType() biz.MsgType {
|
|
return p.base.MsgType
|
|
}
|
|
|
|
func (p *GroupFrame) GetBase() *biz.Common {
|
|
return p.base
|
|
}
|