mirror of
https://github.com/openimsdk/open-im-server.git
synced 2025-04-29 13:46:40 +08:00
Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode
This commit is contained in:
wangchuxiao
commit
4854db030f
@ -3,14 +3,12 @@ package main
|
||||
import (
|
||||
_ "Open_IM/cmd/open_im_api/docs"
|
||||
apiAuth "Open_IM/internal/api/auth"
|
||||
clientInit "Open_IM/internal/api/client_init"
|
||||
"Open_IM/internal/api/conversation"
|
||||
"Open_IM/internal/api/friend"
|
||||
"Open_IM/internal/api/group"
|
||||
"Open_IM/internal/api/manage"
|
||||
apiChat "Open_IM/internal/api/msg"
|
||||
"Open_IM/internal/api/office"
|
||||
"Open_IM/internal/api/organization"
|
||||
apiThird "Open_IM/internal/api/third"
|
||||
"Open_IM/internal/api/user"
|
||||
"Open_IM/pkg/common/config"
|
||||
@ -84,14 +82,14 @@ func main() {
|
||||
friendRouterGroup.POST("/add_friend", friend.AddFriend) //1
|
||||
friendRouterGroup.POST("/delete_friend", friend.DeleteFriend) //1
|
||||
friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList) //1
|
||||
friendRouterGroup.POST("/get_self_friend_apply_list", friend.GetSelfFriendApplyList) //1
|
||||
friendRouterGroup.POST("/get_self_friend_apply_list", friend.GetSelfApplyList) //1
|
||||
friendRouterGroup.POST("/get_friend_list", friend.GetFriendList) //1
|
||||
friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse) //1
|
||||
friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark) //1
|
||||
|
||||
friendRouterGroup.POST("/add_black", friend.AddBlack) //1
|
||||
friendRouterGroup.POST("/get_black_list", friend.GetBlacklist) //1
|
||||
friendRouterGroup.POST("/remove_black", friend.RemoveBlack) //1
|
||||
friendRouterGroup.POST("/remove_black", friend.RemoveBlacklist) //1
|
||||
|
||||
friendRouterGroup.POST("/import_friend", friend.ImportFriend) //1
|
||||
friendRouterGroup.POST("/is_friend", friend.IsFriend) //1
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -5,27 +5,53 @@ import (
|
||||
api "Open_IM/pkg/base_info"
|
||||
"Open_IM/pkg/common/config"
|
||||
rpc "Open_IM/pkg/proto/friend"
|
||||
"Open_IM/pkg/utils"
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
// 不一致
|
||||
func AddBlacklist(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.AddBlacklistReq{}, &api.AddBlacklistResp{},
|
||||
config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
|
||||
func AddBlack(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.AddBlacklistReq{}, &api.AddBlacklistResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func ImportFriend1(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.ImportFriendReq{}, &api.ImportFriendResp{},
|
||||
config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
|
||||
func ImportFriend(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.ImportFriendReq{}, &api.ImportFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func AddFriend1(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.AddFriendReq{}, &api.AddFriendResp{},
|
||||
config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
|
||||
func AddFriend(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.AddFriendReq{}, &api.AddFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func AddFriendResponse1(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.AddFriendResponseReq{}, &api.AddFriendResponseResp{},
|
||||
config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
|
||||
func AddFriendResponse(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.AddFriendResponseReq{}, &api.AddFriendResponseResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func DeleteFriend(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.DeleteFriendReq{}, &api.DeleteFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func GetBlacklist(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.GetBlackListReq{}, &api.GetBlackListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func SetFriendRemark(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.SetFriendRemarkReq{}, &api.SetFriendRemarkResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func RemoveBlacklist(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.RemoveBlacklistReq{}, &api.RemoveBlacklistResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func IsFriend(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.IsFriendReq{}, &api.IsFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func GetFriendList(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.GetFriendListReq{}, &api.GetFriendListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func GetFriendApplyList(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.GetFriendApplyListReq{}, &api.GetFriendApplyListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
func GetSelfApplyList(c *gin.Context) {
|
||||
common.ApiToRpc(c, &api.GetSelfApplyListReq{}, &api.GetSelfApplyListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
|
||||
}
|
||||
|
||||
@ -12,48 +12,43 @@ import (
|
||||
)
|
||||
|
||||
func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcClientFunc interface{}, rpcFuncName string) {
|
||||
if rpcName == "" {
|
||||
rpcName = utils2.GetFuncName(1)
|
||||
}
|
||||
logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName)
|
||||
operationID := c.GetHeader("operationID")
|
||||
nCtx := trace_log.NewCtx1(c, rpcFuncName, operationID)
|
||||
defer log.ShowLog(nCtx)
|
||||
ctx := trace_log.NewCtx1(c, rpcFuncName)
|
||||
defer log.ShowLog(ctx)
|
||||
if err := c.BindJSON(apiReq); err != nil {
|
||||
trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
|
||||
trace_log.WriteErrorResponse(ctx, "BindJSON", err)
|
||||
return
|
||||
}
|
||||
trace_log.SetCtxInfo(nCtx, logFuncName, nil, "apiReq", apiReq)
|
||||
etcdConn, err := getcdv3.GetConn(nCtx, rpcName)
|
||||
trace_log.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq)
|
||||
etcdConn, err := getcdv3.GetConn(ctx, rpcName)
|
||||
if err != nil {
|
||||
trace_log.WriteErrorResponse(nCtx, "GetConn", err)
|
||||
trace_log.WriteErrorResponse(ctx, "GetConn", err)
|
||||
return
|
||||
}
|
||||
rpc := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
|
||||
rpcClient := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
|
||||
reflect.ValueOf(etcdConn),
|
||||
})[0].MethodByName(rpcFuncName) // rpc func
|
||||
rpcReqPtr := reflect.New(rpc.Type().In(1).Elem()) // *req参数
|
||||
//if err := utils.CopyStructFields(rpcReqPtr.Interface(), apiReq); err != nil {
|
||||
// trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err)
|
||||
// return
|
||||
//}
|
||||
})[0].MethodByName(rpcFuncName) // rpcClient func
|
||||
rpcReqPtr := reflect.New(rpcClient.Type().In(1).Elem()) // *req
|
||||
CopyAny(apiReq, rpcReqPtr.Interface())
|
||||
trace_log.SetCtxInfo(nCtx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
|
||||
respArr := rpc.Call([]reflect.Value{
|
||||
reflect.ValueOf(context.Context(c)), // context.Context
|
||||
rpcReqPtr, // rpc apiReq
|
||||
trace_log.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
|
||||
respArr := rpcClient.Call([]reflect.Value{
|
||||
reflect.ValueOf(context.Context(c)), // context.Context (ctx operationID. opUserID)
|
||||
rpcReqPtr, // rpcClient apiReq
|
||||
}) // respArr => (apiResp, error)
|
||||
if !respArr[1].IsNil() { // rpc err != nil
|
||||
if !respArr[1].IsNil() { // rpcClient err != nil
|
||||
err := respArr[1].Interface().(error)
|
||||
trace_log.WriteErrorResponse(nCtx, rpcFuncName, err, "callRpcResp", "error")
|
||||
trace_log.WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error")
|
||||
return
|
||||
}
|
||||
rpcResp := respArr[0].Elem()
|
||||
trace_log.SetCtxInfo(nCtx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
|
||||
trace_log.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
|
||||
if apiResp != nil {
|
||||
//if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != nil {
|
||||
// trace_log.SetCtxInfo(nCtx, "CopyStructFields_RpcResp", err, "apiResp", fmt.Sprintf("%T", apiResp), "rpcResp", fmt.Sprintf("%T", rpcResp.Interface()))
|
||||
//}
|
||||
CopyAny(rpcResp.Interface(), apiResp)
|
||||
}
|
||||
trace_log.SetSuccess(nCtx, rpcFuncName, apiResp)
|
||||
trace_log.SetSuccess(ctx, rpcFuncName, apiResp)
|
||||
}
|
||||
|
||||
func rpcString(v interface{}) string {
|
||||
@ -62,77 +57,3 @@ func rpcString(v interface{}) string {
|
||||
}
|
||||
return fmt.Sprintf("%+v", v)
|
||||
}
|
||||
|
||||
//func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn interface{}, rpcFuncName string, tokenFunc func(token string, operationID string) (string, error)) {
|
||||
// nCtx := trace_log.NewCtx(c, rpcFuncName)
|
||||
// defer trace_log.ShowLog(nCtx)
|
||||
// if err := c.BindJSON(apiReq); err != nil {
|
||||
// trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
|
||||
// return
|
||||
// }
|
||||
// reqValue := reflect.ValueOf(apiReq).Elem()
|
||||
// operationID := reqValue.FieldByName("OperationID").String()
|
||||
// trace_log.SetOperationID(nCtx, operationID)
|
||||
// trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", apiReq)
|
||||
// etcdConn, err := utils2.GetConn(c, rpcName)
|
||||
// if err != nil {
|
||||
// trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err)
|
||||
// return
|
||||
// }
|
||||
// rpc := reflect.ValueOf(fn).Call([]reflect.Value{
|
||||
// reflect.ValueOf(etcdConn),
|
||||
// })[0].MethodByName(rpcFuncName) // rpc func
|
||||
// rpcReqPtr := reflect.New(rpc.Type().In(1).Elem()) // *req参数
|
||||
// var opUserID string
|
||||
// if tokenFunc != nil {
|
||||
// var err error
|
||||
// opUserID, err = tokenFunc(c.GetHeader("token"), operationID)
|
||||
// if err != nil {
|
||||
// trace_log.WriteErrorResponse(nCtx, "TokenFunc", err)
|
||||
// return
|
||||
// }
|
||||
// }
|
||||
// if opID := rpcReqPtr.Elem().FieldByName("OperationID"); opID.IsValid() {
|
||||
// opID.SetString(operationID)
|
||||
// if opU := rpcReqPtr.Elem().FieldByName("OpUserID"); opU.IsValid() {
|
||||
// opU.SetString(opUserID)
|
||||
// }
|
||||
// } else {
|
||||
// op := rpcReqPtr.Elem().FieldByName("Operation").Elem()
|
||||
// op.FieldByName("OperationID").SetString(operationID)
|
||||
// op.FieldByName("OpUserID").SetString(opUserID)
|
||||
// }
|
||||
// if err := utils.CopyStructFields(rpcReqPtr.Interface(), apiReq); err != nil {
|
||||
// trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err)
|
||||
// return
|
||||
// }
|
||||
// respArr := rpc.Call([]reflect.Value{
|
||||
// reflect.ValueOf(context.Context(c)), // context.Context
|
||||
// rpcReqPtr, // rpc apiReq
|
||||
// }) // respArr => (apiResp, error)
|
||||
// if !respArr[1].IsNil() { // rpc err != nil
|
||||
// err := respArr[1].Interface().(error)
|
||||
// trace_log.WriteErrorResponse(nCtx, rpcFuncName, err, "rpc req", rpcReqPtr.Interface())
|
||||
// return
|
||||
// }
|
||||
// rpcResp := respArr[0].Elem()
|
||||
// trace_log.SetCtxInfo(nCtx, rpcFuncName, nil, "rpc req", rpcReqPtr.Interface(), "resp", rpcResp.Interface())
|
||||
// commonResp := rpcResp.FieldByName("CommonResp").Elem()
|
||||
// errCodeVal := commonResp.FieldByName("ErrCode")
|
||||
// errMsgVal := commonResp.FieldByName("ErrMsg").Interface().(string)
|
||||
// errCode := errCodeVal.Interface().(int32)
|
||||
// if errCode != 0 {
|
||||
// trace_log.WriteErrorResponse(nCtx, "RpcErrCode", &constant.ErrInfo{
|
||||
// ErrCode: errCode,
|
||||
// ErrMsg: errMsgVal,
|
||||
// })
|
||||
// return
|
||||
// }
|
||||
// if apiResp != nil {
|
||||
// if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != nil {
|
||||
// trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcResp", err)
|
||||
// return
|
||||
// }
|
||||
// }
|
||||
// trace_log.SetSuccess(nCtx, rpcFuncName, apiResp)
|
||||
//}
|
||||
|
||||
@ -6,25 +6,6 @@ import (
|
||||
"reflect"
|
||||
)
|
||||
|
||||
func setBaseValue(from, to reflect.Value) {
|
||||
if isBaseNil(from) {
|
||||
return
|
||||
}
|
||||
var l int
|
||||
t := to.Type()
|
||||
for t.Kind() == reflect.Ptr {
|
||||
l++
|
||||
t = t.Elem()
|
||||
}
|
||||
v := baseValue(from)
|
||||
for i := 0; i < l; i++ {
|
||||
t := reflect.New(v.Type())
|
||||
t.Elem().Set(v)
|
||||
v = t
|
||||
}
|
||||
to.Set(v)
|
||||
}
|
||||
|
||||
func CopyAny(from, to interface{}) {
|
||||
t := reflect.ValueOf(to)
|
||||
if t.Kind() == reflect.Ptr {
|
||||
@ -50,31 +31,35 @@ func copyAny(from, to reflect.Value) {
|
||||
if isBaseNil(to) {
|
||||
to.Set(getBaseZeroValue(to.Type()))
|
||||
}
|
||||
btfrom := baseType(from.Type())
|
||||
btto := baseType(to.Type())
|
||||
if typeEq(btfrom, btto) {
|
||||
btFrom := baseType(from.Type())
|
||||
btTo := baseType(to.Type())
|
||||
if btTo.Kind() == reflect.Interface || typeEq(btFrom, btTo) {
|
||||
setBaseValue(from, to)
|
||||
return
|
||||
}
|
||||
if _, ok := wrapType[btto.String()]; ok { // string -> wrapperspb.StringValue
|
||||
val := reflect.New(btto).Elem()
|
||||
if _, ok := wrapType[btTo.String()]; ok { // string -> wrapperspb.StringValue
|
||||
val := reflect.New(btTo).Elem()
|
||||
copyAny(from, val.FieldByName("Value"))
|
||||
setBaseValue(val, to)
|
||||
return
|
||||
}
|
||||
if _, ok := wrapType[btfrom.String()]; ok { // wrapperspb.StringValue -> string
|
||||
if _, ok := wrapType[btFrom.String()]; ok { // wrapperspb.StringValue -> string
|
||||
copyAny(baseValue(from).FieldByName("Value"), to)
|
||||
return
|
||||
}
|
||||
if btfrom.Kind() == reflect.Struct && btto.Kind() == reflect.Struct {
|
||||
if btFrom.Kind() == reflect.Struct && btTo.Kind() == reflect.Struct {
|
||||
copyStruct(baseValue(from), baseValue(to))
|
||||
return
|
||||
}
|
||||
if btfrom.Kind() == reflect.Slice && btto.Kind() == reflect.Slice {
|
||||
if btFrom.Kind() == reflect.Slice && btTo.Kind() == reflect.Slice {
|
||||
copySlice(baseValue(from), baseValue(to))
|
||||
return
|
||||
}
|
||||
if btto.Kind() == reflect.String {
|
||||
if btFrom.Kind() == reflect.Map && btTo.Kind() == reflect.Map {
|
||||
copyMap(baseValue(from), baseValue(to))
|
||||
return
|
||||
}
|
||||
if btTo.Kind() == reflect.String {
|
||||
if isBaseNil(to) {
|
||||
to.Set(getBaseZeroValue(baseType(to.Type())))
|
||||
}
|
||||
@ -84,6 +69,26 @@ func copyAny(from, to reflect.Value) {
|
||||
if toNumber(from, to) {
|
||||
return
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func setBaseValue(from, to reflect.Value) {
|
||||
if isBaseNil(from) {
|
||||
return
|
||||
}
|
||||
var l int
|
||||
t := to.Type()
|
||||
for t.Kind() == reflect.Ptr {
|
||||
l++
|
||||
t = t.Elem()
|
||||
}
|
||||
v := baseValue(from)
|
||||
for i := 0; i < l; i++ {
|
||||
t := reflect.New(v.Type())
|
||||
t.Elem().Set(v)
|
||||
v = t
|
||||
}
|
||||
to.Set(v)
|
||||
}
|
||||
|
||||
func getBaseZeroValue(t reflect.Type) reflect.Value {
|
||||
@ -121,15 +126,6 @@ func baseType(t reflect.Type) reflect.Type {
|
||||
return t
|
||||
}
|
||||
|
||||
func baseLayer(t reflect.Type) int {
|
||||
var layer int
|
||||
for t.Kind() == reflect.Ptr {
|
||||
layer++
|
||||
t = t.Elem()
|
||||
}
|
||||
return layer
|
||||
}
|
||||
|
||||
func typeEq(t1, t2 reflect.Type) bool {
|
||||
return t1.String() == t2.String()
|
||||
}
|
||||
@ -174,59 +170,72 @@ func copySlice(from, to reflect.Value) {
|
||||
to.Set(temp)
|
||||
}
|
||||
|
||||
func copyMap(from, to reflect.Value) {
|
||||
// todo copy map
|
||||
}
|
||||
|
||||
func toString(value reflect.Value) string {
|
||||
if value.Kind() == reflect.Slice {
|
||||
switch value.Type().String() {
|
||||
case "[]uint8":
|
||||
case "[]uint8": // []byte -> []uint8
|
||||
return string(value.Interface().([]uint8))
|
||||
case "[]int32":
|
||||
case "[]int32": // []rune -> []int32
|
||||
return string(value.Interface().([]int32))
|
||||
}
|
||||
}
|
||||
return fmt.Sprint(value.Interface())
|
||||
}
|
||||
|
||||
func toNumber(from1, to1 reflect.Value) bool {
|
||||
if isBaseNil(to1) {
|
||||
to1.Set(getBaseZeroValue(to1.Type()))
|
||||
func toNumber(from, to reflect.Value) bool {
|
||||
initTo := func() {
|
||||
if isBaseNil(to) {
|
||||
to.Set(getBaseZeroValue(to.Type()))
|
||||
}
|
||||
from := baseValue(from1)
|
||||
to := baseValue(to1)
|
||||
switch from.Kind() {
|
||||
}
|
||||
switch baseValue(from).Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
switch to.Kind() {
|
||||
switch baseValue(to).Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
to.SetInt(from.Int())
|
||||
initTo()
|
||||
baseValue(to).SetInt(baseValue(from).Int())
|
||||
return true
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
to.SetUint(uint64(from.Int()))
|
||||
initTo()
|
||||
baseValue(to).SetUint(uint64(baseValue(from).Int()))
|
||||
return true
|
||||
case reflect.Float64, reflect.Float32:
|
||||
to.SetFloat(float64(from.Int()))
|
||||
initTo()
|
||||
baseValue(to).SetFloat(float64(baseValue(from).Int()))
|
||||
return true
|
||||
}
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
switch to.Kind() {
|
||||
switch baseValue(to).Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
to.SetInt(int64(from.Uint()))
|
||||
initTo()
|
||||
baseValue(to).SetInt(int64(baseValue(from).Uint()))
|
||||
return true
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
to.SetInt(int64(from.Uint()))
|
||||
initTo()
|
||||
baseValue(to).SetInt(int64(baseValue(from).Uint()))
|
||||
return true
|
||||
case reflect.Float64, reflect.Float32:
|
||||
to.SetFloat(float64(from.Uint()))
|
||||
initTo()
|
||||
baseValue(to).SetFloat(float64(baseValue(from).Uint()))
|
||||
return true
|
||||
}
|
||||
case reflect.Float64, reflect.Float32:
|
||||
switch to.Kind() {
|
||||
switch baseValue(to).Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
to.SetInt(int64(from.Float()))
|
||||
initTo()
|
||||
baseValue(to).SetInt(int64(baseValue(from).Float()))
|
||||
return true
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
to.SetUint(uint64(from.Float()))
|
||||
initTo()
|
||||
baseValue(to).SetUint(uint64(baseValue(from).Float()))
|
||||
return true
|
||||
case reflect.Float64, reflect.Float32:
|
||||
to.SetFloat(from.Float())
|
||||
initTo()
|
||||
baseValue(to).SetFloat(baseValue(from).Float())
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
@ -4,6 +4,7 @@ import (
|
||||
chat "Open_IM/internal/rpc/msg"
|
||||
"Open_IM/pkg/common/config"
|
||||
"Open_IM/pkg/common/constant"
|
||||
"Open_IM/pkg/common/db"
|
||||
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
|
||||
rocksCache "Open_IM/pkg/common/db/rocks_cache"
|
||||
"Open_IM/pkg/common/log"
|
||||
@ -11,6 +12,7 @@ import (
|
||||
promePkg "Open_IM/pkg/common/prometheus"
|
||||
"Open_IM/pkg/common/token_verify"
|
||||
"Open_IM/pkg/common/tools"
|
||||
"Open_IM/pkg/common/trace_log"
|
||||
cp "Open_IM/pkg/common/utils"
|
||||
"Open_IM/pkg/getcdv3"
|
||||
pbCache "Open_IM/pkg/proto/cache"
|
||||
@ -18,6 +20,8 @@ import (
|
||||
sdkws "Open_IM/pkg/proto/sdk_ws"
|
||||
"Open_IM/pkg/utils"
|
||||
"context"
|
||||
"errors"
|
||||
"gorm.io/gorm"
|
||||
"net"
|
||||
"strconv"
|
||||
"strings"
|
||||
@ -40,14 +44,15 @@ type friendServer struct {
|
||||
|
||||
func NewFriendServer(port int) *friendServer {
|
||||
log.NewPrivateLog(constant.LogFileName)
|
||||
DB := db.DB.MysqlDB.DefaultGormDB()
|
||||
return &friendServer{
|
||||
rpcPort: port,
|
||||
rpcRegisterName: config.Config.RpcRegisterName.OpenImFriendName,
|
||||
etcdSchema: config.Config.Etcd.EtcdSchema,
|
||||
etcdAddr: config.Config.Etcd.EtcdAddr,
|
||||
friendModel: imdb.NewFriend(nil),
|
||||
friendRequestModel: imdb.NewFriendRequest(nil),
|
||||
blackModel: imdb.NewBlack(nil),
|
||||
friendModel: imdb.NewFriend(DB),
|
||||
friendRequestModel: imdb.NewFriendRequest(DB),
|
||||
blackModel: imdb.NewBlack(DB),
|
||||
}
|
||||
}
|
||||
|
||||
@ -108,10 +113,10 @@ func (s *friendServer) Run() {
|
||||
|
||||
func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) {
|
||||
resp := &pbFriend.AddBlacklistResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
black := imdb.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
|
||||
black := imdb.Black{OwnerUserID: req.FromUserID, BlockUserID: req.ToUserID, OperatorUserID: tools.OpUserID(ctx)}
|
||||
if err := s.blackModel.Create(ctx, []*imdb.Black{&black}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@ -119,7 +124,7 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID})
|
||||
_, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.FromUserID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@ -129,25 +134,25 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
|
||||
|
||||
func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq) (*pbFriend.AddFriendResp, error) {
|
||||
resp := &pbFriend.AddFriendResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := callbackBeforeAddFriendV1(req); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
userIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.ToUserID)
|
||||
userIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.ToUserID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
userIDList2, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID)
|
||||
userIDList2, err := rocksCache.GetFriendIDListFromCache(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var isSend = true
|
||||
for _, v := range userIDList {
|
||||
if v == req.CommID.FromUserID {
|
||||
if v == req.FromUserID {
|
||||
for _, v2 := range userIDList2 {
|
||||
if v2 == req.CommID.ToUserID {
|
||||
if v2 == req.ToUserID {
|
||||
isSend = false
|
||||
break
|
||||
}
|
||||
@ -159,12 +164,12 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
|
||||
//Cannot add non-existent users
|
||||
|
||||
if isSend {
|
||||
if _, err := GetUserInfo(ctx, req.CommID.ToUserID); err != nil {
|
||||
if _, err := GetUserInfo(ctx, req.ToUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
friendRequest := imdb.FriendRequest{
|
||||
FromUserID: req.CommID.FromUserID,
|
||||
ToUserID: req.CommID.ToUserID,
|
||||
FromUserID: req.FromUserID,
|
||||
ToUserID: req.ToUserID,
|
||||
HandleResult: 0,
|
||||
ReqMsg: req.ReqMsg,
|
||||
CreateTime: time.Now(),
|
||||
@ -179,199 +184,113 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
|
||||
|
||||
func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFriendReq) (*pbFriend.ImportFriendResp, error) {
|
||||
resp := &pbFriend.ImportFriendResp{}
|
||||
//var c sdkws.CommonResp
|
||||
if !utils.IsContain(tools.OpUserID(ctx), config.Config.Manager.AppManagerUid) {
|
||||
//log.NewError(req.OperationID, "not authorized", req.OpUserID, config.Config.Manager.AppManagerUid)
|
||||
//c.ErrCode = constant.ErrNoPermission.ErrCode
|
||||
//c.ErrMsg = constant.ErrNoPermission.ErrMsg
|
||||
//for _, userID := range req.FriendUserIDList {
|
||||
// resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1})
|
||||
//}
|
||||
return nil, constant.ErrNoPermission.Wrap()
|
||||
}
|
||||
if _, err := GetUserInfo(ctx, req.FromUserID); err != nil {
|
||||
//log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.FromUserID)
|
||||
//c.ErrCode = constant.ErrDB.ErrCode
|
||||
//c.ErrMsg = "this user not exists,cant not add friend"
|
||||
//for _, userID := range req.FriendUserIDList {
|
||||
// resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1})
|
||||
//}
|
||||
//resp.CommonResp = &c
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, userID := range req.FriendUserIDList {
|
||||
if _, fErr := GetUserInfo(ctx, userID); fErr != nil {
|
||||
resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1})
|
||||
if _, err := GetUserInfo(ctx, userID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
fs, err := s.friendModel.FindUserState(ctx, req.FromUserID, userID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var friends []*imdb.Friend
|
||||
switch len(fs) {
|
||||
case 1:
|
||||
if fs[0].OwnerUserID == req.FromUserID {
|
||||
friends = append(friends, &imdb.Friend{OwnerUserID: userID, FriendUserID: req.FromUserID})
|
||||
} else {
|
||||
if _, err := imdb.GetFriendRelationshipFromFriend(req.FromUserID, userID); err != nil {
|
||||
//Establish two single friendship
|
||||
toInsertFollow := imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: userID}
|
||||
err1 := imdb.InsertToFriend(&toInsertFollow)
|
||||
if err1 != nil {
|
||||
log.NewError(req.OperationID, "InsertToFriend failed ", err1.Error(), toInsertFollow)
|
||||
resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1})
|
||||
friends = append(friends, &imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: userID})
|
||||
}
|
||||
case 0:
|
||||
friends = append(friends, &imdb.Friend{OwnerUserID: userID, FriendUserID: req.FromUserID}, &imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: userID})
|
||||
default:
|
||||
continue
|
||||
}
|
||||
toInsertFollow = imdb.Friend{OwnerUserID: userID, FriendUserID: req.FromUserID}
|
||||
err2 := imdb.InsertToFriend(&toInsertFollow)
|
||||
if err2 != nil {
|
||||
log.NewError(req.OperationID, "InsertToFriend failed ", err2.Error(), toInsertFollow)
|
||||
resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1})
|
||||
continue
|
||||
}
|
||||
resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: 0})
|
||||
log.NewDebug(req.OperationID, "UserIDResultList ", resp.UserIDResultList)
|
||||
chat.FriendAddedNotification(req.OperationID, req.OpUserID, req.FromUserID, userID)
|
||||
} else {
|
||||
log.NewWarn(req.OperationID, "GetFriendRelationshipFromFriend ok", req.FromUserID, userID)
|
||||
resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: 0})
|
||||
if err := s.friendModel.Create(ctx, friends); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password)
|
||||
if etcdConn == nil {
|
||||
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
|
||||
log.NewError(req.OperationID, errMsg)
|
||||
resp.CommonResp.ErrMsg = errMsg
|
||||
resp.CommonResp.ErrCode = 500
|
||||
return &resp, nil
|
||||
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
cacheClient := pbCache.NewCacheClient(etcdConn)
|
||||
cacheResp, err := cacheClient.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID, OperationID: req.OperationID})
|
||||
if err != nil {
|
||||
log.NewError(req.OperationID, "DelBlackIDListFromCache rpc call failed ", err.Error())
|
||||
resp.CommonResp.ErrCode = 500
|
||||
resp.CommonResp.ErrMsg = err.Error()
|
||||
return &resp, nil
|
||||
}
|
||||
if cacheResp.CommonResp.ErrCode != 0 {
|
||||
log.NewError(req.OperationID, "DelBlackIDListFromCache rpc logic call failed ", cacheResp.String())
|
||||
resp.CommonResp.ErrCode = 500
|
||||
resp.CommonResp.ErrMsg = cacheResp.CommonResp.ErrMsg
|
||||
return &resp, nil
|
||||
if _, err := cacheClient.DelFriendIDListFromCache(ctx, &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil {
|
||||
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.FromUserID)
|
||||
trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.FromUserID)
|
||||
}
|
||||
|
||||
for _, userID := range req.FriendUserIDList {
|
||||
cacheResp, err := cacheClient.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: userID, OperationID: req.OperationID})
|
||||
if err != nil {
|
||||
log.NewError(req.OperationID, "DelBlackIDListFromCache rpc call failed ", err.Error())
|
||||
}
|
||||
if cacheResp != nil && cacheResp.CommonResp != nil {
|
||||
if cacheResp.CommonResp.ErrCode != 0 {
|
||||
log.NewError(req.OperationID, "DelBlackIDListFromCache rpc logic call failed ", cacheResp.String())
|
||||
resp.CommonResp.ErrCode = 500
|
||||
resp.CommonResp.ErrMsg = cacheResp.CommonResp.ErrMsg
|
||||
return &resp, nil
|
||||
}
|
||||
if _, err = cacheClient.DelFriendIDListFromCache(ctx, &pbCache.DelFriendIDListFromCacheReq{UserID: userID}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, userID); err != nil {
|
||||
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), userID)
|
||||
trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", userID)
|
||||
}
|
||||
}
|
||||
|
||||
resp.CommonResp.ErrCode = 0
|
||||
log.NewInfo(req.OperationID, "ImportFriend rpc ok ", resp.String())
|
||||
return &resp, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// process Friend application
|
||||
func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddFriendResponseReq) (*pbFriend.AddFriendResponseResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "AddFriendResponse args ", req.String())
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.AddFriendResponseResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
//Check there application before agreeing or refuse to a friend's application
|
||||
//req.CommID.FromUserID process req.CommID.ToUserID
|
||||
friendRequest, err := imdb.GetFriendApplicationByBothUserID(req.CommID.ToUserID, req.CommID.FromUserID)
|
||||
friendRequest, err := s.friendRequestModel.Take(ctx, req.ToUserID, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
friendRequest.HandleResult = req.HandleResult
|
||||
friendRequest.HandleTime = time.Now()
|
||||
//friendRequest.HandleTime.Unix()
|
||||
friendRequest.HandleMsg = req.HandleMsg
|
||||
friendRequest.HandlerUserID = req.CommID.OpUserID
|
||||
friendRequest.HandlerUserID = tools.OpUserID(ctx)
|
||||
err = imdb.UpdateFriendApplication(friendRequest)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest)
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
|
||||
//Change the status of the friend request form
|
||||
if req.HandleResult == constant.FriendFlag {
|
||||
var isInsert int
|
||||
var isInsert bool
|
||||
//Establish friendship after find friend relationship not exists
|
||||
_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
if err == nil {
|
||||
log.NewWarn(req.CommID.OperationID, "GetFriendRelationshipFromFriend exist", req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
} else {
|
||||
//Establish two single friendship
|
||||
toInsertFollow := imdb.Friend{OwnerUserID: req.CommID.FromUserID, FriendUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
|
||||
err = imdb.InsertToFriend(&toInsertFollow)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow)
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
_, err := s.friendModel.Take(ctx, req.FromUserID, req.ToUserID)
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
if err := s.friendModel.Create(ctx, []*imdb.Friend{{OwnerUserID: req.FromUserID, FriendUserID: req.ToUserID, OperatorUserID: tools.OpUserID(ctx)}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
isInsert = 1
|
||||
isInsert = true
|
||||
} else if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
_, err = imdb.GetFriendRelationshipFromFriend(req.CommID.ToUserID, req.CommID.FromUserID)
|
||||
if err == nil {
|
||||
log.NewWarn(req.CommID.OperationID, "GetFriendRelationshipFromFriend exist", req.CommID.ToUserID, req.CommID.FromUserID)
|
||||
} else {
|
||||
toInsertFollow := imdb.Friend{OwnerUserID: req.CommID.ToUserID, FriendUserID: req.CommID.FromUserID, OperatorUserID: req.CommID.OpUserID}
|
||||
err = imdb.InsertToFriend(&toInsertFollow)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow)
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
}
|
||||
isInsert = 1
|
||||
}
|
||||
// cache rpc
|
||||
if isInsert == 1 {
|
||||
delFriendIDListFromCacheReq := &pbCache.DelFriendIDListFromCacheReq{OperationID: req.CommID.OperationID}
|
||||
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password)
|
||||
if etcdConn == nil {
|
||||
errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
|
||||
log.NewError(req.CommID.OperationID, errMsg)
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrInternalServer.ErrCode, ErrMsg: errMsg}}, nil
|
||||
if isInsert {
|
||||
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
client := pbCache.NewCacheClient(etcdConn)
|
||||
delFriendIDListFromCacheReq.UserID = req.CommID.ToUserID
|
||||
respPb, err := client.DelFriendIDListFromCache(context.Background(), delFriendIDListFromCacheReq)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", err.Error())
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
|
||||
|
||||
if _, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.ToUserID}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if respPb.CommonResp.ErrCode != 0 {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", respPb.CommonResp.String())
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil
|
||||
if _, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
delFriendIDListFromCacheReq.UserID = req.CommID.FromUserID
|
||||
respPb, err = client.DelFriendIDListFromCache(context.Background(), delFriendIDListFromCacheReq)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", err.Error())
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.ToUserID); err != nil {
|
||||
trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.ToUserID)
|
||||
}
|
||||
if respPb.CommonResp.ErrCode != 0 {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", respPb.CommonResp.String())
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil {
|
||||
trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.FromUserID)
|
||||
}
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.ToUserID); err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.ToUserID)
|
||||
}
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID); err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID)
|
||||
}
|
||||
chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
chat.FriendAddedNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.FromUserID, req.ToUserID)
|
||||
}
|
||||
}
|
||||
|
||||
@ -380,329 +299,174 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
|
||||
} else if req.HandleResult == constant.FriendResponseRefuse {
|
||||
chat.FriendApplicationRejectedNotification(req)
|
||||
} else {
|
||||
log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult)
|
||||
trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), nil, "handleResult", req.HandleResult)
|
||||
}
|
||||
|
||||
log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
|
||||
return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{}}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (*pbFriend.DeleteFriendResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "DeleteFriend args ", req.String())
|
||||
//Parse token, to find current user information
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.DeleteFriendResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
err := imdb.DeleteSingleFriendInfo(req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
if err := s.friendModel.Delete(ctx, req.FromUserID, req.ToUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "DeleteSingleFriendInfo failed", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "DeleteFriend rpc ok")
|
||||
|
||||
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password)
|
||||
if etcdConn == nil {
|
||||
errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
|
||||
log.NewError(req.CommID.OperationID, errMsg)
|
||||
return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrInternalServer.ErrCode, ErrMsg: errMsg}}, nil
|
||||
}
|
||||
client := pbCache.NewCacheClient(etcdConn)
|
||||
respPb, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{OperationID: req.CommID.OperationID, UserID: req.CommID.FromUserID})
|
||||
_, err = pbCache.NewCacheClient(etcdConn).DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID})
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache rpc failed", err.Error())
|
||||
return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
if respPb.CommonResp.ErrCode != 0 {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", respPb.CommonResp.String())
|
||||
return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil {
|
||||
trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "DelAllFriendsInfoFromCache", req.FromUserID)
|
||||
}
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID); err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID)
|
||||
}
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.ToUserID); err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID)
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.ToUserID); err != nil {
|
||||
trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "DelAllFriendsInfoFromCache", req.ToUserID)
|
||||
}
|
||||
chat.FriendDeletedNotification(req)
|
||||
return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{}}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlacklistReq) (*pbFriend.GetBlacklistResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "GetBlacklist args ", req.String())
|
||||
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.GetBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.GetBlacklistResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.CommID.FromUserID)
|
||||
blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "GetBlackListByUID failed ", err.Error(), req.CommID.FromUserID)
|
||||
return &pbFriend.GetBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var (
|
||||
userInfoList []*sdkws.PublicUserInfo
|
||||
)
|
||||
for _, userID := range blackIDList {
|
||||
user, err := rocksCache.GetUserInfoFromCache(ctx, userID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), userID)
|
||||
trace_log.SetCtxInfo(ctx, "GetUserInfoFromCache", err, "userID", userID)
|
||||
continue
|
||||
}
|
||||
var blackUserInfo sdkws.PublicUserInfo
|
||||
utils.CopyStructFields(&blackUserInfo, user)
|
||||
userInfoList = append(userInfoList, &blackUserInfo)
|
||||
resp.BlackUserInfoList = append(resp.BlackUserInfoList, &blackUserInfo)
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "rpc GetBlacklist ok ", pbFriend.GetBlacklistResp{BlackUserInfoList: userInfoList})
|
||||
return &pbFriend.GetBlacklistResp{BlackUserInfoList: userInfoList}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFriendRemarkReq) (*pbFriend.SetFriendRemarkResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "SetFriendComment args ", req.String())
|
||||
//Parse token, to find current user information
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.SetFriendRemarkResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err := imdb.UpdateFriendComment(req.CommID.FromUserID, req.CommID.ToUserID, req.Remark)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "UpdateFriendComment failed ", req.CommID.FromUserID, req.CommID.ToUserID, req.Remark, err.Error())
|
||||
return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
if err := s.friendModel.UpdateRemark(ctx, req.FromUserID, req.ToUserID, req.Remark); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok")
|
||||
err = rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "DelAllFriendInfoFromCache failed ", req.CommID.FromUserID, err.Error())
|
||||
return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
chat.FriendRemarkSetNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{}}, nil
|
||||
chat.FriendRemarkSetNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.FromUserID, req.ToUserID)
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.RemoveBlacklistReq) (*pbFriend.RemoveBlacklistResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "RemoveBlacklist args ", req.String())
|
||||
resp := &pbFriend.RemoveBlacklistResp{}
|
||||
//Parse token, to find current user information
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
err := imdb.RemoveBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
if err := s.blackModel.Delete(ctx, []*imdb.Black{{OwnerUserID: req.FromUserID, BlockUserID: req.ToUserID}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "RemoveBlackList failed", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
|
||||
return nil, err
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "rpc RemoveBlacklist ok ")
|
||||
|
||||
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password)
|
||||
if etcdConn == nil {
|
||||
errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
|
||||
log.NewError(req.CommID.OperationID, errMsg)
|
||||
return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrInternalServer.ErrCode, ErrMsg: errMsg}}, nil
|
||||
}
|
||||
|
||||
cacheClient := pbCache.NewCacheClient(etcdConn)
|
||||
cacheResp, err := cacheClient.DelBlackIDListFromCache(context.Background(), &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID})
|
||||
_, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(context.Background(), &pbCache.DelBlackIDListFromCacheReq{UserID: req.FromUserID})
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "DelBlackIDListFromCache rpc call failed ", err.Error())
|
||||
return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: 500, ErrMsg: "ReduceBlackUserFromCache rpc call failed"}}, nil
|
||||
}
|
||||
if cacheResp.CommonResp.ErrCode != 0 {
|
||||
log.NewError(req.CommID.OperationID, "DelBlackIDListFromCache rpc logic call failed ", cacheResp.CommonResp.String())
|
||||
return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
chat.BlackDeletedNotification(req)
|
||||
return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{}}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlackListReq) (*pbFriend.IsInBlackListResp, error) {
|
||||
log.NewInfo("IsInBlackList args ", req.String())
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.IsInBlackListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.IsInBlackListResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.CommID.FromUserID)
|
||||
blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID)
|
||||
return &pbFriend.IsInBlackListResp{CommonResp: &sdkws.CommonResp{ErrMsg: err.Error(), ErrCode: constant.ErrDB.ErrCode}}, nil
|
||||
return nil, err
|
||||
}
|
||||
var isInBlacklist bool
|
||||
if utils.IsContain(req.CommID.ToUserID, blackIDList) {
|
||||
isInBlacklist = true
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "IsInBlackList rpc ok ", pbFriend.IsInBlackListResp{Response: isInBlacklist})
|
||||
return &pbFriend.IsInBlackListResp{Response: isInBlacklist}, nil
|
||||
resp.Response = utils.IsContain(req.ToUserID, blackIDList)
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (*pbFriend.IsFriendResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, req.String())
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.IsFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.IsFriendResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID)
|
||||
friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID)
|
||||
return &pbFriend.IsFriendResp{CommonResp: &sdkws.CommonResp{ErrMsg: err.Error(), ErrCode: constant.ErrDB.ErrCode}}, nil
|
||||
return nil, err
|
||||
}
|
||||
var isFriend bool
|
||||
if utils.IsContain(req.CommID.ToUserID, friendIDList) {
|
||||
isFriend = true
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, pbFriend.IsFriendResp{Response: isFriend})
|
||||
return &pbFriend.IsFriendResp{Response: isFriend}, nil
|
||||
resp.Response = utils.IsContain(req.ToUserID, friendIDList)
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFriendListReq) (*pbFriend.GetFriendListResp, error) {
|
||||
log.NewInfo("GetFriendList args ", req.String())
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.GetFriendListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
resp := &pbFriend.GetFriendListResp{}
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
friendList, err := rocksCache.GetAllFriendsInfoFromCache(ctx, req.CommID.FromUserID)
|
||||
friendList, err := rocksCache.GetAllFriendsInfoFromCache(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache failed", err.Error(), req.CommID.FromUserID)
|
||||
return &pbFriend.GetFriendListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var userInfoList []*sdkws.FriendInfo
|
||||
for _, friendUser := range friendList {
|
||||
friendUserInfo := sdkws.FriendInfo{FriendUser: &sdkws.UserInfo{}}
|
||||
cp.FriendDBCopyOpenIM(&friendUserInfo, friendUser)
|
||||
log.NewDebug(req.CommID.OperationID, "friends : ", friendUser, "openim friends: ", friendUserInfo)
|
||||
userInfoList = append(userInfoList, &friendUserInfo)
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "rpc GetFriendList ok", pbFriend.GetFriendListResp{FriendInfoList: userInfoList})
|
||||
return &pbFriend.GetFriendListResp{FriendInfoList: userInfoList}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// received
|
||||
func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.GetFriendApplyListReq) (*pbFriend.GetFriendApplyListResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "GetFriendApplyList args ", req.String())
|
||||
resp := &pbFriend.GetFriendApplyListResp{}
|
||||
//Parse token, to find current user information
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.GetFriendApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Find the current user friend applications received
|
||||
ApplyUsersInfo, err := imdb.GetReceivedFriendsApplicationListByUserID(req.CommID.FromUserID)
|
||||
applyUsersInfo, err := s.friendRequestModel.FindToUserID(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "GetReceivedFriendsApplicationListByUserID ", err.Error(), req.CommID.FromUserID)
|
||||
return &pbFriend.GetFriendApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var appleUserList []*sdkws.FriendRequest
|
||||
for _, applyUserInfo := range ApplyUsersInfo {
|
||||
for _, applyUserInfo := range applyUsersInfo {
|
||||
var userInfo sdkws.FriendRequest
|
||||
cp.FriendRequestDBCopyOpenIM(&userInfo, &applyUserInfo)
|
||||
// utils.CopyStructFields(&userInfo, applyUserInfo)
|
||||
// u, err := imdb.GetUserByUserID(userInfo.FromUserID)
|
||||
// if err != nil {
|
||||
// log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID)
|
||||
// continue
|
||||
// }
|
||||
// userInfo.FromNickname = u.Nickname
|
||||
// userInfo.FromFaceURL = u.FaceURL
|
||||
// userInfo.FromGender = u.Gender
|
||||
//
|
||||
// u, err = imdb.GetUserByUserID(userInfo.ToUserID)
|
||||
// if err != nil {
|
||||
// log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID)
|
||||
// continue
|
||||
// }
|
||||
// userInfo.ToNickname = u.Nickname
|
||||
// userInfo.ToFaceURL = u.FaceURL
|
||||
// userInfo.ToGender = u.Gender
|
||||
appleUserList = append(appleUserList, &userInfo)
|
||||
cp.FriendRequestDBCopyOpenIM(&userInfo, applyUserInfo)
|
||||
resp.FriendRequestList = append(resp.FriendRequestList, &userInfo)
|
||||
}
|
||||
|
||||
log.NewInfo(req.CommID.OperationID, "rpc GetFriendApplyList ok", pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList})
|
||||
return &pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSelfApplyListReq) (*pbFriend.GetSelfApplyListResp, error) {
|
||||
log.NewInfo(req.CommID.OperationID, "GetSelfApplyList args ", req.String())
|
||||
|
||||
resp := &pbFriend.GetSelfApplyListResp{}
|
||||
//Parse token, to find current user information
|
||||
if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) {
|
||||
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
|
||||
return &pbFriend.GetSelfApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
|
||||
|
||||
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Find the self add other userinfo
|
||||
usersInfo, err := imdb.GetSendFriendApplicationListByUserID(req.CommID.FromUserID)
|
||||
usersInfo, err := s.friendRequestModel.FindFromUserID(ctx, req.FromUserID)
|
||||
if err != nil {
|
||||
log.NewError(req.CommID.OperationID, "GetSendFriendApplicationListByUserID failed ", err.Error(), req.CommID.FromUserID)
|
||||
return &pbFriend.GetSelfApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
|
||||
return nil, err
|
||||
}
|
||||
var selfApplyOtherUserList []*sdkws.FriendRequest
|
||||
for _, selfApplyOtherUserInfo := range usersInfo {
|
||||
var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo
|
||||
cp.FriendRequestDBCopyOpenIM(&userInfo, &selfApplyOtherUserInfo)
|
||||
//u, err := imdb.GetUserByUserID(userInfo.FromUserID)
|
||||
//if err != nil {
|
||||
// log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID)
|
||||
// continue
|
||||
//}
|
||||
//userInfo.FromNickname = u.Nickname
|
||||
//userInfo.FromFaceURL = u.FaceURL
|
||||
//userInfo.FromGender = u.Gender
|
||||
//
|
||||
//u, err = imdb.GetUserByUserID(userInfo.ToUserID)
|
||||
//if err != nil {
|
||||
// log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID)
|
||||
// continue
|
||||
//}
|
||||
//userInfo.ToNickname = u.Nickname
|
||||
//userInfo.ToFaceURL = u.FaceURL
|
||||
//userInfo.ToGender = u.Gender
|
||||
|
||||
selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo)
|
||||
cp.FriendRequestDBCopyOpenIM(&userInfo, selfApplyOtherUserInfo)
|
||||
resp.FriendRequestList = append(resp.FriendRequestList, &userInfo)
|
||||
}
|
||||
log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList})
|
||||
return &pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}, nil
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
////
|
||||
//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) {
|
||||
// return nil, nil
|
||||
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
|
||||
//// var (
|
||||
//// isInBlackList int32
|
||||
//// // isFriend int32
|
||||
//// comment string
|
||||
//// )
|
||||
////
|
||||
//// friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
//// if err != nil {
|
||||
//// log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error())
|
||||
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
|
||||
//// // isFriend = constant.FriendFlag
|
||||
//// }
|
||||
//// comment = friendShip.Remark
|
||||
////
|
||||
//// friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID)
|
||||
//// if err != nil {
|
||||
//// log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error())
|
||||
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
|
||||
//// }
|
||||
////
|
||||
//// err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
|
||||
//// if err == nil {
|
||||
//// isInBlackList = constant.BlackListFlag
|
||||
//// }
|
||||
////
|
||||
//// resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg: "",}
|
||||
////
|
||||
//// utils.CopyStructFields(resp.FriendInfoList, friendUserInfo)
|
||||
//// resp.Data.IsBlack = isInBlackList
|
||||
//// resp.Data.OwnerUserID = req.CommID.FromUserID
|
||||
//// resp.Data.Remark = comment
|
||||
//// resp.Data.CreateTime = friendUserInfo.CreateTime
|
||||
////
|
||||
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp)
|
||||
//// return &resp, nil
|
||||
////
|
||||
//}
|
||||
|
||||
@ -8,3 +8,7 @@ import (
|
||||
func GetUserInfo(ctx context.Context, userID string) (interface{}, error) {
|
||||
return nil, errors.New("TODO:GetUserInfo")
|
||||
}
|
||||
|
||||
func GetUserInfoBatch(ctx context.Context, userIDs []string) (interface{}, error) {
|
||||
return nil, errors.New("TODO:GetUserInfo")
|
||||
}
|
||||
|
||||
@ -5,8 +5,11 @@ import (
|
||||
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
|
||||
"Open_IM/pkg/common/tools"
|
||||
pbGroup "Open_IM/pkg/proto/group"
|
||||
sdk "Open_IM/pkg/proto/sdk_ws"
|
||||
"Open_IM/pkg/utils"
|
||||
"context"
|
||||
"math/big"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
@ -19,16 +22,12 @@ func getDBGroupRequest(ctx context.Context, req *pbGroup.GroupApplicationRespons
|
||||
return dbGroupRequest
|
||||
}
|
||||
|
||||
func getDBGroupMember(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (dbGroupMember *imdb.GroupMember) {
|
||||
func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMember *imdb.GroupMember, err error) {
|
||||
dbGroupMember = &imdb.GroupMember{}
|
||||
utils.CopyStructFields(&dbGroupRequest, req)
|
||||
dbGroupRequest.UserID = req.FromUserID
|
||||
dbGroupRequest.HandleUserID = tools.OpUserID(ctx)
|
||||
dbGroupRequest.HandledTime = time.Now()
|
||||
|
||||
member := imdb.GroupMember{}
|
||||
member.GroupID = req.GroupID
|
||||
member.UserID = req.FromUserID
|
||||
member.GroupID = groupID
|
||||
member.UserID = userID
|
||||
member.RoleLevel = constant.GroupOrdinaryUsers
|
||||
member.OperatorUserID = tools.OpUserID(ctx)
|
||||
|
||||
@ -38,5 +37,20 @@ func getDBGroupMember(ctx context.Context, req *pbGroup.GroupApplicationResponse
|
||||
member.InviterUserID = request.InviterUserID
|
||||
member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
|
||||
|
||||
return dbGroupRequest
|
||||
return dbGroupMember, nil
|
||||
}
|
||||
|
||||
func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk.UserInfo, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func genGroupID(ctx context.Context, groupID string) string {
|
||||
if groupID != "" {
|
||||
return groupID
|
||||
}
|
||||
groupID = utils.Md5(tools.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
|
||||
bi := big.NewInt(0)
|
||||
bi.SetString(groupID[0:8], 16)
|
||||
groupID = bi.String()
|
||||
return groupID
|
||||
}
|
||||
|
||||
@ -24,7 +24,6 @@ import (
|
||||
"Open_IM/pkg/utils"
|
||||
"context"
|
||||
"errors"
|
||||
"math/big"
|
||||
"net"
|
||||
"strconv"
|
||||
"strings"
|
||||
@ -121,48 +120,36 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
|
||||
if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var groupOwnerNum int
|
||||
if req.OwnerUserID == "" {
|
||||
return nil, constant.ErrArgs.Wrap("no group owner")
|
||||
}
|
||||
var userIDs []string
|
||||
for _, info := range req.InitMemberList {
|
||||
if info.RoleLevel == constant.GroupOwner {
|
||||
groupOwnerNum++
|
||||
for _, ordinaryUserID := range req.InitMemberList {
|
||||
userIDs = append(userIDs, ordinaryUserID)
|
||||
}
|
||||
userIDs = append(userIDs, info.UserID)
|
||||
}
|
||||
if req.OwnerUserID != "" {
|
||||
groupOwnerNum++
|
||||
userIDs = append(userIDs, req.OwnerUserID)
|
||||
for _, adminUserID := range req.AdminUserIDs {
|
||||
userIDs = append(userIDs, adminUserID)
|
||||
}
|
||||
if groupOwnerNum != 1 {
|
||||
return nil, constant.ErrArgs.Wrap("groupOwnerNum != 1")
|
||||
}
|
||||
if utils.IsRepeatStringSlice(userIDs) {
|
||||
if utils.IsRepeatID(userIDs) {
|
||||
return nil, constant.ErrArgs.Wrap("group member is repeated")
|
||||
}
|
||||
users, err := rocksCache.GetUserInfoFromCacheBatch(ctx, userIDs)
|
||||
|
||||
users, err := getUsersInfo(ctx, userIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(users) != len(userIDs) {
|
||||
return nil, constant.ErrDatabase.Wrap("len(users from cache) != len(userIDs)")
|
||||
}
|
||||
userMap := make(map[string]*imdb.User)
|
||||
|
||||
userMap := make(map[string]*open_im_sdk.UserInfo)
|
||||
for i, user := range users {
|
||||
userMap[user.UserID] = users[i]
|
||||
}
|
||||
if err := s.DelGroupAndUserCache(ctx, "", userIDs); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := callbackBeforeCreateGroup(ctx, req); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
groupId := req.GroupInfo.GroupID
|
||||
if groupId == "" {
|
||||
groupId = utils.Md5(tools.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
|
||||
bi := big.NewInt(0)
|
||||
bi.SetString(groupId[0:8], 16)
|
||||
groupId = bi.String()
|
||||
}
|
||||
groupId := genGroupID(ctx, req.GroupInfo.GroupID)
|
||||
|
||||
groupInfo := imdb.Group{}
|
||||
utils.CopyStructFields(&groupInfo, req.GroupInfo)
|
||||
groupInfo.CreatorUserID = tools.OpUserID(ctx)
|
||||
@ -171,7 +158,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
|
||||
if groupInfo.NotificationUpdateTime.Unix() < 0 {
|
||||
groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0)
|
||||
}
|
||||
|
||||
if req.GroupInfo.GroupType != constant.SuperGroup {
|
||||
|
||||
var groupMembers []*imdb.GroupMember
|
||||
joinGroup := func(userID string, roleLevel int32) error {
|
||||
groupMember := &imdb.GroupMember{GroupID: groupId, RoleLevel: roleLevel, OperatorUserID: tools.OpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tools.OpUserID(ctx)}
|
||||
@ -193,9 +182,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
if err := (*imdb.GroupMember)(nil).Create(ctx, groupMembers); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
} else {
|
||||
if err := db.DB.CreateSuperGroup(groupId, userIDs, len(userIDs)); err != nil {
|
||||
return nil, err
|
||||
@ -673,30 +664,15 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
|
||||
return nil, err
|
||||
}
|
||||
if req.HandleResult == constant.GroupResponseAgree {
|
||||
user, err := imdb.GetUserByUserID(req.FromUserID)
|
||||
member, err := getDBGroupMember(ctx, req.GroupID, req.FromUserID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
request, err := (&imdb.GroupRequest{}).Take(ctx, req.GroupID, req.FromUserID)
|
||||
err = CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), member, groupInfo.Ex)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
member := imdb.GroupMember{}
|
||||
member.GroupID = req.GroupID
|
||||
member.UserID = req.FromUserID
|
||||
member.RoleLevel = constant.GroupOrdinaryUsers
|
||||
member.OperatorUserID = tools.OpUserID(ctx)
|
||||
member.FaceURL = user.FaceURL
|
||||
member.Nickname = user.Nickname
|
||||
member.JoinSource = request.JoinSource
|
||||
member.InviterUserID = request.InviterUserID
|
||||
member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
|
||||
err = CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &member, groupInfo.Ex)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{&member})
|
||||
err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{member})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
224
internal/utils/convert.go
Normal file
224
internal/utils/convert.go
Normal file
@ -0,0 +1,224 @@
|
||||
package utils
|
||||
|
||||
import (
|
||||
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
|
||||
sdk "Open_IM/pkg/proto/sdk_ws"
|
||||
utils2 "Open_IM/pkg/utils"
|
||||
utils "github.com/OpenIMSDK/open_utils"
|
||||
"time"
|
||||
)
|
||||
|
||||
func getUsersInfo(userIDs []string) ([]*sdk.UserInfo, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func getGroupOwnerInfo(groupID string) (*sdk.GroupMemberFullInfo, error) {
|
||||
return nil, nil
|
||||
}
|
||||
func getNumberOfGroupMember(groupID string) (int32, error) {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
type DBFriend struct {
|
||||
*imdb.Friend
|
||||
}
|
||||
|
||||
type PBFriend struct {
|
||||
*sdk.FriendInfo
|
||||
}
|
||||
|
||||
func (db *DBFriend) convert() (*sdk.FriendInfo, error) {
|
||||
pbFriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
|
||||
utils.CopyStructFields(pbFriend, db)
|
||||
user, err := getUsersInfo([]string{db.FriendUserID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
utils2.CopyStructFields(pbFriend.FriendUser, user[0])
|
||||
pbFriend.CreateTime = uint32(db.CreateTime.Unix())
|
||||
|
||||
pbFriend.FriendUser.CreateTime = uint32(db.CreateTime.Unix())
|
||||
return pbFriend, nil
|
||||
}
|
||||
|
||||
func (pb *PBFriend) convert() (*imdb.Friend, error) {
|
||||
dbFriend := &imdb.Friend{}
|
||||
utils2.CopyStructFields(dbFriend, pb)
|
||||
dbFriend.FriendUserID = pb.FriendUser.UserID
|
||||
dbFriend.CreateTime = utils2.UnixSecondToTime(int64(pb.CreateTime))
|
||||
return dbFriend, nil
|
||||
}
|
||||
|
||||
type DBFriendRequest struct {
|
||||
*imdb.FriendRequest
|
||||
}
|
||||
|
||||
type PBFriendRequest struct {
|
||||
*sdk.FriendRequest
|
||||
}
|
||||
|
||||
func (pb *PBFriendRequest) convert() (*imdb.FriendRequest, error) {
|
||||
dbFriendRequest := &imdb.FriendRequest{}
|
||||
utils.CopyStructFields(dbFriendRequest, pb)
|
||||
dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
|
||||
dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
|
||||
return dbFriendRequest, nil
|
||||
}
|
||||
func (db *DBFriendRequest) convert() (*sdk.FriendRequest, error) {
|
||||
pbFriendRequest := &sdk.FriendRequest{}
|
||||
utils.CopyStructFields(pbFriendRequest, db)
|
||||
user, err := getUsersInfo([]string{db.FromUserID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pbFriendRequest.FromNickname = user[0].Nickname
|
||||
pbFriendRequest.FromFaceURL = user[0].FaceURL
|
||||
pbFriendRequest.FromGender = user[0].Gender
|
||||
user, err = getUsersInfo([]string{db.ToUserID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pbFriendRequest.ToNickname = user[0].Nickname
|
||||
pbFriendRequest.ToFaceURL = user[0].FaceURL
|
||||
pbFriendRequest.ToGender = user[0].Gender
|
||||
pbFriendRequest.CreateTime = uint32(db.CreateTime.Unix())
|
||||
pbFriendRequest.HandleTime = uint32(db.HandleTime.Unix())
|
||||
return pbFriendRequest, nil
|
||||
}
|
||||
|
||||
type DBBlack struct {
|
||||
*imdb.Black
|
||||
}
|
||||
|
||||
type PBBlack struct {
|
||||
*sdk.BlackInfo
|
||||
}
|
||||
|
||||
func (pb *PBBlack) convert() (*imdb.Black, error) {
|
||||
dbBlack := &imdb.Black{}
|
||||
dbBlack.BlockUserID = pb.BlackUserInfo.UserID
|
||||
dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
|
||||
return dbBlack, nil
|
||||
}
|
||||
func (db *DBBlack) convert() (*sdk.BlackInfo, error) {
|
||||
pbBlack := &sdk.BlackInfo{}
|
||||
utils.CopyStructFields(pbBlack, db)
|
||||
pbBlack.CreateTime = uint32(db.CreateTime.Unix())
|
||||
user, err := getUsersInfo([]string{db.BlockUserID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
utils.CopyStructFields(pbBlack.BlackUserInfo, user)
|
||||
return pbBlack, nil
|
||||
}
|
||||
|
||||
type DBGroup struct {
|
||||
*imdb.Group
|
||||
}
|
||||
|
||||
type PBGroup struct {
|
||||
*sdk.GroupInfo
|
||||
}
|
||||
|
||||
func (pb *PBGroup) convert() (*imdb.Group, error) {
|
||||
dst := &imdb.Group{}
|
||||
utils.CopyStructFields(dst, pb)
|
||||
return dst, nil
|
||||
}
|
||||
func (db *DBGroup) convert() (*sdk.GroupInfo, error) {
|
||||
dst := &sdk.GroupInfo{}
|
||||
utils.CopyStructFields(dst, db)
|
||||
user, err := getGroupOwnerInfo(db.GroupID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dst.OwnerUserID = user.UserID
|
||||
|
||||
memberCount, err := getNumberOfGroupMember(db.GroupID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dst.MemberCount = uint32(memberCount)
|
||||
dst.CreateTime = uint32(db.CreateTime.Unix())
|
||||
dst.NotificationUpdateTime = uint32(db.NotificationUpdateTime.Unix())
|
||||
if db.NotificationUpdateTime.Unix() < 0 {
|
||||
dst.NotificationUpdateTime = 0
|
||||
}
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
type DBGroupMember struct {
|
||||
*imdb.GroupMember
|
||||
}
|
||||
|
||||
type PBGroupMember struct {
|
||||
*sdk.GroupMemberFullInfo
|
||||
}
|
||||
|
||||
func (pb *PBGroupMember) convert() (*imdb.GroupMember, error) {
|
||||
dst := &imdb.GroupMember{}
|
||||
utils.CopyStructFields(dst, pb)
|
||||
dst.JoinTime = utils.UnixSecondToTime(int64(pb.JoinTime))
|
||||
dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
|
||||
return dst, nil
|
||||
}
|
||||
func (db *DBGroupMember) convert() (*sdk.GroupMemberFullInfo, error) {
|
||||
dst := &sdk.GroupMemberFullInfo{}
|
||||
utils.CopyStructFields(dst, db)
|
||||
|
||||
user, err := getUsersInfo([]string{db.UserID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dst.AppMangerLevel = user[0].AppMangerLevel
|
||||
|
||||
dst.JoinTime = int32(db.JoinTime.Unix())
|
||||
if db.JoinTime.Unix() < 0 {
|
||||
dst.JoinTime = 0
|
||||
}
|
||||
dst.MuteEndTime = uint32(db.MuteEndTime.Unix())
|
||||
if dst.MuteEndTime < uint32(time.Now().Unix()) {
|
||||
dst.MuteEndTime = 0
|
||||
}
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
type DBGroupRequest struct {
|
||||
*imdb.GroupRequest
|
||||
}
|
||||
|
||||
type PBGroupRequest struct {
|
||||
*sdk.GroupRequest
|
||||
}
|
||||
|
||||
func (pb *PBGroupRequest) convert() (*imdb.GroupRequest, error) {
|
||||
dst := &imdb.GroupRequest{}
|
||||
utils.CopyStructFields(dst, pb)
|
||||
dst.ReqTime = utils.UnixSecondToTime(int64(pb.ReqTime))
|
||||
dst.HandledTime = utils.UnixSecondToTime(int64(pb.HandleTime))
|
||||
return dst, nil
|
||||
}
|
||||
func (db *DBGroupRequest) convert() (*sdk.GroupRequest, error) {
|
||||
dst := &sdk.GroupRequest{}
|
||||
utils.CopyStructFields(dst, db)
|
||||
dst.ReqTime = uint32(db.ReqTime.Unix())
|
||||
dst.HandleTime = uint32(db.HandledTime.Unix())
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
func UserOpenIMCopyDB(dst *imdb.User, src *open_im_sdk.UserInfo) {
|
||||
utils.CopyStructFields(dst, src)
|
||||
dst.Birth, _ = utils.TimeStringToTime(src.BirthStr)
|
||||
dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
|
||||
}
|
||||
|
||||
func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *imdb.User) {
|
||||
utils.CopyStructFields(dst, src)
|
||||
dst.CreateTime = uint32(src.CreateTime.Unix())
|
||||
//dst.Birth = uint32(src.Birth.Unix())
|
||||
dst.BirthStr = utils2.TimeToString(src.Birth)
|
||||
}
|
||||
|
||||
func UserDBCopyOpenIMPublicUser(dst *open_im_sdk.PublicUserInfo, src *imdb.User) {
|
||||
utils.CopyStructFields(dst, src)
|
||||
}
|
||||
@ -1,128 +1,267 @@
|
||||
package base_info
|
||||
|
||||
import open_im_sdk "Open_IM/pkg/proto/sdk_ws"
|
||||
//type ParamsCommFriend struct {
|
||||
// OperationID string `json:"operationID" binding:"required"`
|
||||
// ToUserID string `json:"toUserID" binding:"required"`
|
||||
// FromUserID string `json:"fromUserID" binding:"required"`
|
||||
//}
|
||||
//
|
||||
//type AddBlacklistReq struct {
|
||||
// ParamsCommFriend
|
||||
//}
|
||||
//type AddBlacklistResp struct {
|
||||
// CommResp
|
||||
//}
|
||||
//
|
||||
//type ImportFriendReq struct {
|
||||
// FriendUserIDList []string `json:"friendUserIDList" binding:"required"`
|
||||
// OperationID string `json:"operationID" binding:"required"`
|
||||
// FromUserID string `json:"fromUserID" binding:"required"`
|
||||
//}
|
||||
//type UserIDResult struct {
|
||||
// UserID string `json:"userID"`
|
||||
// Result int32 `json:"result"`
|
||||
//}
|
||||
//type ImportFriendResp struct {
|
||||
// CommResp
|
||||
// UserIDResultList []UserIDResult `json:"data"`
|
||||
//}
|
||||
//
|
||||
//type AddFriendReq struct {
|
||||
// ParamsCommFriend
|
||||
// ReqMsg string `json:"reqMsg"`
|
||||
//}
|
||||
//type AddFriendResp struct {
|
||||
// CommResp
|
||||
//}
|
||||
//
|
||||
//type AddFriendResponseReq struct {
|
||||
// ParamsCommFriend
|
||||
// Flag int32 `json:"flag" binding:"required,oneof=-1 0 1"`
|
||||
// HandleMsg string `json:"handleMsg"`
|
||||
//}
|
||||
//type AddFriendResponseResp struct {
|
||||
// CommResp
|
||||
//}
|
||||
//
|
||||
//type DeleteFriendReq struct {
|
||||
// ParamsCommFriend
|
||||
//}
|
||||
//type DeleteFriendResp struct {
|
||||
// CommResp
|
||||
//}
|
||||
//
|
||||
//type GetBlackListReq struct {
|
||||
// OperationID string `json:"operationID" binding:"required"`
|
||||
// FromUserID string `json:"fromUserID" binding:"required"`
|
||||
//}
|
||||
//type GetBlackListResp struct {
|
||||
// CommResp
|
||||
// BlackUserInfoList []*open_im_sdk.PublicUserInfo `json:"-"`
|
||||
// Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
//}
|
||||
//
|
||||
////type PublicUserInfo struct {
|
||||
//// UserID string `json:"userID"`
|
||||
//// Nickname string `json:"nickname"`
|
||||
//// FaceUrl string `json:"faceUrl"`
|
||||
//// Gender int32 `json:"gender"`
|
||||
////}
|
||||
//
|
||||
//type SetFriendRemarkReq struct {
|
||||
// ParamsCommFriend
|
||||
// Remark string `json:"remark"`
|
||||
//}
|
||||
//type SetFriendRemarkResp struct {
|
||||
// CommResp
|
||||
//}
|
||||
//
|
||||
//type RemoveBlacklistReq struct {
|
||||
// ParamsCommFriend
|
||||
//}
|
||||
//type RemoveBlacklistResp struct {
|
||||
// CommResp
|
||||
//}
|
||||
//
|
||||
//type IsFriendReq struct {
|
||||
// ParamsCommFriend
|
||||
//}
|
||||
//type Response struct {
|
||||
// Friend bool `json:"isFriend"`
|
||||
//}
|
||||
//type IsFriendResp struct {
|
||||
// CommResp
|
||||
// Response Response `json:"data"`
|
||||
//}
|
||||
//
|
||||
//type GetFriendsInfoReq struct {
|
||||
// ParamsCommFriend
|
||||
//}
|
||||
//type GetFriendsInfoResp struct {
|
||||
// CommResp
|
||||
// FriendInfoList []*open_im_sdk.FriendInfo `json:"-"`
|
||||
// Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
//}
|
||||
//
|
||||
//type GetFriendListReq struct {
|
||||
// OperationID string `json:"operationID" binding:"required"`
|
||||
// FromUserID string `json:"fromUserID" binding:"required"`
|
||||
//}
|
||||
//type GetFriendListResp struct {
|
||||
// CommResp
|
||||
// FriendInfoList []*open_im_sdk.FriendInfo `json:"-"`
|
||||
// Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
//}
|
||||
//
|
||||
//type GetFriendApplyListReq struct {
|
||||
// OperationID string `json:"operationID" binding:"required"`
|
||||
// FromUserID string `json:"fromUserID" binding:"required"`
|
||||
//}
|
||||
//type GetFriendApplyListResp struct {
|
||||
// CommResp
|
||||
// FriendRequestList []*open_im_sdk.FriendRequest `json:"-"`
|
||||
// Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
//}
|
||||
//
|
||||
//type GetSelfApplyListReq struct {
|
||||
// OperationID string `json:"operationID" binding:"required"`
|
||||
// FromUserID string `json:"fromUserID" binding:"required"`
|
||||
//}
|
||||
//type GetSelfApplyListResp struct {
|
||||
// CommResp
|
||||
// FriendRequestList []*open_im_sdk.FriendRequest `json:"-"`
|
||||
// Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
//}
|
||||
|
||||
type ParamsCommFriend struct {
|
||||
OperationID string `json:"operationID" binding:"required"`
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
type FriendInfo struct {
|
||||
UserID string `json:"userID"`
|
||||
Nickname string `json:"nickname"`
|
||||
FaceURL string `json:"faceURL"`
|
||||
Gender int32 `json:"gender"`
|
||||
Ex string `json:"ex"`
|
||||
}
|
||||
|
||||
type PublicUserInfo struct {
|
||||
UserID string `json:"userID"`
|
||||
Nickname string `json:"nickname"`
|
||||
FaceURL string `json:"faceURL"`
|
||||
Gender int32 `json:"gender"`
|
||||
Ex string `json:"ex"`
|
||||
}
|
||||
|
||||
type FriendRequest struct {
|
||||
FromUserID string `json:"fromUserID"`
|
||||
FromNickname string `json:"fromNickname"`
|
||||
FromFaceURL string `json:"fromFaceURL"`
|
||||
FromGender int32 `json:"fromGender"`
|
||||
ToUserID string `json:"toUserID"`
|
||||
ToNickname string `json:"toNickname"`
|
||||
ToFaceURL string `json:"toFaceURL"`
|
||||
ToGender int32 `json:"toGender"`
|
||||
HandleResult int32 `json:"handleResult"`
|
||||
ReqMsg string `json:"reqMsg"`
|
||||
CreateTime uint32 `json:"createTime"`
|
||||
HandlerUserID string `json:"handlerUserID"`
|
||||
HandleMsg string `json:"handleMsg"`
|
||||
HandleTime uint32 `json:"handleTime"`
|
||||
Ex string `json:"ex"`
|
||||
}
|
||||
|
||||
type AddBlacklistReq struct {
|
||||
ParamsCommFriend
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type AddBlacklistResp struct {
|
||||
CommResp
|
||||
}
|
||||
|
||||
type ImportFriendReq struct {
|
||||
FriendUserIDList []string `json:"friendUserIDList" binding:"required"`
|
||||
OperationID string `json:"operationID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type UserIDResult struct {
|
||||
UserID string `json:"userID"`
|
||||
Result int32 `json:"result"`
|
||||
}
|
||||
|
||||
type ImportFriendResp struct {
|
||||
CommResp
|
||||
UserIDResultList []UserIDResult `json:"data"`
|
||||
//CommResp
|
||||
}
|
||||
|
||||
type AddFriendReq struct {
|
||||
ParamsCommFriend
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
ReqMsg string `json:"reqMsg"`
|
||||
}
|
||||
type AddFriendResp struct {
|
||||
CommResp
|
||||
//CommResp
|
||||
}
|
||||
|
||||
type AddFriendResponseReq struct {
|
||||
ParamsCommFriend
|
||||
Flag int32 `json:"flag" binding:"required,oneof=-1 0 1"`
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
HandleResult int32 `json:"flag" binding:"required,oneof=-1 0 1"`
|
||||
HandleMsg string `json:"handleMsg"`
|
||||
}
|
||||
type AddFriendResponseResp struct {
|
||||
CommResp
|
||||
}
|
||||
|
||||
type DeleteFriendReq struct {
|
||||
ParamsCommFriend
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type DeleteFriendResp struct {
|
||||
CommResp
|
||||
}
|
||||
|
||||
type GetBlackListReq struct {
|
||||
OperationID string `json:"operationID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type GetBlackListResp struct {
|
||||
CommResp
|
||||
BlackUserInfoList []*open_im_sdk.PublicUserInfo `json:"-"`
|
||||
Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
BlackUserInfoList []PublicUserInfo `json:"blackUserInfoList"`
|
||||
}
|
||||
|
||||
//type PublicUserInfo struct {
|
||||
// UserID string `json:"userID"`
|
||||
// Nickname string `json:"nickname"`
|
||||
// FaceUrl string `json:"faceUrl"`
|
||||
// Gender int32 `json:"gender"`
|
||||
//}
|
||||
|
||||
type SetFriendRemarkReq struct {
|
||||
ParamsCommFriend
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
Remark string `json:"remark"`
|
||||
}
|
||||
type SetFriendRemarkResp struct {
|
||||
CommResp
|
||||
}
|
||||
|
||||
type RemoveBlackListReq struct {
|
||||
ParamsCommFriend
|
||||
type RemoveBlacklistReq struct {
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type RemoveBlackListResp struct {
|
||||
CommResp
|
||||
type RemoveBlacklistResp struct {
|
||||
}
|
||||
|
||||
type IsFriendReq struct {
|
||||
ParamsCommFriend
|
||||
ToUserID string `json:"toUserID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type Response struct {
|
||||
Friend bool `json:"isFriend"`
|
||||
}
|
||||
type IsFriendResp struct {
|
||||
CommResp
|
||||
Response Response `json:"data"`
|
||||
}
|
||||
|
||||
type GetFriendsInfoReq struct {
|
||||
ParamsCommFriend
|
||||
}
|
||||
type GetFriendsInfoResp struct {
|
||||
CommResp
|
||||
FriendInfoList []*open_im_sdk.FriendInfo `json:"-"`
|
||||
Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
}
|
||||
|
||||
type GetFriendListReq struct {
|
||||
OperationID string `json:"operationID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type GetFriendListResp struct {
|
||||
CommResp
|
||||
FriendInfoList []*open_im_sdk.FriendInfo `json:"-"`
|
||||
Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
OwnerUserID string `json:"ownerUserID"`
|
||||
Remark string `json:"remark"`
|
||||
CreateTime uint32 `json:"createTime"`
|
||||
AddSource int32 `json:"addSource"`
|
||||
OperatorUserID string `json:"operatorUserID"`
|
||||
Ex string `json:"ex"`
|
||||
//FriendUser *UserInfo // TODO
|
||||
}
|
||||
|
||||
type GetFriendApplyListReq struct {
|
||||
OperationID string `json:"operationID" binding:"required"`
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
|
||||
type GetFriendApplyListResp struct {
|
||||
CommResp
|
||||
FriendRequestList []*open_im_sdk.FriendRequest `json:"-"`
|
||||
Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
FriendRequestList []FriendRequest `json:"friendRequestList"`
|
||||
}
|
||||
|
||||
type GetSelfApplyListReq struct {
|
||||
@ -130,7 +269,5 @@ type GetSelfApplyListReq struct {
|
||||
FromUserID string `json:"fromUserID" binding:"required"`
|
||||
}
|
||||
type GetSelfApplyListResp struct {
|
||||
CommResp
|
||||
FriendRequestList []*open_im_sdk.FriendRequest `json:"-"`
|
||||
Data []map[string]interface{} `json:"data" swaggerignore:"true"`
|
||||
FriendRequestList []FriendRequest `json:"friendRequestList"`
|
||||
}
|
||||
|
||||
@ -1,83 +1,83 @@
|
||||
package mysql
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
func InsertToFriend(toInsertFollow *Friend) error {
|
||||
toInsertFollow.CreateTime = time.Now()
|
||||
err := FriendDB.Table("friends").Create(toInsertFollow).Error
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
|
||||
var friend Friend
|
||||
err := FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Take(&friend).Error
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &friend, err
|
||||
}
|
||||
|
||||
func GetFriendListByUserID(OwnerUserID string) ([]Friend, error) {
|
||||
var friends []Friend
|
||||
var x Friend
|
||||
x.OwnerUserID = OwnerUserID
|
||||
err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Find(&friends).Error
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return friends, nil
|
||||
}
|
||||
|
||||
func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
|
||||
var friendIDList []string
|
||||
err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return friendIDList, nil
|
||||
}
|
||||
|
||||
func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error {
|
||||
return FriendDB.Exec("update friends set remark=? where owner_user_id=? and friend_user_id=?", Remark, OwnerUserID, FriendUserID).Error
|
||||
}
|
||||
|
||||
func DeleteSingleFriendInfo(OwnerUserID, FriendUserID string) error {
|
||||
return FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Delete(Friend{}).Error
|
||||
}
|
||||
|
||||
type FriendUser struct {
|
||||
Friend
|
||||
Nickname string `gorm:"column:name;size:255"`
|
||||
}
|
||||
|
||||
func GetUserFriendsCMS(ownerUserID, friendUserName string, pageNumber, showNumber int32) (friendUserList []*FriendUser, count int64, err error) {
|
||||
db := FriendDB.Table("friends").
|
||||
Select("friends.*, users.name").
|
||||
Where("friends.owner_user_id=?", ownerUserID).Limit(int(showNumber)).
|
||||
Joins("left join users on friends.friend_user_id = users.user_id").
|
||||
Offset(int(showNumber * (pageNumber - 1)))
|
||||
if friendUserName != "" {
|
||||
db = db.Where("users.name like ?", fmt.Sprintf("%%%s%%", friendUserName))
|
||||
}
|
||||
if err = db.Count(&count).Error; err != nil {
|
||||
return
|
||||
}
|
||||
err = db.Find(&friendUserList).Error
|
||||
return
|
||||
}
|
||||
|
||||
func GetFriendByIDCMS(ownerUserID, friendUserID string) (friendUser *FriendUser, err error) {
|
||||
friendUser = &FriendUser{}
|
||||
err = FriendDB.Table("friends").
|
||||
Select("friends.*, users.name").
|
||||
Where("friends.owner_user_id=? and friends.friend_user_id=?", ownerUserID, friendUserID).
|
||||
Joins("left join users on friends.friend_user_id = users.user_id").
|
||||
Take(friendUser).Error
|
||||
return friendUser, err
|
||||
}
|
||||
//import (
|
||||
// "fmt"
|
||||
// "time"
|
||||
//)
|
||||
//
|
||||
//func InsertToFriend(toInsertFollow *Friend) error {
|
||||
// toInsertFollow.CreateTime = time.Now()
|
||||
// err := FriendDB.Table("friends").Create(toInsertFollow).Error
|
||||
// if err != nil {
|
||||
// return err
|
||||
// }
|
||||
// return nil
|
||||
//}
|
||||
//
|
||||
//func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
|
||||
// var friend Friend
|
||||
// err := FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Take(&friend).Error
|
||||
// if err != nil {
|
||||
// return nil, err
|
||||
// }
|
||||
// return &friend, err
|
||||
//}
|
||||
//
|
||||
//func GetFriendListByUserID(OwnerUserID string) ([]Friend, error) {
|
||||
// var friends []Friend
|
||||
// var x Friend
|
||||
// x.OwnerUserID = OwnerUserID
|
||||
// err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Find(&friends).Error
|
||||
// if err != nil {
|
||||
// return nil, err
|
||||
// }
|
||||
// return friends, nil
|
||||
//}
|
||||
//
|
||||
//func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
|
||||
// var friendIDList []string
|
||||
// err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error
|
||||
// if err != nil {
|
||||
// return nil, err
|
||||
// }
|
||||
// return friendIDList, nil
|
||||
//}
|
||||
//
|
||||
//func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error {
|
||||
// return FriendDB.Exec("update friends set remark=? where owner_user_id=? and friend_user_id=?", Remark, OwnerUserID, FriendUserID).Error
|
||||
//}
|
||||
//
|
||||
//func DeleteSingleFriendInfo(OwnerUserID, FriendUserID string) error {
|
||||
// return FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Delete(Friend{}).Error
|
||||
//}
|
||||
//
|
||||
//type FriendUser struct {
|
||||
// Friend
|
||||
// Nickname string `gorm:"column:name;size:255"`
|
||||
//}
|
||||
//
|
||||
//func GetUserFriendsCMS(ownerUserID, friendUserName string, pageNumber, showNumber int32) (friendUserList []*FriendUser, count int64, err error) {
|
||||
// db := FriendDB.Table("friends").
|
||||
// Select("friends.*, users.name").
|
||||
// Where("friends.owner_user_id=?", ownerUserID).Limit(int(showNumber)).
|
||||
// Joins("left join users on friends.friend_user_id = users.user_id").
|
||||
// Offset(int(showNumber * (pageNumber - 1)))
|
||||
// if friendUserName != "" {
|
||||
// db = db.Where("users.name like ?", fmt.Sprintf("%%%s%%", friendUserName))
|
||||
// }
|
||||
// if err = db.Count(&count).Error; err != nil {
|
||||
// return
|
||||
// }
|
||||
// err = db.Find(&friendUserList).Error
|
||||
// return
|
||||
//}
|
||||
//
|
||||
//func GetFriendByIDCMS(ownerUserID, friendUserID string) (friendUser *FriendUser, err error) {
|
||||
// friendUser = &FriendUser{}
|
||||
// err = FriendDB.Table("friends").
|
||||
// Select("friends.*, users.name").
|
||||
// Where("friends.owner_user_id=? and friends.friend_user_id=?", ownerUserID, friendUserID).
|
||||
// Joins("left join users on friends.friend_user_id = users.user_id").
|
||||
// Take(friendUser).Error
|
||||
// return friendUser, err
|
||||
//}
|
||||
|
||||
@ -27,15 +27,14 @@ func (f *Friend) Create(ctx context.Context, friends []*Friend) (err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
|
||||
}()
|
||||
err = utils.Wrap(f.db.Create(&friends).Error, "")
|
||||
return err
|
||||
return utils.Wrap(f.db.Create(&friends).Error, "")
|
||||
}
|
||||
|
||||
func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) {
|
||||
func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs string) (err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs)
|
||||
}()
|
||||
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
|
||||
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
|
||||
return err
|
||||
}
|
||||
|
||||
@ -53,17 +52,29 @@ func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) {
|
||||
return utils.Wrap(f.db.Updates(&friends).Error, "")
|
||||
}
|
||||
|
||||
func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark)
|
||||
}()
|
||||
return utils.Wrap(f.db.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "")
|
||||
}
|
||||
|
||||
func (f *Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
|
||||
}()
|
||||
err = utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
|
||||
return friends, err
|
||||
return friends, utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
|
||||
}
|
||||
|
||||
func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) {
|
||||
friend = &Friend{}
|
||||
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *friend)
|
||||
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
|
||||
return friend, err
|
||||
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend)
|
||||
return friend, utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
|
||||
}
|
||||
|
||||
func (f *Friend) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*Friend, err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "userID1", userID1, "userID2", userID2)
|
||||
}()
|
||||
return friends, utils.Wrap(f.db.Where("(owner_user_id = ? and friend_user_id = ?) or (owner_user_id = ? and friend_user_id = ?)", userID1, userID2, userID2, userID1).Find(&friends).Error, "")
|
||||
}
|
||||
|
||||
@ -65,13 +65,27 @@ func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends [
|
||||
return friends, err
|
||||
}
|
||||
|
||||
func (f *FriendRequest) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *FriendRequest, err error) {
|
||||
func (f *FriendRequest) Take(ctx context.Context, fromUserID, toUserID string) (friend *FriendRequest, err error) {
|
||||
friend = &FriendRequest{}
|
||||
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *friend)
|
||||
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
|
||||
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend)
|
||||
err = utils.Wrap(f.db.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "")
|
||||
return friend, err
|
||||
}
|
||||
|
||||
func (f *FriendRequest) FindToUserID(ctx context.Context, toUserID string) (friends []*FriendRequest, err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "toUserID", toUserID, "friends", friends)
|
||||
}()
|
||||
return friends, utils.Wrap(f.db.Where("to_user_id = ?", toUserID).Find(&friends).Error, "")
|
||||
}
|
||||
|
||||
func (f *FriendRequest) FindFromUserID(ctx context.Context, fromUserID string) (friends []*FriendRequest, err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "friends", friends)
|
||||
}()
|
||||
return friends, utils.Wrap(f.db.Where("from_user_id = ?", fromUserID).Find(&friends).Error, "")
|
||||
}
|
||||
|
||||
// who apply to add me
|
||||
func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]FriendRequest, error) {
|
||||
var usersInfo []FriendRequest
|
||||
|
||||
@ -9,7 +9,6 @@ import (
|
||||
"Open_IM/pkg/common/trace_log"
|
||||
"Open_IM/pkg/utils"
|
||||
"context"
|
||||
"github.com/OpenIMSDK/open_utils"
|
||||
"time"
|
||||
|
||||
go_redis "github.com/go-redis/redis/v8"
|
||||
@ -160,19 +159,6 @@ func CheckAccess(ctx context.Context, OpUserID string, OwnerUserID string) bool
|
||||
return false
|
||||
}
|
||||
|
||||
func CheckAccessV2(ctx context.Context, OpUserID string, OwnerUserID string) (err error) {
|
||||
defer func() {
|
||||
trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", OpUserID, "OwnerUserID", OwnerUserID)
|
||||
}()
|
||||
if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) {
|
||||
return nil
|
||||
}
|
||||
if OpUserID == OwnerUserID {
|
||||
return nil
|
||||
}
|
||||
return utils.Wrap(constant.ErrIdentity, open_utils.GetSelfFuncName())
|
||||
}
|
||||
|
||||
func CheckAccessV3(ctx context.Context, OwnerUserID string) (err error) {
|
||||
opUserID := tools.OpUserID(ctx)
|
||||
defer func() {
|
||||
|
||||
@ -22,8 +22,8 @@ func NewCtx(c *gin.Context, api string) context.Context {
|
||||
return context.WithValue(c, TraceLogKey, req)
|
||||
}
|
||||
|
||||
func NewCtx1(c *gin.Context, api, operationID string) context.Context {
|
||||
req := &ApiInfo{ApiName: api, GinCtx: c, OperationID: operationID, Funcs: &[]FuncInfo{}}
|
||||
func NewCtx1(c *gin.Context, api string) context.Context {
|
||||
req := &ApiInfo{ApiName: api, GinCtx: c, OperationID: c.GetHeader("operationID"), Funcs: &[]FuncInfo{}}
|
||||
return context.WithValue(c, TraceLogKey, req)
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -3,26 +3,19 @@ import "Open-IM-Server/pkg/proto/sdk_ws/ws.proto";
|
||||
option go_package = "Open_IM/pkg/proto/friend;friend";
|
||||
package friend;
|
||||
|
||||
message CommID{
|
||||
string OpUserID = 1;
|
||||
string OperationID = 2;
|
||||
string ToUserID = 4;
|
||||
string FromUserID = 5;
|
||||
}
|
||||
|
||||
|
||||
message GetFriendsInfoReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message GetFriendInfoResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
repeated server_api_params.FriendInfo FriendInfoList = 2;
|
||||
repeated server_api_params.FriendInfo FriendInfoList = 1;
|
||||
}
|
||||
|
||||
|
||||
message AddFriendReq{
|
||||
CommID CommID = 1;
|
||||
string ReqMsg = 2;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
string ReqMsg = 3;
|
||||
}
|
||||
message AddFriendResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
@ -31,115 +24,111 @@ message AddFriendResp{
|
||||
|
||||
message ImportFriendReq{
|
||||
repeated string FriendUserIDList = 1;
|
||||
string OperationID = 2;
|
||||
string FromUserID = 3;
|
||||
string OpUserID = 4;
|
||||
}
|
||||
message UserIDResult{
|
||||
string UserID = 1;
|
||||
int32 Result = 2;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
|
||||
message ImportFriendResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
repeated UserIDResult UserIDResultList = 2;
|
||||
}
|
||||
|
||||
|
||||
message GetFriendApplyListReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message GetFriendApplyListResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
repeated server_api_params.FriendRequest FriendRequestList = 2;
|
||||
repeated server_api_params.FriendRequest FriendRequestList = 1;
|
||||
}
|
||||
|
||||
|
||||
message GetFriendListReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message GetFriendListResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
repeated server_api_params.FriendInfo FriendInfoList = 2;
|
||||
repeated server_api_params.FriendInfo FriendInfoList = 1;
|
||||
}
|
||||
|
||||
|
||||
message AddBlacklistReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message AddBlacklistResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
message RemoveBlacklistReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message RemoveBlacklistResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
|
||||
}
|
||||
|
||||
message GetBlacklistReq{
|
||||
CommID CommID = 1;
|
||||
string FromUserID = 1;
|
||||
}
|
||||
message GetBlacklistResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
repeated server_api_params.PublicUserInfo BlackUserInfoList = 2;
|
||||
repeated server_api_params.PublicUserInfo BlackUserInfoList = 1;
|
||||
}
|
||||
|
||||
|
||||
message IsFriendReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message IsFriendResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
bool Response = 2;
|
||||
bool Response = 1;
|
||||
}
|
||||
|
||||
|
||||
message IsInBlackListReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message IsInBlackListResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
bool Response = 2;
|
||||
bool Response = 1;
|
||||
}
|
||||
|
||||
|
||||
message DeleteFriendReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message DeleteFriendResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
|
||||
}
|
||||
|
||||
//process
|
||||
message AddFriendResponseReq{
|
||||
CommID CommID = 1;
|
||||
int32 handleResult = 2;
|
||||
string handleMsg = 3;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
int32 handleResult = 3;
|
||||
string handleMsg = 4;
|
||||
}
|
||||
message AddFriendResponseResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
|
||||
}
|
||||
|
||||
message SetFriendRemarkReq{
|
||||
CommID CommID = 1;
|
||||
string Remark = 2;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
string Remark = 3;
|
||||
}
|
||||
message SetFriendRemarkResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
|
||||
}
|
||||
|
||||
message GetSelfApplyListReq{
|
||||
CommID CommID = 1;
|
||||
string ToUserID = 1;
|
||||
string FromUserID = 2;
|
||||
}
|
||||
message GetSelfApplyListResp{
|
||||
server_api_params.CommonResp commonResp = 1;
|
||||
repeated server_api_params.FriendRequest FriendRequestList = 2;
|
||||
repeated server_api_params.FriendRequest FriendRequestList = 1;
|
||||
}
|
||||
|
||||
service friend{
|
||||
// rpc getFriendsInfo(GetFriendsInfoReq) returns(GetFriendInfoResp);
|
||||
rpc addFriend(AddFriendReq) returns(AddFriendResp);
|
||||
rpc getFriendApplyList(GetFriendApplyListReq) returns(GetFriendApplyListResp);
|
||||
rpc getSelfApplyList(GetSelfApplyListReq) returns(GetSelfApplyListResp);
|
||||
@ -153,7 +142,4 @@ service friend{
|
||||
rpc addFriendResponse(AddFriendResponseReq) returns(AddFriendResponseResp);
|
||||
rpc setFriendRemark(SetFriendRemarkReq) returns(SetFriendRemarkResp);
|
||||
rpc importFriend(ImportFriendReq) returns(ImportFriendResp);
|
||||
|
||||
// rpc CheckFriendFromCache(IsFriendReq) returns(IsFriendResp);
|
||||
// rpc CheckBlockFromCache(IsInBlackListReq) returns(IsFriendResp);
|
||||
}
|
||||
@ -25,55 +25,10 @@ var _ = math.Inf
|
||||
// proto package needs to be updated.
|
||||
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
|
||||
|
||||
type GroupAddMemberInfo struct {
|
||||
UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
|
||||
RoleLevel int32 `protobuf:"varint,2,opt,name=roleLevel" json:"roleLevel,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *GroupAddMemberInfo) Reset() { *m = GroupAddMemberInfo{} }
|
||||
func (m *GroupAddMemberInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*GroupAddMemberInfo) ProtoMessage() {}
|
||||
func (*GroupAddMemberInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{0}
|
||||
}
|
||||
func (m *GroupAddMemberInfo) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GroupAddMemberInfo.Unmarshal(m, b)
|
||||
}
|
||||
func (m *GroupAddMemberInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_GroupAddMemberInfo.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (dst *GroupAddMemberInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_GroupAddMemberInfo.Merge(dst, src)
|
||||
}
|
||||
func (m *GroupAddMemberInfo) XXX_Size() int {
|
||||
return xxx_messageInfo_GroupAddMemberInfo.Size(m)
|
||||
}
|
||||
func (m *GroupAddMemberInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_GroupAddMemberInfo.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_GroupAddMemberInfo proto.InternalMessageInfo
|
||||
|
||||
func (m *GroupAddMemberInfo) GetUserID() string {
|
||||
if m != nil {
|
||||
return m.UserID
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *GroupAddMemberInfo) GetRoleLevel() int32 {
|
||||
if m != nil {
|
||||
return m.RoleLevel
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type CreateGroupReq struct {
|
||||
InitMemberList []*GroupAddMemberInfo `protobuf:"bytes,1,rep,name=initMemberList" json:"initMemberList,omitempty"`
|
||||
InitMemberList []string `protobuf:"bytes,1,rep,name=initMemberList" json:"initMemberList,omitempty"`
|
||||
GroupInfo *sdk_ws.GroupInfo `protobuf:"bytes,2,opt,name=groupInfo" json:"groupInfo,omitempty"`
|
||||
AdminUserIDs []string `protobuf:"bytes,3,rep,name=adminUserIDs" json:"adminUserIDs,omitempty"`
|
||||
OwnerUserID string `protobuf:"bytes,5,opt,name=ownerUserID" json:"ownerUserID,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
@ -84,7 +39,7 @@ func (m *CreateGroupReq) Reset() { *m = CreateGroupReq{} }
|
||||
func (m *CreateGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*CreateGroupReq) ProtoMessage() {}
|
||||
func (*CreateGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{1}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{0}
|
||||
}
|
||||
func (m *CreateGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CreateGroupReq.Unmarshal(m, b)
|
||||
@ -104,7 +59,7 @@ func (m *CreateGroupReq) XXX_DiscardUnknown() {
|
||||
|
||||
var xxx_messageInfo_CreateGroupReq proto.InternalMessageInfo
|
||||
|
||||
func (m *CreateGroupReq) GetInitMemberList() []*GroupAddMemberInfo {
|
||||
func (m *CreateGroupReq) GetInitMemberList() []string {
|
||||
if m != nil {
|
||||
return m.InitMemberList
|
||||
}
|
||||
@ -118,6 +73,13 @@ func (m *CreateGroupReq) GetGroupInfo() *sdk_ws.GroupInfo {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CreateGroupReq) GetAdminUserIDs() []string {
|
||||
if m != nil {
|
||||
return m.AdminUserIDs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CreateGroupReq) GetOwnerUserID() string {
|
||||
if m != nil {
|
||||
return m.OwnerUserID
|
||||
@ -136,7 +98,7 @@ func (m *CreateGroupResp) Reset() { *m = CreateGroupResp{} }
|
||||
func (m *CreateGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*CreateGroupResp) ProtoMessage() {}
|
||||
func (*CreateGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{2}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{1}
|
||||
}
|
||||
func (m *CreateGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CreateGroupResp.Unmarshal(m, b)
|
||||
@ -174,7 +136,7 @@ func (m *GetGroupsInfoReq) Reset() { *m = GetGroupsInfoReq{} }
|
||||
func (m *GetGroupsInfoReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupsInfoReq) ProtoMessage() {}
|
||||
func (*GetGroupsInfoReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{3}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{2}
|
||||
}
|
||||
func (m *GetGroupsInfoReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupsInfoReq.Unmarshal(m, b)
|
||||
@ -212,7 +174,7 @@ func (m *GetGroupsInfoResp) Reset() { *m = GetGroupsInfoResp{} }
|
||||
func (m *GetGroupsInfoResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupsInfoResp) ProtoMessage() {}
|
||||
func (*GetGroupsInfoResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{4}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{3}
|
||||
}
|
||||
func (m *GetGroupsInfoResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupsInfoResp.Unmarshal(m, b)
|
||||
@ -250,7 +212,7 @@ func (m *SetGroupInfoReq) Reset() { *m = SetGroupInfoReq{} }
|
||||
func (m *SetGroupInfoReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*SetGroupInfoReq) ProtoMessage() {}
|
||||
func (*SetGroupInfoReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{5}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{4}
|
||||
}
|
||||
func (m *SetGroupInfoReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SetGroupInfoReq.Unmarshal(m, b)
|
||||
@ -287,7 +249,7 @@ func (m *SetGroupInfoResp) Reset() { *m = SetGroupInfoResp{} }
|
||||
func (m *SetGroupInfoResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*SetGroupInfoResp) ProtoMessage() {}
|
||||
func (*SetGroupInfoResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{6}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{5}
|
||||
}
|
||||
func (m *SetGroupInfoResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SetGroupInfoResp.Unmarshal(m, b)
|
||||
@ -319,7 +281,7 @@ func (m *GetGroupApplicationListReq) Reset() { *m = GetGroupApplicationL
|
||||
func (m *GetGroupApplicationListReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupApplicationListReq) ProtoMessage() {}
|
||||
func (*GetGroupApplicationListReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{7}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{6}
|
||||
}
|
||||
func (m *GetGroupApplicationListReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupApplicationListReq.Unmarshal(m, b)
|
||||
@ -365,7 +327,7 @@ func (m *GetGroupApplicationListResp) Reset() { *m = GetGroupApplication
|
||||
func (m *GetGroupApplicationListResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupApplicationListResp) ProtoMessage() {}
|
||||
func (*GetGroupApplicationListResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{8}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{7}
|
||||
}
|
||||
func (m *GetGroupApplicationListResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupApplicationListResp.Unmarshal(m, b)
|
||||
@ -411,7 +373,7 @@ func (m *GetUserReqApplicationListReq) Reset() { *m = GetUserReqApplicat
|
||||
func (m *GetUserReqApplicationListReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetUserReqApplicationListReq) ProtoMessage() {}
|
||||
func (*GetUserReqApplicationListReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{9}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{8}
|
||||
}
|
||||
func (m *GetUserReqApplicationListReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetUserReqApplicationListReq.Unmarshal(m, b)
|
||||
@ -457,7 +419,7 @@ func (m *GetUserReqApplicationListResp) Reset() { *m = GetUserReqApplica
|
||||
func (m *GetUserReqApplicationListResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetUserReqApplicationListResp) ProtoMessage() {}
|
||||
func (*GetUserReqApplicationListResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{10}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{9}
|
||||
}
|
||||
func (m *GetUserReqApplicationListResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetUserReqApplicationListResp.Unmarshal(m, b)
|
||||
@ -504,7 +466,7 @@ func (m *TransferGroupOwnerReq) Reset() { *m = TransferGroupOwnerReq{} }
|
||||
func (m *TransferGroupOwnerReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*TransferGroupOwnerReq) ProtoMessage() {}
|
||||
func (*TransferGroupOwnerReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{11}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{10}
|
||||
}
|
||||
func (m *TransferGroupOwnerReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_TransferGroupOwnerReq.Unmarshal(m, b)
|
||||
@ -555,7 +517,7 @@ func (m *TransferGroupOwnerResp) Reset() { *m = TransferGroupOwnerResp{}
|
||||
func (m *TransferGroupOwnerResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*TransferGroupOwnerResp) ProtoMessage() {}
|
||||
func (*TransferGroupOwnerResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{12}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{11}
|
||||
}
|
||||
func (m *TransferGroupOwnerResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_TransferGroupOwnerResp.Unmarshal(m, b)
|
||||
@ -589,7 +551,7 @@ func (m *JoinGroupReq) Reset() { *m = JoinGroupReq{} }
|
||||
func (m *JoinGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*JoinGroupReq) ProtoMessage() {}
|
||||
func (*JoinGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{13}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{12}
|
||||
}
|
||||
func (m *JoinGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_JoinGroupReq.Unmarshal(m, b)
|
||||
@ -647,7 +609,7 @@ func (m *JoinGroupResp) Reset() { *m = JoinGroupResp{} }
|
||||
func (m *JoinGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*JoinGroupResp) ProtoMessage() {}
|
||||
func (*JoinGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{14}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{13}
|
||||
}
|
||||
func (m *JoinGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_JoinGroupResp.Unmarshal(m, b)
|
||||
@ -681,7 +643,7 @@ func (m *GroupApplicationResponseReq) Reset() { *m = GroupApplicationRes
|
||||
func (m *GroupApplicationResponseReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GroupApplicationResponseReq) ProtoMessage() {}
|
||||
func (*GroupApplicationResponseReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{15}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{14}
|
||||
}
|
||||
func (m *GroupApplicationResponseReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GroupApplicationResponseReq.Unmarshal(m, b)
|
||||
@ -739,7 +701,7 @@ func (m *GroupApplicationResponseResp) Reset() { *m = GroupApplicationRe
|
||||
func (m *GroupApplicationResponseResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GroupApplicationResponseResp) ProtoMessage() {}
|
||||
func (*GroupApplicationResponseResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{16}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{15}
|
||||
}
|
||||
func (m *GroupApplicationResponseResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GroupApplicationResponseResp.Unmarshal(m, b)
|
||||
@ -770,7 +732,7 @@ func (m *QuitGroupReq) Reset() { *m = QuitGroupReq{} }
|
||||
func (m *QuitGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*QuitGroupReq) ProtoMessage() {}
|
||||
func (*QuitGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{17}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{16}
|
||||
}
|
||||
func (m *QuitGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_QuitGroupReq.Unmarshal(m, b)
|
||||
@ -807,7 +769,7 @@ func (m *QuitGroupResp) Reset() { *m = QuitGroupResp{} }
|
||||
func (m *QuitGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*QuitGroupResp) ProtoMessage() {}
|
||||
func (*QuitGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{18}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{17}
|
||||
}
|
||||
func (m *QuitGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_QuitGroupResp.Unmarshal(m, b)
|
||||
@ -840,7 +802,7 @@ func (m *GetGroupMemberListReq) Reset() { *m = GetGroupMemberListReq{} }
|
||||
func (m *GetGroupMemberListReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMemberListReq) ProtoMessage() {}
|
||||
func (*GetGroupMemberListReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{19}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{18}
|
||||
}
|
||||
func (m *GetGroupMemberListReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMemberListReq.Unmarshal(m, b)
|
||||
@ -893,7 +855,7 @@ func (m *GetGroupMemberListResp) Reset() { *m = GetGroupMemberListResp{}
|
||||
func (m *GetGroupMemberListResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMemberListResp) ProtoMessage() {}
|
||||
func (*GetGroupMemberListResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{20}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{19}
|
||||
}
|
||||
func (m *GetGroupMemberListResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMemberListResp.Unmarshal(m, b)
|
||||
@ -939,7 +901,7 @@ func (m *GetGroupMembersInfoReq) Reset() { *m = GetGroupMembersInfoReq{}
|
||||
func (m *GetGroupMembersInfoReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMembersInfoReq) ProtoMessage() {}
|
||||
func (*GetGroupMembersInfoReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{21}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{20}
|
||||
}
|
||||
func (m *GetGroupMembersInfoReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMembersInfoReq.Unmarshal(m, b)
|
||||
@ -984,7 +946,7 @@ func (m *GetGroupMembersInfoResp) Reset() { *m = GetGroupMembersInfoResp
|
||||
func (m *GetGroupMembersInfoResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMembersInfoResp) ProtoMessage() {}
|
||||
func (*GetGroupMembersInfoResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{22}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{21}
|
||||
}
|
||||
func (m *GetGroupMembersInfoResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMembersInfoResp.Unmarshal(m, b)
|
||||
@ -1024,7 +986,7 @@ func (m *KickGroupMemberReq) Reset() { *m = KickGroupMemberReq{} }
|
||||
func (m *KickGroupMemberReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*KickGroupMemberReq) ProtoMessage() {}
|
||||
func (*KickGroupMemberReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{23}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{22}
|
||||
}
|
||||
func (m *KickGroupMemberReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_KickGroupMemberReq.Unmarshal(m, b)
|
||||
@ -1077,7 +1039,7 @@ func (m *Id2Result) Reset() { *m = Id2Result{} }
|
||||
func (m *Id2Result) String() string { return proto.CompactTextString(m) }
|
||||
func (*Id2Result) ProtoMessage() {}
|
||||
func (*Id2Result) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{24}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{23}
|
||||
}
|
||||
func (m *Id2Result) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_Id2Result.Unmarshal(m, b)
|
||||
@ -1122,7 +1084,7 @@ func (m *KickGroupMemberResp) Reset() { *m = KickGroupMemberResp{} }
|
||||
func (m *KickGroupMemberResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*KickGroupMemberResp) ProtoMessage() {}
|
||||
func (*KickGroupMemberResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{25}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{24}
|
||||
}
|
||||
func (m *KickGroupMemberResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_KickGroupMemberResp.Unmarshal(m, b)
|
||||
@ -1161,7 +1123,7 @@ func (m *GetJoinedGroupListReq) Reset() { *m = GetJoinedGroupListReq{} }
|
||||
func (m *GetJoinedGroupListReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetJoinedGroupListReq) ProtoMessage() {}
|
||||
func (*GetJoinedGroupListReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{26}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{25}
|
||||
}
|
||||
func (m *GetJoinedGroupListReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetJoinedGroupListReq.Unmarshal(m, b)
|
||||
@ -1207,7 +1169,7 @@ func (m *GetJoinedGroupListResp) Reset() { *m = GetJoinedGroupListResp{}
|
||||
func (m *GetJoinedGroupListResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetJoinedGroupListResp) ProtoMessage() {}
|
||||
func (*GetJoinedGroupListResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{27}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{26}
|
||||
}
|
||||
func (m *GetJoinedGroupListResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetJoinedGroupListResp.Unmarshal(m, b)
|
||||
@ -1254,7 +1216,7 @@ func (m *InviteUserToGroupReq) Reset() { *m = InviteUserToGroupReq{} }
|
||||
func (m *InviteUserToGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*InviteUserToGroupReq) ProtoMessage() {}
|
||||
func (*InviteUserToGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{28}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{27}
|
||||
}
|
||||
func (m *InviteUserToGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_InviteUserToGroupReq.Unmarshal(m, b)
|
||||
@ -1306,7 +1268,7 @@ func (m *InviteUserToGroupResp) Reset() { *m = InviteUserToGroupResp{} }
|
||||
func (m *InviteUserToGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*InviteUserToGroupResp) ProtoMessage() {}
|
||||
func (*InviteUserToGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{29}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{28}
|
||||
}
|
||||
func (m *InviteUserToGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_InviteUserToGroupResp.Unmarshal(m, b)
|
||||
@ -1346,7 +1308,7 @@ func (m *GetGroupAllMemberReq) Reset() { *m = GetGroupAllMemberReq{} }
|
||||
func (m *GetGroupAllMemberReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupAllMemberReq) ProtoMessage() {}
|
||||
func (*GetGroupAllMemberReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{30}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{29}
|
||||
}
|
||||
func (m *GetGroupAllMemberReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupAllMemberReq.Unmarshal(m, b)
|
||||
@ -1398,7 +1360,7 @@ func (m *GetGroupAllMemberResp) Reset() { *m = GetGroupAllMemberResp{} }
|
||||
func (m *GetGroupAllMemberResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupAllMemberResp) ProtoMessage() {}
|
||||
func (*GetGroupAllMemberResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{31}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{30}
|
||||
}
|
||||
func (m *GetGroupAllMemberResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupAllMemberResp.Unmarshal(m, b)
|
||||
@ -1438,7 +1400,7 @@ func (m *CMSGroup) Reset() { *m = CMSGroup{} }
|
||||
func (m *CMSGroup) String() string { return proto.CompactTextString(m) }
|
||||
func (*CMSGroup) ProtoMessage() {}
|
||||
func (*CMSGroup) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{32}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{31}
|
||||
}
|
||||
func (m *CMSGroup) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CMSGroup.Unmarshal(m, b)
|
||||
@ -1492,7 +1454,7 @@ func (m *GetGroupsReq) Reset() { *m = GetGroupsReq{} }
|
||||
func (m *GetGroupsReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupsReq) ProtoMessage() {}
|
||||
func (*GetGroupsReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{33}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{32}
|
||||
}
|
||||
func (m *GetGroupsReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupsReq.Unmarshal(m, b)
|
||||
@ -1545,7 +1507,7 @@ func (m *GetGroupsResp) Reset() { *m = GetGroupsResp{} }
|
||||
func (m *GetGroupsResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupsResp) ProtoMessage() {}
|
||||
func (*GetGroupsResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{34}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{33}
|
||||
}
|
||||
func (m *GetGroupsResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupsResp.Unmarshal(m, b)
|
||||
@ -1590,7 +1552,7 @@ func (m *GetGroupMemberReq) Reset() { *m = GetGroupMemberReq{} }
|
||||
func (m *GetGroupMemberReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMemberReq) ProtoMessage() {}
|
||||
func (*GetGroupMemberReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{35}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{34}
|
||||
}
|
||||
func (m *GetGroupMemberReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMemberReq.Unmarshal(m, b)
|
||||
@ -1630,7 +1592,7 @@ func (m *GetGroupMembersCMSReq) Reset() { *m = GetGroupMembersCMSReq{} }
|
||||
func (m *GetGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMembersCMSReq) ProtoMessage() {}
|
||||
func (*GetGroupMembersCMSReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{36}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{35}
|
||||
}
|
||||
func (m *GetGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMembersCMSReq.Unmarshal(m, b)
|
||||
@ -1684,7 +1646,7 @@ func (m *GetGroupMembersCMSResp) Reset() { *m = GetGroupMembersCMSResp{}
|
||||
func (m *GetGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupMembersCMSResp) ProtoMessage() {}
|
||||
func (*GetGroupMembersCMSResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{37}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{36}
|
||||
}
|
||||
func (m *GetGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupMembersCMSResp.Unmarshal(m, b)
|
||||
@ -1736,7 +1698,7 @@ func (m *DismissGroupReq) Reset() { *m = DismissGroupReq{} }
|
||||
func (m *DismissGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*DismissGroupReq) ProtoMessage() {}
|
||||
func (*DismissGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{38}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{37}
|
||||
}
|
||||
func (m *DismissGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_DismissGroupReq.Unmarshal(m, b)
|
||||
@ -1773,7 +1735,7 @@ func (m *DismissGroupResp) Reset() { *m = DismissGroupResp{} }
|
||||
func (m *DismissGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*DismissGroupResp) ProtoMessage() {}
|
||||
func (*DismissGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{39}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{38}
|
||||
}
|
||||
func (m *DismissGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_DismissGroupResp.Unmarshal(m, b)
|
||||
@ -1806,7 +1768,7 @@ func (m *MuteGroupMemberReq) Reset() { *m = MuteGroupMemberReq{} }
|
||||
func (m *MuteGroupMemberReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*MuteGroupMemberReq) ProtoMessage() {}
|
||||
func (*MuteGroupMemberReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{40}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{39}
|
||||
}
|
||||
func (m *MuteGroupMemberReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_MuteGroupMemberReq.Unmarshal(m, b)
|
||||
@ -1857,7 +1819,7 @@ func (m *MuteGroupMemberResp) Reset() { *m = MuteGroupMemberResp{} }
|
||||
func (m *MuteGroupMemberResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*MuteGroupMemberResp) ProtoMessage() {}
|
||||
func (*MuteGroupMemberResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{41}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{40}
|
||||
}
|
||||
func (m *MuteGroupMemberResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_MuteGroupMemberResp.Unmarshal(m, b)
|
||||
@ -1889,7 +1851,7 @@ func (m *CancelMuteGroupMemberReq) Reset() { *m = CancelMuteGroupMemberR
|
||||
func (m *CancelMuteGroupMemberReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*CancelMuteGroupMemberReq) ProtoMessage() {}
|
||||
func (*CancelMuteGroupMemberReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{42}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{41}
|
||||
}
|
||||
func (m *CancelMuteGroupMemberReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CancelMuteGroupMemberReq.Unmarshal(m, b)
|
||||
@ -1933,7 +1895,7 @@ func (m *CancelMuteGroupMemberResp) Reset() { *m = CancelMuteGroupMember
|
||||
func (m *CancelMuteGroupMemberResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*CancelMuteGroupMemberResp) ProtoMessage() {}
|
||||
func (*CancelMuteGroupMemberResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{43}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{42}
|
||||
}
|
||||
func (m *CancelMuteGroupMemberResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CancelMuteGroupMemberResp.Unmarshal(m, b)
|
||||
@ -1964,7 +1926,7 @@ func (m *MuteGroupReq) Reset() { *m = MuteGroupReq{} }
|
||||
func (m *MuteGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*MuteGroupReq) ProtoMessage() {}
|
||||
func (*MuteGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{44}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{43}
|
||||
}
|
||||
func (m *MuteGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_MuteGroupReq.Unmarshal(m, b)
|
||||
@ -2001,7 +1963,7 @@ func (m *MuteGroupResp) Reset() { *m = MuteGroupResp{} }
|
||||
func (m *MuteGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*MuteGroupResp) ProtoMessage() {}
|
||||
func (*MuteGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{45}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{44}
|
||||
}
|
||||
func (m *MuteGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_MuteGroupResp.Unmarshal(m, b)
|
||||
@ -2032,7 +1994,7 @@ func (m *CancelMuteGroupReq) Reset() { *m = CancelMuteGroupReq{} }
|
||||
func (m *CancelMuteGroupReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*CancelMuteGroupReq) ProtoMessage() {}
|
||||
func (*CancelMuteGroupReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{46}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{45}
|
||||
}
|
||||
func (m *CancelMuteGroupReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CancelMuteGroupReq.Unmarshal(m, b)
|
||||
@ -2069,7 +2031,7 @@ func (m *CancelMuteGroupResp) Reset() { *m = CancelMuteGroupResp{} }
|
||||
func (m *CancelMuteGroupResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*CancelMuteGroupResp) ProtoMessage() {}
|
||||
func (*CancelMuteGroupResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{47}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{46}
|
||||
}
|
||||
func (m *CancelMuteGroupResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CancelMuteGroupResp.Unmarshal(m, b)
|
||||
@ -2102,7 +2064,7 @@ func (m *SetGroupMemberNicknameReq) Reset() { *m = SetGroupMemberNicknam
|
||||
func (m *SetGroupMemberNicknameReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*SetGroupMemberNicknameReq) ProtoMessage() {}
|
||||
func (*SetGroupMemberNicknameReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{48}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{47}
|
||||
}
|
||||
func (m *SetGroupMemberNicknameReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SetGroupMemberNicknameReq.Unmarshal(m, b)
|
||||
@ -2153,7 +2115,7 @@ func (m *SetGroupMemberNicknameResp) Reset() { *m = SetGroupMemberNickna
|
||||
func (m *SetGroupMemberNicknameResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*SetGroupMemberNicknameResp) ProtoMessage() {}
|
||||
func (*SetGroupMemberNicknameResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{49}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{48}
|
||||
}
|
||||
func (m *SetGroupMemberNicknameResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SetGroupMemberNicknameResp.Unmarshal(m, b)
|
||||
@ -2185,7 +2147,7 @@ func (m *GetJoinedSuperGroupListReq) Reset() { *m = GetJoinedSuperGroupL
|
||||
func (m *GetJoinedSuperGroupListReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetJoinedSuperGroupListReq) ProtoMessage() {}
|
||||
func (*GetJoinedSuperGroupListReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{50}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{49}
|
||||
}
|
||||
func (m *GetJoinedSuperGroupListReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetJoinedSuperGroupListReq.Unmarshal(m, b)
|
||||
@ -2231,7 +2193,7 @@ func (m *GetJoinedSuperGroupListResp) Reset() { *m = GetJoinedSuperGroup
|
||||
func (m *GetJoinedSuperGroupListResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetJoinedSuperGroupListResp) ProtoMessage() {}
|
||||
func (*GetJoinedSuperGroupListResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{51}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{50}
|
||||
}
|
||||
func (m *GetJoinedSuperGroupListResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetJoinedSuperGroupListResp.Unmarshal(m, b)
|
||||
@ -2276,7 +2238,7 @@ func (m *GetSuperGroupsInfoReq) Reset() { *m = GetSuperGroupsInfoReq{} }
|
||||
func (m *GetSuperGroupsInfoReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetSuperGroupsInfoReq) ProtoMessage() {}
|
||||
func (*GetSuperGroupsInfoReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{52}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{51}
|
||||
}
|
||||
func (m *GetSuperGroupsInfoReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetSuperGroupsInfoReq.Unmarshal(m, b)
|
||||
@ -2314,7 +2276,7 @@ func (m *GetSuperGroupsInfoResp) Reset() { *m = GetSuperGroupsInfoResp{}
|
||||
func (m *GetSuperGroupsInfoResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetSuperGroupsInfoResp) ProtoMessage() {}
|
||||
func (*GetSuperGroupsInfoResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{53}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{52}
|
||||
}
|
||||
func (m *GetSuperGroupsInfoResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetSuperGroupsInfoResp.Unmarshal(m, b)
|
||||
@ -2357,7 +2319,7 @@ func (m *SetGroupMemberInfoReq) Reset() { *m = SetGroupMemberInfoReq{} }
|
||||
func (m *SetGroupMemberInfoReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*SetGroupMemberInfoReq) ProtoMessage() {}
|
||||
func (*SetGroupMemberInfoReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{54}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{53}
|
||||
}
|
||||
func (m *SetGroupMemberInfoReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SetGroupMemberInfoReq.Unmarshal(m, b)
|
||||
@ -2429,7 +2391,7 @@ func (m *SetGroupMemberInfoResp) Reset() { *m = SetGroupMemberInfoResp{}
|
||||
func (m *SetGroupMemberInfoResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*SetGroupMemberInfoResp) ProtoMessage() {}
|
||||
func (*SetGroupMemberInfoResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{55}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{54}
|
||||
}
|
||||
func (m *SetGroupMemberInfoResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SetGroupMemberInfoResp.Unmarshal(m, b)
|
||||
@ -2460,7 +2422,7 @@ func (m *GetGroupAbstractInfoReq) Reset() { *m = GetGroupAbstractInfoReq
|
||||
func (m *GetGroupAbstractInfoReq) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupAbstractInfoReq) ProtoMessage() {}
|
||||
func (*GetGroupAbstractInfoReq) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{56}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{55}
|
||||
}
|
||||
func (m *GetGroupAbstractInfoReq) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupAbstractInfoReq.Unmarshal(m, b)
|
||||
@ -2500,7 +2462,7 @@ func (m *GroupAbstractInfo) Reset() { *m = GroupAbstractInfo{} }
|
||||
func (m *GroupAbstractInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*GroupAbstractInfo) ProtoMessage() {}
|
||||
func (*GroupAbstractInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{57}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{56}
|
||||
}
|
||||
func (m *GroupAbstractInfo) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GroupAbstractInfo.Unmarshal(m, b)
|
||||
@ -2552,7 +2514,7 @@ func (m *GetGroupAbstractInfoResp) Reset() { *m = GetGroupAbstractInfoRe
|
||||
func (m *GetGroupAbstractInfoResp) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetGroupAbstractInfoResp) ProtoMessage() {}
|
||||
func (*GetGroupAbstractInfoResp) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_group_908b1d0f9beeddfc, []int{58}
|
||||
return fileDescriptor_group_4fa7763fd681832d, []int{57}
|
||||
}
|
||||
func (m *GetGroupAbstractInfoResp) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_GetGroupAbstractInfoResp.Unmarshal(m, b)
|
||||
@ -2580,7 +2542,6 @@ func (m *GetGroupAbstractInfoResp) GetGroupAbstractInfos() []*GroupAbstractInfo
|
||||
}
|
||||
|
||||
func init() {
|
||||
proto.RegisterType((*GroupAddMemberInfo)(nil), "group.GroupAddMemberInfo")
|
||||
proto.RegisterType((*CreateGroupReq)(nil), "group.CreateGroupReq")
|
||||
proto.RegisterType((*CreateGroupResp)(nil), "group.CreateGroupResp")
|
||||
proto.RegisterType((*GetGroupsInfoReq)(nil), "group.GetGroupsInfoReq")
|
||||
@ -3586,129 +3547,128 @@ var _Group_serviceDesc = grpc.ServiceDesc{
|
||||
Metadata: "group/group.proto",
|
||||
}
|
||||
|
||||
func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_908b1d0f9beeddfc) }
|
||||
func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_4fa7763fd681832d) }
|
||||
|
||||
var fileDescriptor_group_908b1d0f9beeddfc = []byte{
|
||||
// 1925 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x5f, 0x73, 0x1b, 0x49,
|
||||
0x11, 0xaf, 0x95, 0x23, 0xc7, 0x6e, 0xdb, 0xb1, 0x33, 0x8e, 0x1c, 0x65, 0xa3, 0x24, 0xbe, 0xb9,
|
||||
0x70, 0xb8, 0x20, 0xb1, 0x29, 0x1f, 0x5c, 0x71, 0x1c, 0x55, 0x47, 0x2e, 0x21, 0x39, 0xdf, 0x59,
|
||||
0x36, 0x59, 0xe5, 0xb8, 0xaa, 0x2b, 0xc0, 0xac, 0xa5, 0xd1, 0xde, 0xc6, 0xd2, 0xee, 0x78, 0x67,
|
||||
0xd7, 0xb9, 0xa2, 0xa0, 0x0a, 0x78, 0xe0, 0x89, 0x3f, 0x0f, 0x3c, 0xf2, 0x46, 0xf1, 0x05, 0xf8,
|
||||
0x08, 0x7c, 0x33, 0x6a, 0x67, 0x66, 0x47, 0xb3, 0x3b, 0xb3, 0x92, 0x1d, 0xc4, 0x8b, 0xaa, 0xb6,
|
||||
0xa7, 0x7b, 0xba, 0xa7, 0xa7, 0xbb, 0xe7, 0xd7, 0x2d, 0xb8, 0x19, 0x24, 0x71, 0x46, 0xf7, 0xf8,
|
||||
0xef, 0x2e, 0x4d, 0xe2, 0x34, 0x46, 0x4d, 0xfe, 0xe1, 0xee, 0x1c, 0x53, 0x12, 0x3d, 0x3e, 0xe8,
|
||||
0x3e, 0xee, 0x91, 0xe4, 0x82, 0x24, 0x7b, 0xf4, 0x2c, 0xd8, 0xe3, 0x0c, 0x7b, 0x6c, 0x70, 0x76,
|
||||
0xf2, 0x86, 0xed, 0xbd, 0x61, 0x42, 0xc0, 0xdd, 0x9d, 0xc9, 0x99, 0xf8, 0x94, 0x92, 0x44, 0xf2,
|
||||
0xe3, 0xcf, 0x00, 0xbd, 0xc8, 0x55, 0x3c, 0x19, 0x0c, 0xba, 0x64, 0x7c, 0x4a, 0x92, 0x83, 0x68,
|
||||
0x18, 0xa3, 0x2d, 0x58, 0xcc, 0x18, 0x49, 0x0e, 0x9e, 0xb5, 0x9d, 0x6d, 0x67, 0x67, 0xd9, 0x93,
|
||||
0x5f, 0xa8, 0x03, 0xcb, 0x49, 0x3c, 0x22, 0x87, 0xe4, 0x82, 0x8c, 0xda, 0x8d, 0x6d, 0x67, 0xa7,
|
||||
0xe9, 0x4d, 0x08, 0xf8, 0xdf, 0x0e, 0xdc, 0x78, 0x9a, 0x10, 0x3f, 0x25, 0x7c, 0x4b, 0x8f, 0x9c,
|
||||
0xa3, 0x27, 0x70, 0x23, 0x8c, 0xc2, 0x54, 0x6c, 0x7d, 0x18, 0xb2, 0xb4, 0xed, 0x6c, 0x2f, 0xec,
|
||||
0xac, 0xec, 0xdf, 0xd9, 0x15, 0xa7, 0x34, 0x75, 0x7b, 0x15, 0x01, 0xf4, 0x23, 0x58, 0xe6, 0xbc,
|
||||
0xf9, 0x22, 0xd7, 0xb9, 0xb2, 0xdf, 0xd9, 0x65, 0xfc, 0x74, 0x27, 0x3e, 0x0d, 0x4f, 0xa8, 0x9f,
|
||||
0xf8, 0x63, 0x26, 0x76, 0xe2, 0x1b, 0x4c, 0xd8, 0xd1, 0x36, 0xac, 0xc4, 0x6f, 0x22, 0x92, 0x7c,
|
||||
0x21, 0x0e, 0xd3, 0xe4, 0x87, 0xd1, 0x49, 0xb8, 0x0b, 0xeb, 0x25, 0x93, 0x19, 0x2d, 0x2b, 0x5c,
|
||||
0xb8, 0x92, 0x42, 0xfc, 0x7d, 0xd8, 0x78, 0x41, 0x52, 0xbe, 0xc4, 0xf8, 0x1a, 0x39, 0xcf, 0x8d,
|
||||
0x10, 0x0c, 0xcf, 0x94, 0x03, 0x96, 0x3d, 0x9d, 0x84, 0xbf, 0x84, 0x9b, 0x15, 0x29, 0x46, 0xd1,
|
||||
0x27, 0xb0, 0xa6, 0xf6, 0xe5, 0x82, 0x0b, 0xdc, 0x73, 0xd3, 0x4d, 0x29, 0x8b, 0xe0, 0x13, 0x58,
|
||||
0xef, 0xc9, 0x8d, 0x0b, 0x6b, 0x0e, 0x61, 0x5d, 0xf1, 0x3c, 0x8f, 0x93, 0x1e, 0x49, 0xf9, 0x1d,
|
||||
0xaf, 0xec, 0xe3, 0x69, 0x1b, 0x0b, 0x4e, 0xaf, 0x2a, 0x8a, 0x11, 0x6c, 0x94, 0x15, 0x30, 0x8a,
|
||||
0xff, 0xe8, 0x80, 0x5b, 0x1c, 0xe7, 0x09, 0xa5, 0xa3, 0xb0, 0xef, 0xa7, 0x61, 0x1c, 0xe5, 0x06,
|
||||
0xe5, 0x06, 0x3c, 0x03, 0xa0, 0x7e, 0x10, 0x46, 0x9c, 0x28, 0x75, 0x3f, 0xb4, 0xe8, 0xf6, 0xc8,
|
||||
0x79, 0x46, 0x58, 0xfa, 0x33, 0xc5, 0xeb, 0x69, 0x72, 0xe8, 0x3e, 0xc0, 0x30, 0x89, 0xc7, 0xf2,
|
||||
0x62, 0x17, 0xf8, 0xc5, 0x6a, 0x14, 0xfc, 0x7b, 0x07, 0xee, 0xd6, 0x1a, 0xc1, 0x28, 0xba, 0x05,
|
||||
0xcd, 0x34, 0x4e, 0xfd, 0x11, 0x37, 0xa0, 0xe9, 0x89, 0x0f, 0xf4, 0x39, 0x6c, 0x04, 0x32, 0x74,
|
||||
0x73, 0xdd, 0x9a, 0xdb, 0x1f, 0xd4, 0x79, 0x47, 0xb2, 0x7a, 0x86, 0x20, 0xfe, 0x2d, 0x74, 0x5e,
|
||||
0x90, 0x34, 0xb7, 0xc7, 0x23, 0xe7, 0x16, 0x47, 0xd4, 0x25, 0x59, 0xd9, 0x41, 0x8d, 0xb7, 0x73,
|
||||
0x50, 0x7e, 0x0b, 0xf7, 0xa6, 0xa8, 0xbf, 0x92, 0x0b, 0x1a, 0x6f, 0xeb, 0x82, 0x3f, 0x38, 0xd0,
|
||||
0x7a, 0x95, 0xf8, 0x11, 0x1b, 0x92, 0x84, 0xb3, 0x1e, 0xe7, 0xa9, 0x97, 0x1f, 0xbe, 0x0d, 0xd7,
|
||||
0x65, 0x06, 0xc8, 0xd3, 0x17, 0x9f, 0xe8, 0x3d, 0xb8, 0x11, 0x8f, 0x06, 0xc7, 0x5a, 0xda, 0x36,
|
||||
0x38, 0x43, 0x85, 0x9a, 0xf3, 0x45, 0xe4, 0x8d, 0xce, 0x27, 0xa2, 0xa0, 0x42, 0xc5, 0x6d, 0xd8,
|
||||
0xb2, 0x99, 0xc0, 0x28, 0xfe, 0xab, 0x03, 0xab, 0x9f, 0xc5, 0x61, 0xa4, 0xaa, 0x55, 0xbd, 0x51,
|
||||
0xf7, 0x01, 0x12, 0x72, 0xde, 0x25, 0x8c, 0xf9, 0x01, 0x91, 0x06, 0x69, 0x94, 0x7c, 0xfd, 0x75,
|
||||
0x1c, 0x46, 0xbd, 0x38, 0x4b, 0xfa, 0x84, 0xd7, 0x99, 0xa6, 0xa7, 0x51, 0xd0, 0x43, 0x58, 0x0b,
|
||||
0xa3, 0x8b, 0x30, 0x55, 0xb6, 0x2e, 0xf2, 0x2d, 0xca, 0x44, 0xbc, 0x0e, 0x6b, 0x9a, 0x3d, 0x8c,
|
||||
0xe2, 0x7f, 0xe4, 0x51, 0x5c, 0x09, 0xe1, 0x7c, 0x21, 0x8e, 0x18, 0xa9, 0x18, 0xbc, 0x60, 0x18,
|
||||
0xac, 0xe5, 0xc7, 0xb5, 0x6a, 0x7e, 0xe4, 0xeb, 0x5f, 0xfb, 0xd1, 0x60, 0x44, 0x06, 0x5d, 0x16,
|
||||
0xc8, 0xc2, 0xa8, 0x51, 0x10, 0x86, 0x55, 0xf1, 0xe5, 0x11, 0x96, 0x8d, 0x52, 0x6e, 0x6f, 0xd3,
|
||||
0x2b, 0xd1, 0xf0, 0x7d, 0xe8, 0xd4, 0x1b, 0xc7, 0x28, 0xde, 0x81, 0xd5, 0x97, 0x59, 0x98, 0xce,
|
||||
0x76, 0x6f, 0x7e, 0x70, 0x8d, 0x93, 0x51, 0xfc, 0x37, 0x07, 0x5a, 0x45, 0xfa, 0x4e, 0xde, 0x82,
|
||||
0xe9, 0x77, 0xb4, 0x05, 0x8b, 0xc3, 0x70, 0x94, 0x92, 0x84, 0x1f, 0xb7, 0xe9, 0xc9, 0xaf, 0x39,
|
||||
0xe5, 0xd3, 0x05, 0x6c, 0xd9, 0x0c, 0xaa, 0xcd, 0xa3, 0xe7, 0x00, 0xe3, 0xc9, 0xab, 0x27, 0x8a,
|
||||
0xc8, 0x7b, 0x75, 0x19, 0x24, 0x76, 0x7c, 0x9e, 0x8d, 0x46, 0xbc, 0x8a, 0x6a, 0x92, 0xd8, 0xab,
|
||||
0xea, 0x55, 0xef, 0xca, 0xd4, 0x68, 0xd5, 0x74, 0x37, 0xf8, 0x83, 0xa3, 0xef, 0xe9, 0xc3, 0x6d,
|
||||
0xeb, 0x9e, 0x8c, 0xce, 0xcd, 0xec, 0x04, 0xd0, 0xe7, 0x61, 0xff, 0x4c, 0x63, 0x9b, 0x6e, 0xf2,
|
||||
0x77, 0x60, 0xe3, 0x2c, 0xec, 0x9f, 0x91, 0x81, 0x88, 0x4f, 0xcd, 0x70, 0x83, 0x9e, 0x5f, 0x74,
|
||||
0x42, 0x7c, 0x16, 0x47, 0x32, 0xe8, 0xe5, 0x17, 0xfe, 0x08, 0x96, 0x0f, 0x06, 0xfb, 0x22, 0x38,
|
||||
0x6b, 0xab, 0x2b, 0x17, 0xe6, 0x21, 0x2d, 0xf0, 0x8b, 0xfc, 0xc2, 0x5d, 0xd8, 0x34, 0x0c, 0x66,
|
||||
0x14, 0x7d, 0x00, 0x6b, 0x61, 0xb1, 0xa7, 0xe6, 0x92, 0x0d, 0x89, 0x5f, 0x94, 0x3e, 0xaf, 0xcc,
|
||||
0x86, 0x7f, 0xc7, 0xe3, 0x37, 0xcf, 0x66, 0x32, 0xe0, 0x7b, 0x16, 0xf1, 0x5b, 0x4e, 0x4c, 0xc7,
|
||||
0x48, 0xcc, 0xf9, 0x44, 0xeb, 0x6b, 0x1e, 0x35, 0x86, 0xfa, 0xda, 0x68, 0x2d, 0x30, 0xcf, 0xa5,
|
||||
0x81, 0xc6, 0x84, 0x1d, 0x5f, 0xc0, 0xad, 0x03, 0x5e, 0xc6, 0xf2, 0x13, 0xbc, 0x8a, 0x6d, 0xe9,
|
||||
0xbe, 0x60, 0x64, 0xaa, 0xbc, 0xc0, 0x6b, 0xfa, 0x05, 0xa2, 0x47, 0x70, 0x53, 0x14, 0x44, 0x3d,
|
||||
0x0a, 0x9a, 0x3c, 0x0a, 0xcc, 0x05, 0x7c, 0x0c, 0x2d, 0x8b, 0xde, 0xff, 0xe1, 0xce, 0x7e, 0x05,
|
||||
0xb7, 0x14, 0x64, 0x18, 0x8d, 0x2e, 0x13, 0xb5, 0x5b, 0xb0, 0x18, 0x0f, 0x87, 0x8c, 0xa4, 0x45,
|
||||
0xc9, 0x11, 0x5f, 0xb9, 0x93, 0xfb, 0x71, 0x16, 0xa5, 0xf2, 0x25, 0x10, 0x1f, 0xf8, 0x64, 0x52,
|
||||
0xd3, 0xb4, 0xfd, 0xe7, 0x98, 0x74, 0xff, 0x74, 0x60, 0xe9, 0x69, 0xb7, 0xc7, 0xd9, 0xca, 0x30,
|
||||
0xd6, 0xb9, 0x1a, 0x6e, 0xde, 0x05, 0x14, 0xa8, 0xb7, 0x32, 0x77, 0xef, 0x91, 0x3f, 0x2e, 0x9e,
|
||||
0x3d, 0xcb, 0x4a, 0x9e, 0xbd, 0x65, 0xaa, 0xba, 0x73, 0x83, 0x8e, 0xff, 0xec, 0xc0, 0xaa, 0x42,
|
||||
0xbb, 0xf3, 0x03, 0x84, 0x1d, 0x79, 0x5c, 0xcd, 0xd2, 0x09, 0xa1, 0x3e, 0x16, 0xf1, 0x2b, 0x58,
|
||||
0xd3, 0xac, 0x61, 0x14, 0x7d, 0x1b, 0x16, 0xf9, 0x1a, 0x93, 0xad, 0xca, 0xba, 0x0c, 0x9b, 0xc2,
|
||||
0xb1, 0x9e, 0x5c, 0x46, 0x2e, 0x2c, 0x71, 0xc2, 0x51, 0x36, 0xe6, 0x9b, 0x36, 0x3d, 0xf5, 0x8d,
|
||||
0x1f, 0x4f, 0x10, 0xfd, 0x25, 0xe2, 0x08, 0xff, 0xdd, 0x78, 0xee, 0xd8, 0xd3, 0x6e, 0x6f, 0x7a,
|
||||
0xec, 0xb9, 0xb0, 0x94, 0x95, 0x6f, 0x46, 0x7d, 0x57, 0x5c, 0xba, 0xf0, 0x96, 0x45, 0xe4, 0x3f,
|
||||
0x8e, 0xf1, 0xf6, 0x70, 0xab, 0x18, 0x45, 0x3f, 0x81, 0xeb, 0x22, 0xee, 0x0a, 0x2f, 0x5d, 0x36,
|
||||
0x5c, 0x0b, 0x31, 0xf4, 0x53, 0x4b, 0x9d, 0xfb, 0x96, 0xd5, 0x44, 0x81, 0x28, 0xea, 0xfb, 0x00,
|
||||
0xb1, 0xe3, 0x51, 0x36, 0x66, 0xf2, 0x1a, 0x34, 0x0a, 0xfe, 0x2e, 0xac, 0x3f, 0x0b, 0xd9, 0x38,
|
||||
0x64, 0x6c, 0x76, 0x5d, 0xca, 0xbb, 0x99, 0x32, 0x33, 0xa3, 0xf8, 0x35, 0xa0, 0x6e, 0x26, 0xdb,
|
||||
0x43, 0xeb, 0x55, 0x9a, 0xb5, 0x2d, 0xd3, 0x41, 0x57, 0xf1, 0xee, 0x60, 0x58, 0x1d, 0x67, 0x29,
|
||||
0x19, 0xf4, 0x48, 0x3f, 0x8e, 0x06, 0x8c, 0x57, 0x86, 0x35, 0xaf, 0x44, 0xc3, 0x2d, 0xd8, 0x34,
|
||||
0x74, 0x31, 0x8a, 0x0f, 0xa1, 0xfd, 0xd4, 0x8f, 0xfa, 0x64, 0x34, 0x0f, 0x43, 0xf0, 0x5d, 0xb8,
|
||||
0x53, 0xb3, 0x9b, 0x80, 0x6c, 0x8a, 0x3c, 0xdd, 0x57, 0xeb, 0xb0, 0xa6, 0x71, 0x32, 0x8a, 0x77,
|
||||
0x01, 0x55, 0xf6, 0x9d, 0xbe, 0x41, 0x0b, 0x36, 0x0d, 0x7e, 0x46, 0x71, 0x08, 0x77, 0x7a, 0xa5,
|
||||
0x98, 0x3b, 0x0a, 0xfb, 0x67, 0x91, 0x3f, 0x26, 0x33, 0xb3, 0x21, 0x92, 0x8c, 0x45, 0x36, 0x14,
|
||||
0xdf, 0x9a, 0x27, 0x9a, 0x25, 0x4f, 0x74, 0xc0, 0xad, 0x53, 0xc5, 0x28, 0xfe, 0x0d, 0xef, 0x62,
|
||||
0xc5, 0x13, 0xda, 0xcb, 0xa8, 0xec, 0x1e, 0xe6, 0xdb, 0xc5, 0x4e, 0x2c, 0x6b, 0x94, 0x2c, 0x8b,
|
||||
0x79, 0xf3, 0x6a, 0xd7, 0xfd, 0x7f, 0x79, 0xc3, 0x3f, 0xe4, 0xf5, 0x67, 0xa2, 0xea, 0x0a, 0xc3,
|
||||
0x8b, 0x5f, 0xf0, 0x22, 0x61, 0x88, 0xce, 0x69, 0x82, 0xf1, 0xaf, 0x06, 0xb4, 0xca, 0x97, 0x34,
|
||||
0x1b, 0xfe, 0xd6, 0x78, 0x15, 0xfd, 0x50, 0x8b, 0x91, 0xa6, 0x7c, 0x10, 0x83, 0x38, 0x0e, 0x46,
|
||||
0x44, 0x0c, 0xc3, 0x4e, 0xb3, 0xe1, 0x6e, 0x2f, 0x4d, 0xc2, 0x28, 0xf8, 0xb9, 0x3f, 0xca, 0x88,
|
||||
0x16, 0x41, 0x1f, 0xc0, 0xf5, 0xa1, 0xdf, 0x27, 0x5f, 0x78, 0x87, 0xbc, 0x11, 0x9a, 0x25, 0x58,
|
||||
0x30, 0xa3, 0x0f, 0xf5, 0x79, 0xd9, 0x75, 0x2e, 0x79, 0xd7, 0x90, 0x3c, 0x88, 0xd2, 0xf7, 0xf7,
|
||||
0x85, 0xe0, 0x84, 0x1b, 0x3d, 0x82, 0x06, 0xf9, 0xa6, 0xbd, 0x74, 0x09, 0x6d, 0x0d, 0xf2, 0x4d,
|
||||
0xde, 0xe4, 0xda, 0xbc, 0xc4, 0x28, 0xfe, 0xc1, 0x04, 0xeb, 0x3f, 0x39, 0x65, 0x69, 0xe2, 0xf7,
|
||||
0xd3, 0xc2, 0x83, 0x2e, 0x2c, 0x49, 0x97, 0x31, 0x79, 0xb1, 0xea, 0x1b, 0xff, 0xc5, 0x81, 0x9b,
|
||||
0x86, 0xd0, 0x14, 0x9f, 0x3f, 0x92, 0xd3, 0xcb, 0x6e, 0x51, 0x7a, 0x4f, 0x49, 0x22, 0x11, 0xb6,
|
||||
0xb9, 0x80, 0xbe, 0x07, 0x9b, 0x41, 0xb9, 0x93, 0xfa, 0xd4, 0x67, 0x5f, 0xf3, 0x0a, 0x71, 0xcd,
|
||||
0xb3, 0x2d, 0xe1, 0x01, 0xb4, 0xed, 0xc7, 0x60, 0x14, 0x7d, 0x2a, 0xd1, 0x8a, 0xbe, 0x50, 0xbc,
|
||||
0x4b, 0xed, 0xd2, 0xa0, 0x51, 0x97, 0xb4, 0xc8, 0xec, 0xff, 0x69, 0x03, 0xc4, 0xc4, 0x15, 0xfd,
|
||||
0x18, 0x56, 0xfa, 0x93, 0xb9, 0x20, 0x6a, 0x15, 0x20, 0xa0, 0x34, 0xde, 0x74, 0xb7, 0x6c, 0x64,
|
||||
0x8e, 0x40, 0x97, 0x5f, 0x17, 0x8d, 0x3c, 0xda, 0x94, 0x4c, 0xfa, 0xa8, 0xc1, 0xbd, 0x65, 0x12,
|
||||
0x85, 0xdc, 0x79, 0xd1, 0x07, 0x2b, 0x39, 0xbd, 0x87, 0x56, 0x72, 0xa5, 0x76, 0x99, 0x67, 0x9a,
|
||||
0x3e, 0x40, 0x44, 0xb7, 0x8b, 0x63, 0x57, 0x86, 0x91, 0x6e, 0xdb, 0xbe, 0xc0, 0x28, 0xfa, 0x18,
|
||||
0x56, 0x99, 0x36, 0xca, 0x43, 0xc5, 0xd9, 0x2a, 0x03, 0x44, 0xf7, 0xb6, 0x95, 0xce, 0x28, 0xfa,
|
||||
0x35, 0xdc, 0x0e, 0xec, 0x13, 0x37, 0xf4, 0x4e, 0x45, 0xab, 0x39, 0x0d, 0x73, 0xf1, 0x2c, 0x16,
|
||||
0x46, 0xd1, 0x10, 0xee, 0x04, 0x75, 0x23, 0x2d, 0xf4, 0xee, 0x64, 0x83, 0xda, 0x99, 0x9b, 0xfb,
|
||||
0x70, 0x36, 0x13, 0xa3, 0xe8, 0x25, 0xa0, 0xd4, 0x18, 0x19, 0xa1, 0x8e, 0x94, 0xb5, 0x0e, 0xb4,
|
||||
0xdc, 0x7b, 0x53, 0x56, 0x19, 0x45, 0x7d, 0x68, 0x07, 0x35, 0xb3, 0x12, 0x84, 0x4b, 0x31, 0x6a,
|
||||
0x9d, 0xf4, 0xb8, 0xef, 0xce, 0xe4, 0x11, 0x76, 0x07, 0xc6, 0x8c, 0x42, 0xd9, 0x6d, 0x9d, 0xa7,
|
||||
0x28, 0xbb, 0x6b, 0x86, 0x1b, 0xaf, 0x60, 0x33, 0x30, 0x47, 0x05, 0xc8, 0x2e, 0xa5, 0xa2, 0xec,
|
||||
0xfe, 0xb4, 0x65, 0x9e, 0xb1, 0xeb, 0x67, 0xe5, 0x66, 0x1b, 0x15, 0xff, 0x08, 0x98, 0x53, 0x03,
|
||||
0xd7, 0xad, 0x5b, 0x52, 0x47, 0xae, 0x34, 0xba, 0xfa, 0x91, 0xcd, 0x16, 0x5c, 0x3f, 0xb2, 0xad,
|
||||
0x43, 0x3e, 0x2a, 0xba, 0x50, 0xad, 0xaf, 0x44, 0x77, 0x8b, 0xe6, 0xd1, 0xd2, 0xe9, 0xba, 0x9d,
|
||||
0xfa, 0x45, 0x91, 0xd4, 0x2a, 0xdb, 0x54, 0x52, 0xeb, 0x1d, 0x90, 0x4a, 0xea, 0x72, 0x23, 0xf2,
|
||||
0x12, 0x90, 0x89, 0xbe, 0x6b, 0x6e, 0x53, 0xb6, 0x0b, 0x35, 0xb7, 0xa9, 0x60, 0xfb, 0xc7, 0xb0,
|
||||
0xaa, 0x03, 0x5c, 0x95, 0xe3, 0x15, 0x88, 0xac, 0x72, 0xbc, 0x8a, 0x86, 0xf3, 0x8b, 0xab, 0xc0,
|
||||
0x46, 0x75, 0x71, 0x26, 0x38, 0x55, 0x17, 0x67, 0x41, 0x9a, 0xe8, 0x2b, 0x68, 0x59, 0x61, 0x28,
|
||||
0x7a, 0x50, 0xd4, 0xd4, 0x1a, 0xc8, 0xeb, 0x6e, 0x4f, 0x67, 0x10, 0x1e, 0x57, 0x64, 0xe5, 0x71,
|
||||
0x1d, 0x96, 0x2a, 0x8f, 0x97, 0xb0, 0x67, 0x7e, 0xba, 0xca, 0xa6, 0xea, 0x74, 0x26, 0xb4, 0x55,
|
||||
0xa7, 0xb3, 0xa0, 0xd8, 0xbc, 0x16, 0xd6, 0x00, 0x38, 0xbd, 0x16, 0xd6, 0x80, 0x4b, 0xbd, 0x16,
|
||||
0xd6, 0x62, 0x40, 0x11, 0x1d, 0x15, 0xd8, 0xa5, 0x47, 0x87, 0x09, 0xe6, 0xf4, 0xe8, 0xb0, 0xe1,
|
||||
0xb5, 0x5f, 0x56, 0x41, 0x44, 0x81, 0x87, 0xd1, 0x76, 0xa5, 0xe6, 0x1b, 0xc8, 0xdc, 0x7d, 0x67,
|
||||
0x06, 0x87, 0xb0, 0xd8, 0xc4, 0x28, 0xca, 0x62, 0x2b, 0xc8, 0x53, 0x16, 0xdb, 0xc1, 0x0d, 0xfa,
|
||||
0x52, 0x9b, 0xd8, 0xe8, 0x38, 0xa5, 0x5a, 0x7f, 0x2a, 0xc8, 0xc7, 0x7d, 0x30, 0x75, 0x9d, 0xd1,
|
||||
0x4f, 0x1e, 0x7c, 0x75, 0xef, 0x98, 0x92, 0xe8, 0xe4, 0xa0, 0xab, 0xfd, 0x83, 0xca, 0x65, 0x3e,
|
||||
0xe2, 0xbf, 0xa7, 0x8b, 0x9c, 0xf4, 0xfe, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x50, 0xb3,
|
||||
0x74, 0xb4, 0x1d, 0x00, 0x00,
|
||||
var fileDescriptor_group_4fa7763fd681832d = []byte{
|
||||
// 1907 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x5f, 0x73, 0xdb, 0xc6,
|
||||
0x11, 0x1f, 0x50, 0xa6, 0x2c, 0xad, 0xa5, 0x50, 0x3e, 0x99, 0x32, 0x0d, 0xcb, 0xb6, 0x72, 0x71,
|
||||
0x53, 0x4d, 0x6b, 0x53, 0x1d, 0xa5, 0xcd, 0x34, 0x4d, 0x67, 0xd2, 0xc4, 0xae, 0x1d, 0x35, 0xa2,
|
||||
0x54, 0x83, 0x4e, 0x33, 0x93, 0x69, 0xab, 0x42, 0xe4, 0x11, 0x81, 0x45, 0x02, 0x27, 0x1c, 0x20,
|
||||
0x67, 0x3a, 0xed, 0x4c, 0xdb, 0x87, 0x3e, 0xf5, 0xcf, 0x43, 0x1f, 0xfb, 0xd6, 0xe9, 0xa7, 0xe8,
|
||||
0x5b, 0xbf, 0x59, 0x07, 0x77, 0x87, 0xe3, 0x01, 0x77, 0x20, 0x25, 0x97, 0x79, 0xe1, 0x0c, 0xf6,
|
||||
0x76, 0xef, 0xf6, 0xf6, 0xdf, 0xfd, 0x76, 0x09, 0x37, 0x83, 0x24, 0xce, 0xe8, 0x1e, 0xff, 0xed,
|
||||
0xd2, 0x24, 0x4e, 0x63, 0xd4, 0xe4, 0x1f, 0xee, 0xee, 0x31, 0x25, 0xd1, 0xe3, 0x83, 0xde, 0xe3,
|
||||
0x3e, 0x49, 0x2e, 0x48, 0xb2, 0x47, 0xcf, 0x82, 0x3d, 0xce, 0xb0, 0xc7, 0x86, 0x67, 0x27, 0xaf,
|
||||
0xd9, 0xde, 0x6b, 0x26, 0x04, 0xdc, 0xee, 0x5c, 0xce, 0xc4, 0xa7, 0x94, 0x24, 0x92, 0x1f, 0xff,
|
||||
0xc7, 0x81, 0xb7, 0x9e, 0x24, 0xc4, 0x4f, 0xc9, 0xf3, 0xfc, 0x24, 0x8f, 0x9c, 0xa3, 0x77, 0xe1,
|
||||
0xad, 0x30, 0x0a, 0xd3, 0x1e, 0x99, 0x9c, 0x92, 0xe4, 0x30, 0x64, 0x69, 0xc7, 0xd9, 0x59, 0xda,
|
||||
0x5d, 0xf5, 0x2a, 0x54, 0xf4, 0x23, 0x58, 0xe5, 0xda, 0x1d, 0x44, 0xa3, 0xb8, 0xd3, 0xd8, 0x71,
|
||||
0x76, 0x6f, 0xec, 0x6f, 0x77, 0x19, 0x3f, 0xf6, 0xc4, 0xa7, 0xe1, 0x09, 0xf5, 0x13, 0x7f, 0xc2,
|
||||
0xba, 0xcf, 0x0b, 0x1e, 0x6f, 0xca, 0x8e, 0x30, 0xac, 0xf9, 0xc3, 0x49, 0x18, 0x7d, 0xce, 0x48,
|
||||
0x72, 0xf0, 0x94, 0x75, 0x96, 0xf8, 0x09, 0x25, 0x1a, 0xda, 0x81, 0x1b, 0xf1, 0xeb, 0x88, 0x24,
|
||||
0xe2, 0xbb, 0xd3, 0xdc, 0x71, 0x76, 0x57, 0x3d, 0x9d, 0x84, 0x7b, 0xd0, 0x2a, 0xe9, 0xce, 0x68,
|
||||
0x59, 0xa9, 0xa5, 0x2b, 0x29, 0x85, 0xbf, 0x0f, 0x1b, 0xcf, 0x49, 0xca, 0x97, 0x18, 0x5f, 0x23,
|
||||
0xe7, 0xb9, 0x12, 0x82, 0xe1, 0xa9, 0x66, 0x09, 0x9d, 0x84, 0xbf, 0x80, 0x9b, 0x15, 0x29, 0x46,
|
||||
0xd1, 0x27, 0xb0, 0xae, 0xf6, 0xe5, 0x82, 0xf9, 0x05, 0xe7, 0xa9, 0x52, 0x16, 0xc1, 0x27, 0xd0,
|
||||
0xea, 0xcb, 0x8d, 0x0b, 0x6d, 0x0e, 0xa1, 0xa5, 0x78, 0x9e, 0xc5, 0x49, 0x9f, 0xe4, 0x1a, 0xe5,
|
||||
0x77, 0xc4, 0xb3, 0x36, 0x16, 0x9c, 0x5e, 0x55, 0x14, 0x23, 0xd8, 0x28, 0x1f, 0xc0, 0x28, 0xfe,
|
||||
0x93, 0x03, 0x6e, 0x71, 0x9d, 0x8f, 0x29, 0x1d, 0x87, 0x03, 0x3f, 0x0d, 0xe3, 0x28, 0x57, 0x28,
|
||||
0x57, 0xe0, 0x29, 0x00, 0xf5, 0x83, 0x30, 0xe2, 0x44, 0x79, 0xf6, 0x43, 0xcb, 0xd9, 0x1e, 0x39,
|
||||
0xcf, 0x08, 0x4b, 0x7f, 0xae, 0x78, 0x3d, 0x4d, 0x0e, 0xdd, 0x07, 0x18, 0x25, 0xf1, 0x44, 0x3a,
|
||||
0x76, 0x89, 0x3b, 0x56, 0xa3, 0xe0, 0x3f, 0x38, 0x70, 0xb7, 0x56, 0x09, 0x46, 0xd1, 0x2d, 0x68,
|
||||
0xa6, 0x71, 0xea, 0x8f, 0xb9, 0x02, 0x4d, 0x4f, 0x7c, 0xa0, 0xcf, 0x60, 0x23, 0x90, 0x31, 0x9c,
|
||||
0x9f, 0xad, 0x99, 0xfd, 0x41, 0x9d, 0x75, 0x24, 0xab, 0x67, 0x08, 0xe2, 0xdf, 0xc1, 0xf6, 0x73,
|
||||
0x92, 0xe6, 0xfa, 0x78, 0xe4, 0xdc, 0x62, 0x88, 0x2d, 0x58, 0xce, 0x84, 0xfa, 0x0e, 0x57, 0x5f,
|
||||
0x7e, 0x55, 0x0c, 0xd4, 0x78, 0x33, 0x03, 0xe5, 0x5e, 0xb8, 0x37, 0xe3, 0xf8, 0x2b, 0x99, 0xa0,
|
||||
0xf1, 0xa6, 0x26, 0xf8, 0xa3, 0x03, 0xed, 0x97, 0x89, 0x1f, 0xb1, 0x11, 0x49, 0x38, 0xeb, 0x71,
|
||||
0x9e, 0x7a, 0xf9, 0xe5, 0x3b, 0x70, 0x5d, 0x66, 0x80, 0xbc, 0x7d, 0xf1, 0x99, 0xd7, 0x8e, 0x78,
|
||||
0x3c, 0x3c, 0xd6, 0xd2, 0xb6, 0xc1, 0x19, 0x2a, 0xd4, 0x9c, 0x2f, 0x22, 0xaf, 0x75, 0x3e, 0x11,
|
||||
0x05, 0x15, 0x2a, 0xee, 0xc0, 0x96, 0x4d, 0x05, 0x46, 0xf1, 0xdf, 0x1c, 0x58, 0xfb, 0x59, 0x1c,
|
||||
0x46, 0xaa, 0x6c, 0xd5, 0x2b, 0x75, 0x1f, 0x20, 0x21, 0xe7, 0x3d, 0xc2, 0x98, 0x1f, 0x10, 0xa9,
|
||||
0x90, 0x46, 0xc9, 0xd7, 0x5f, 0xc5, 0x61, 0xd4, 0x8f, 0xb3, 0x64, 0x40, 0x78, 0x9d, 0x69, 0x7a,
|
||||
0x1a, 0x05, 0x3d, 0x84, 0xf5, 0x30, 0xba, 0x08, 0x53, 0xa5, 0xeb, 0x32, 0xdf, 0xa2, 0x4c, 0xc4,
|
||||
0x2d, 0x58, 0xd7, 0xf4, 0x61, 0x14, 0xff, 0x33, 0x8f, 0xe2, 0x4a, 0x08, 0xe7, 0x0b, 0x71, 0xc4,
|
||||
0x48, 0x45, 0xe1, 0x25, 0x43, 0x61, 0x2d, 0x3f, 0xae, 0x55, 0xf3, 0x23, 0x5f, 0xff, 0xca, 0x8f,
|
||||
0x86, 0x63, 0x32, 0xec, 0xb1, 0x40, 0x16, 0x46, 0x8d, 0x92, 0x57, 0x57, 0xf1, 0xe5, 0x11, 0x96,
|
||||
0x8d, 0x53, 0xae, 0x6f, 0xd3, 0x2b, 0xd1, 0xf0, 0x7d, 0xd8, 0xae, 0x57, 0x8e, 0x51, 0xbc, 0x0b,
|
||||
0x6b, 0x2f, 0xb2, 0x30, 0x9d, 0x6f, 0xde, 0xfc, 0xe2, 0x1a, 0x27, 0xa3, 0xf8, 0xef, 0x0e, 0xb4,
|
||||
0x8b, 0xf4, 0x9d, 0xbe, 0x17, 0xb3, 0x7d, 0xb4, 0x05, 0xcb, 0xa3, 0x70, 0x9c, 0x92, 0x84, 0x5f,
|
||||
0xb7, 0xe9, 0xc9, 0xaf, 0x05, 0xe5, 0xd3, 0x05, 0x6c, 0xd9, 0x14, 0xaa, 0xcd, 0xa3, 0x67, 0x00,
|
||||
0x93, 0xe9, 0xf3, 0x27, 0x8a, 0xc8, 0xbb, 0x75, 0x19, 0x24, 0x76, 0x7c, 0x96, 0x8d, 0xc7, 0xbc,
|
||||
0x8a, 0x6a, 0x92, 0xd8, 0xab, 0x9e, 0xab, 0xde, 0x95, 0x99, 0xd1, 0xaa, 0x9d, 0xdd, 0xe0, 0x0f,
|
||||
0x8e, 0xbe, 0xa7, 0x0f, 0xb7, 0xad, 0x7b, 0x32, 0xba, 0x30, 0xb5, 0x13, 0x40, 0x9f, 0x85, 0x83,
|
||||
0x33, 0x8d, 0x6d, 0xb6, 0xca, 0xdf, 0x81, 0x8d, 0xb3, 0x70, 0x70, 0x46, 0x86, 0x22, 0x3e, 0x35,
|
||||
0xc5, 0x0d, 0x7a, 0xee, 0xe8, 0x84, 0xf8, 0x2c, 0x8e, 0x64, 0xd0, 0xcb, 0x2f, 0xfc, 0x21, 0xac,
|
||||
0x1e, 0x0c, 0xf7, 0x45, 0x70, 0xd6, 0x56, 0x57, 0x2e, 0xcc, 0x43, 0xba, 0x21, 0xa2, 0x44, 0x7c,
|
||||
0xe1, 0x1e, 0x6c, 0x1a, 0x0a, 0x33, 0x8a, 0xde, 0x87, 0xf5, 0xb0, 0xd8, 0x53, 0x33, 0xc9, 0x46,
|
||||
0x57, 0x40, 0x2c, 0x75, 0x9e, 0x57, 0x66, 0xc3, 0xbf, 0xe7, 0xf1, 0x9b, 0x67, 0x33, 0x19, 0xf2,
|
||||
0x3d, 0x8b, 0xf8, 0x2d, 0x27, 0xa6, 0x63, 0x24, 0xe6, 0x62, 0xa2, 0xf5, 0x15, 0x8f, 0x1a, 0xe3,
|
||||
0xf8, 0xda, 0x68, 0x2d, 0x30, 0xcf, 0xa5, 0x81, 0xc6, 0x94, 0x1d, 0x5f, 0xc0, 0xad, 0x03, 0x5e,
|
||||
0xc6, 0xf2, 0x1b, 0xbc, 0x8c, 0x6d, 0xe9, 0xbe, 0x64, 0x64, 0xaa, 0x74, 0xe0, 0x35, 0xdd, 0x81,
|
||||
0xe8, 0x11, 0xdc, 0x14, 0x05, 0x51, 0x8f, 0x82, 0x26, 0x8f, 0x02, 0x73, 0x01, 0x1f, 0x43, 0xdb,
|
||||
0x72, 0xee, 0xff, 0xe1, 0xb3, 0x5f, 0xc3, 0x2d, 0x05, 0x19, 0xc6, 0xe3, 0xcb, 0x44, 0xed, 0x16,
|
||||
0x2c, 0xc7, 0xa3, 0x11, 0x23, 0x69, 0x51, 0x72, 0xc4, 0x57, 0x6e, 0xe4, 0x41, 0x9c, 0x45, 0xa9,
|
||||
0x7c, 0x09, 0xc4, 0x07, 0x3e, 0x99, 0xd6, 0x34, 0x6d, 0xff, 0x05, 0x26, 0xdd, 0xbf, 0x1c, 0x58,
|
||||
0x79, 0xd2, 0xeb, 0x73, 0xb6, 0x32, 0x8c, 0x75, 0xae, 0x86, 0xad, 0xbb, 0x80, 0x02, 0xf5, 0x56,
|
||||
0xe6, 0xe6, 0x3d, 0xf2, 0x27, 0xc5, 0xb3, 0x67, 0x59, 0xc9, 0xb3, 0xb7, 0x4c, 0x55, 0x3e, 0x37,
|
||||
0xe8, 0xf8, 0x2f, 0x0e, 0xac, 0x29, 0xb4, 0xbb, 0x38, 0x40, 0xb8, 0x2d, 0xaf, 0xab, 0x69, 0x3a,
|
||||
0x25, 0xd4, 0xc7, 0x22, 0x7e, 0x09, 0xeb, 0x9a, 0x36, 0x8c, 0xa2, 0x6f, 0xc3, 0x32, 0x5f, 0x63,
|
||||
0x1c, 0xa9, 0xdf, 0xd8, 0x6f, 0xc9, 0xb0, 0x29, 0x0c, 0xeb, 0xc9, 0x65, 0xe4, 0xc2, 0x0a, 0x27,
|
||||
0x1c, 0x65, 0x13, 0xbe, 0x69, 0xd3, 0x53, 0xdf, 0xf8, 0xf1, 0x14, 0xd1, 0x5f, 0x22, 0x8e, 0xf0,
|
||||
0x3f, 0x8c, 0xe7, 0x8e, 0x3d, 0xe9, 0xf5, 0x67, 0xc7, 0x9e, 0x0b, 0x2b, 0x59, 0xd9, 0x33, 0xea,
|
||||
0xbb, 0x62, 0xd2, 0xa5, 0x37, 0x2c, 0x22, 0xff, 0x75, 0x8c, 0xb7, 0x87, 0x6b, 0xc5, 0x28, 0xfa,
|
||||
0x09, 0x5c, 0x17, 0x71, 0x57, 0x58, 0xe9, 0xb2, 0xe1, 0x5a, 0x88, 0xa1, 0x9f, 0x5a, 0xea, 0xdc,
|
||||
0xb7, 0xac, 0x2a, 0x0a, 0x44, 0x51, 0xdf, 0x07, 0x88, 0x1d, 0x8f, 0xb2, 0x09, 0x93, 0x6e, 0xd0,
|
||||
0x28, 0xf8, 0xbb, 0xd0, 0x7a, 0x1a, 0xb2, 0x49, 0xc8, 0xd8, 0xfc, 0xba, 0x94, 0x77, 0x33, 0x65,
|
||||
0x66, 0x46, 0xf1, 0x2b, 0x40, 0xbd, 0x4c, 0xb6, 0x87, 0x56, 0x57, 0x9a, 0xb5, 0x2d, 0xd3, 0x41,
|
||||
0x57, 0xf1, 0xee, 0x60, 0x58, 0x9b, 0x64, 0x29, 0x19, 0xf6, 0xc9, 0x20, 0x8e, 0x86, 0x8c, 0x57,
|
||||
0x86, 0x75, 0xaf, 0x44, 0xc3, 0x6d, 0xd8, 0x34, 0xce, 0x62, 0x14, 0x1f, 0x42, 0xe7, 0x89, 0x1f,
|
||||
0x0d, 0xc8, 0x78, 0x11, 0x8a, 0xe0, 0xbb, 0x70, 0xa7, 0x66, 0x37, 0x01, 0xd9, 0x14, 0x79, 0xb6,
|
||||
0xad, 0x5a, 0xb0, 0xae, 0x71, 0x32, 0x8a, 0xbb, 0x80, 0x2a, 0xfb, 0xce, 0xde, 0xa0, 0x0d, 0x9b,
|
||||
0x06, 0x3f, 0xa3, 0x38, 0x84, 0x3b, 0xfd, 0x52, 0xcc, 0x1d, 0x85, 0x83, 0xb3, 0xc8, 0x9f, 0x90,
|
||||
0xb9, 0xd9, 0x10, 0x49, 0xc6, 0x22, 0x1b, 0x8a, 0x6f, 0xcd, 0x12, 0xcd, 0x92, 0x25, 0xb6, 0xc1,
|
||||
0xad, 0x3b, 0x8a, 0x51, 0xfc, 0x5b, 0xde, 0xc5, 0x8a, 0x27, 0xb4, 0x9f, 0x51, 0xd9, 0x3d, 0x2c,
|
||||
0xb6, 0x8b, 0x9d, 0x6a, 0xd6, 0x28, 0x69, 0x16, 0xf3, 0xe6, 0xd5, 0x7e, 0xf6, 0x37, 0xf2, 0x86,
|
||||
0x7f, 0xc0, 0xeb, 0xcf, 0xf4, 0xa8, 0x2b, 0x0c, 0x2f, 0x7e, 0xc9, 0x8b, 0x84, 0x21, 0xba, 0xa0,
|
||||
0x09, 0xc6, 0xbf, 0x1b, 0xd0, 0x2e, 0x3b, 0x69, 0x3e, 0xfc, 0xad, 0xb1, 0x2a, 0xfa, 0xa1, 0x16,
|
||||
0x23, 0x4d, 0xf9, 0x20, 0x06, 0x71, 0x1c, 0x8c, 0x89, 0x98, 0x64, 0x9d, 0x66, 0xa3, 0x6e, 0x3f,
|
||||
0x4d, 0xc2, 0x28, 0xf8, 0x85, 0x3f, 0xce, 0x88, 0x16, 0x41, 0xef, 0xc3, 0xf5, 0x91, 0x3f, 0x20,
|
||||
0x9f, 0x7b, 0x87, 0xbc, 0x11, 0x9a, 0x27, 0x58, 0x30, 0xa3, 0x0f, 0x60, 0x35, 0x89, 0xc7, 0xe4,
|
||||
0x90, 0x5c, 0x90, 0x71, 0xe7, 0x3a, 0x97, 0xbc, 0x6b, 0x48, 0x1e, 0x44, 0xe9, 0x7b, 0xfb, 0x42,
|
||||
0x70, 0xca, 0x8d, 0x1e, 0x41, 0x83, 0x7c, 0xdd, 0x59, 0xb9, 0xc4, 0x69, 0x0d, 0xf2, 0x75, 0xde,
|
||||
0xe4, 0xda, 0xac, 0xc4, 0x28, 0xfe, 0xc1, 0x14, 0xeb, 0x7f, 0x7c, 0xca, 0xd2, 0xc4, 0x1f, 0xa4,
|
||||
0x85, 0x05, 0x5d, 0x58, 0x91, 0x26, 0x63, 0xd2, 0xb1, 0xea, 0x1b, 0xff, 0xd5, 0x81, 0x9b, 0x86,
|
||||
0xd0, 0x0c, 0x9b, 0x3f, 0x92, 0xa3, 0xc7, 0x5e, 0x51, 0x7a, 0x4f, 0x49, 0x22, 0x11, 0xb6, 0xb9,
|
||||
0x80, 0xbe, 0x07, 0x9b, 0x41, 0xb9, 0x93, 0xfa, 0xd4, 0x67, 0x5f, 0xf1, 0x0a, 0x71, 0xcd, 0xb3,
|
||||
0x2d, 0xe1, 0x21, 0x74, 0xec, 0xd7, 0x60, 0x14, 0x7d, 0x2a, 0xd1, 0x8a, 0xbe, 0x50, 0xbc, 0x4b,
|
||||
0x1d, 0xf9, 0x7a, 0x9b, 0x92, 0x16, 0x99, 0xfd, 0x3f, 0x6f, 0x80, 0x18, 0x97, 0xa2, 0x1f, 0xc3,
|
||||
0x8d, 0xc1, 0x74, 0x2e, 0x88, 0xda, 0x05, 0x08, 0x28, 0xcd, 0x39, 0xdd, 0x2d, 0x1b, 0x99, 0x23,
|
||||
0xd0, 0xd5, 0x57, 0x45, 0x23, 0x8f, 0x36, 0x25, 0x93, 0x3e, 0x6a, 0x70, 0x6f, 0x99, 0x44, 0x21,
|
||||
0x77, 0x5e, 0xf4, 0xc1, 0x4a, 0x4e, 0xef, 0xa1, 0x95, 0x5c, 0xa9, 0x5d, 0xe6, 0x99, 0xa6, 0x0f,
|
||||
0x10, 0xd1, 0xed, 0xe2, 0xda, 0x95, 0x61, 0xa4, 0xdb, 0xb1, 0x2f, 0x30, 0x8a, 0x3e, 0x82, 0x35,
|
||||
0xa6, 0x8d, 0xf2, 0x50, 0x71, 0xb7, 0xca, 0x00, 0xd1, 0xbd, 0x6d, 0xa5, 0x33, 0x8a, 0x7e, 0x03,
|
||||
0xb7, 0x03, 0xfb, 0xc4, 0x0d, 0xbd, 0x5d, 0x39, 0xd5, 0x9c, 0x86, 0xb9, 0x78, 0x1e, 0x0b, 0xa3,
|
||||
0x68, 0x04, 0x77, 0x82, 0xba, 0x91, 0x16, 0x7a, 0x67, 0xba, 0x41, 0xed, 0xcc, 0xcd, 0x7d, 0x38,
|
||||
0x9f, 0x89, 0x51, 0xf4, 0x02, 0x50, 0x6a, 0x8c, 0x8c, 0xd0, 0xb6, 0x94, 0xb5, 0x0e, 0xb4, 0xdc,
|
||||
0x7b, 0x33, 0x56, 0x19, 0x45, 0x03, 0xe8, 0x04, 0x35, 0xb3, 0x12, 0x84, 0x4b, 0x31, 0x6a, 0x9d,
|
||||
0xf4, 0xb8, 0xef, 0xcc, 0xe5, 0x11, 0x7a, 0x07, 0xc6, 0x8c, 0x42, 0xe9, 0x6d, 0x9d, 0xa7, 0x28,
|
||||
0xbd, 0x6b, 0x86, 0x1b, 0x2f, 0x61, 0x33, 0x30, 0x47, 0x05, 0xc8, 0x2e, 0xa5, 0xa2, 0xec, 0xfe,
|
||||
0xac, 0x65, 0x9e, 0xb1, 0xad, 0xb3, 0x72, 0xb3, 0x8d, 0xee, 0x48, 0x11, 0x73, 0x6a, 0xe0, 0xba,
|
||||
0x75, 0x4b, 0xea, 0xca, 0x95, 0x46, 0x57, 0xbf, 0xb2, 0xd9, 0x82, 0xeb, 0x57, 0xb6, 0x75, 0xc8,
|
||||
0x47, 0x45, 0x17, 0xaa, 0xf5, 0x95, 0xe8, 0x6e, 0xd1, 0x3c, 0x5a, 0x3a, 0x5d, 0x77, 0xbb, 0x7e,
|
||||
0x51, 0x24, 0xb5, 0xca, 0x36, 0x95, 0xd4, 0x7a, 0x07, 0xa4, 0x92, 0xba, 0xdc, 0x88, 0xbc, 0x00,
|
||||
0x64, 0xa2, 0xef, 0x1a, 0x6f, 0xca, 0x76, 0xa1, 0xc6, 0x9b, 0x0a, 0xb6, 0x7f, 0x04, 0x6b, 0x3a,
|
||||
0xc0, 0x55, 0x39, 0x5e, 0x81, 0xc8, 0x2a, 0xc7, 0xab, 0x68, 0x38, 0x77, 0x5c, 0x05, 0x36, 0x2a,
|
||||
0xc7, 0x99, 0xe0, 0x54, 0x39, 0xce, 0x82, 0x34, 0xd1, 0x97, 0xd0, 0xb6, 0xc2, 0x50, 0xf4, 0xa0,
|
||||
0xa8, 0xa9, 0x35, 0x90, 0xd7, 0xdd, 0x99, 0xcd, 0x20, 0x2c, 0xae, 0xc8, 0xca, 0xe2, 0x3a, 0x2c,
|
||||
0x55, 0x16, 0x2f, 0x61, 0xcf, 0xfc, 0x76, 0x95, 0x4d, 0xd5, 0xed, 0x4c, 0x68, 0xab, 0x6e, 0x67,
|
||||
0x41, 0xb1, 0x79, 0x2d, 0xac, 0x01, 0x70, 0x7a, 0x2d, 0xac, 0x01, 0x97, 0x7a, 0x2d, 0xac, 0xc5,
|
||||
0x80, 0x22, 0x3a, 0x2a, 0xb0, 0x4b, 0x8f, 0x0e, 0x13, 0xcc, 0xe9, 0xd1, 0x61, 0xc3, 0x6b, 0xbf,
|
||||
0xaa, 0x82, 0x88, 0x02, 0x0f, 0xa3, 0x9d, 0x4a, 0xcd, 0x37, 0x90, 0xb9, 0xfb, 0xf6, 0x1c, 0x0e,
|
||||
0xa1, 0xb1, 0x89, 0x51, 0x94, 0xc6, 0x56, 0x90, 0xa7, 0x34, 0xb6, 0x83, 0x1b, 0xf4, 0x85, 0x36,
|
||||
0xb1, 0xd1, 0x71, 0x4a, 0xb5, 0xfe, 0x54, 0x90, 0x8f, 0xfb, 0x60, 0xe6, 0x3a, 0xa3, 0x9f, 0x3c,
|
||||
0xf8, 0xf2, 0xde, 0x31, 0x25, 0xd1, 0xc9, 0x41, 0x4f, 0xfb, 0xfb, 0x93, 0xcb, 0x7c, 0xc8, 0x7f,
|
||||
0x4f, 0x97, 0x39, 0xe9, 0xbd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x06, 0xa5, 0xc5, 0x9c, 0x71,
|
||||
0x1d, 0x00, 0x00,
|
||||
}
|
||||
|
||||
@ -5,14 +5,11 @@ option go_package = "Open_IM/pkg/proto/group;group";
|
||||
package group;
|
||||
|
||||
|
||||
message GroupAddMemberInfo{
|
||||
string userID = 1;
|
||||
int32 roleLevel = 2;
|
||||
}
|
||||
|
||||
message CreateGroupReq{
|
||||
repeated GroupAddMemberInfo initMemberList = 1;
|
||||
repeated string initMemberList = 1;
|
||||
server_api_params.GroupInfo groupInfo = 2;
|
||||
repeated string adminUserIDs = 3;
|
||||
string ownerUserID = 5; //owner
|
||||
}
|
||||
message CreateGroupResp{
|
||||
|
||||
@ -132,3 +132,7 @@ func IsRepeatStringSlice(arr []string) bool {
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func IsRepeatID(args ...interface{}) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user