game_sync/model/friendapply.go

package model

import (
	"time"

	"github.com/globalsign/mgo/bson"
	"mongo.games.com/goserver/core/logger"
)

type FriendApply struct {
	Id         bson.ObjectId `bson:"_id"`
	Snid       int32
	ApplySnids []*FriendApplySnid
}

type FriendApplySnid struct {
	SnId     int32
	Name     string
	Head     int32
	CreateTs int64
	HeadUrl  string
	RoleId   int32
}

type FriendApplyRet struct {
	FA *FriendApply
}

type FriendApplyByKey struct {
	Platform string
	SnId     int32
	FA       *FriendApply
}

func NewFriendApply(snid int32) *FriendApply {
	f := &FriendApply{Id: bson.NewObjectId()}
	f.Snid = snid
	f.ApplySnids = []*FriendApplySnid{}
	return f
}

func UpsertFriendApply(platform string, snid int32, fa *FriendApply) *FriendApply {
	if rpcCli == nil {
		logger.Logger.Error("model.UpsertFriendApply rpcCli == nil")
		return nil
	}
	if len(fa.ApplySnids) == 0 {
		DelFriendApply(platform, snid)
		return nil
	}
	args := &FriendApplyByKey{
		Platform: platform,
		SnId:     snid,
		FA:       fa,
	}
	ret := &FriendApplyRet{}
	err := rpcCli.CallWithTimeout("FriendApplySvc.UpsertFriendApply", args, ret, time.Second*30)
	if err != nil {
		logger.Logger.Warn("UpsertFriendApply error:", err)
		return nil
	}
	return ret.FA
}

func QueryFriendApplyBySnid(platform string, snid int32) (fa *FriendApply, err error) {
	if rpcCli == nil {
		logger.Logger.Error("model.QueryFriendApplyBySnid rpcCli == nil")
		return
	}
	args := &FriendApplyByKey{
		Platform: platform,
		SnId:     snid,
	}
	ret := &FriendApplyRet{}
	err = rpcCli.CallWithTimeout("FriendApplySvc.QueryFriendApplyByKey", args, ret, time.Second*30)
	if err != nil {
		logger.Logger.Warn("QueryFriendApplyBySnid error:", err)
	}
	fa = ret.FA
	return
}

func DelFriendApply(platform string, snid int32) {
	if rpcCli == nil {
		logger.Logger.Error("model.UpsertFriendApply rpcCli == nil")
		return
	}
	args := &FriendApplyByKey{
		Platform: platform,
		SnId:     snid,
	}
	err := rpcCli.CallWithTimeout("FriendApplySvc.DelFriendApply", args, nil, time.Second*30)
	if err != nil {
		logger.Logger.Warn("DelFriendApply error:", err)
	}
	return
}

//===========================
// Apply List
//===========================

type ApplyList struct {
	//Id   bson.ObjectId `bson:"_id"`
	SnId int32
	List []int32
}

func NewApplyList(snId int32) *ApplyList {
	return &ApplyList{
		SnId: snId,
	}
}

type ApplyListReq struct {
	Platform string
	Data     *ApplyList
}

type ApplyListRes struct {
	Data *ApplyList
}

func UpsertApplyList(platform string, data *ApplyList) {
	if rpcCli == nil {
		logger.Logger.Error("model.UpsertApplyList rpcCli == nil")
		return
	}
	if len(data.List) == 0 {
		DelFriendApplyList(platform, data.SnId)
		return
	}
	args := &ApplyListReq{
		Platform: platform,
		Data:     data,
	}
	ret := &ApplyListRes{}
	err := rpcCli.CallWithTimeout("FriendApplySvc.UpsertApplyList", args, ret, time.Second*30)
	if err != nil {
		logger.Logger.Warn("UpsertApplyList error:", err)
		return
	}
	return
}

func QueryFriendApplyListBySnid(platform string, snid int32) (data *ApplyList, err error) {
	if rpcCli == nil {
		logger.Logger.Error("model.QueryFriendApplyListBySnid rpcCli == nil")
		return
	}
	args := &FriendApplyByKey{
		Platform: platform,
		SnId:     snid,
	}
	ret := &ApplyListRes{}
	err = rpcCli.CallWithTimeout("FriendApplySvc.QueryFriendApplyListBySnid", args, ret, time.Second*30)
	if err != nil {
		logger.Logger.Warn("QueryFriendApplyListBySnid error:", err)
	}
	data = ret.Data
	return
}

func DelFriendApplyList(platform string, snid int32) {
	if rpcCli == nil {
		logger.Logger.Error("model.DelFriendApplyList rpcCli == nil")
		return
	}
	args := &FriendApplyByKey{
		Platform: platform,
		SnId:     snid,
	}
	err := rpcCli.CallWithTimeout("FriendApplySvc.DelFriendApplyList", args, nil, time.Second*30)
	if err != nil {
		logger.Logger.Warn("DelFriendApplyList error:", err)
	}
	return
}