Initial commit

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

models/v/proxymod/app.go

@@ -0,0 +1,19 @@
+package proxymod
+
+// InvitationBindReq 推广绑定请求参数
+type InvitationBindReq struct {
+	UID       uint64 `form:"uid" json:"uid" bson:"uid"`          //邀请用户id
+	PromoCode string `bson:"promotionCode" json:"promotionCode"` //邀请码
+}
+
+// UIDList uid切片类型结构体
+type UIDList struct {
+	ID    uint64   `bson:"_id"`
+	IDS   []uint64 `bson:"ids"`
+	Total int64    `bson:"total"`
+}
+
+type InvitationRes struct {
+	IsBoughtVIP bool `json:"isBought"`
+	Invitation
+}

models/v/proxymod/h5.go

@@ -0,0 +1,24 @@
+package proxymod
+
+type InvitActUser struct {
+	Name       string `json:"name"`       //用户名
+	UID        uint64 `json:"uid"`        //用户id
+	Portrait   string `json:"portrait"`   //头像
+	TotalCoins int64  `json:"totalCoins"` //总金币
+	ReCoins    int64  `json:"reCoins"`    //未领金币
+	CoinsLv1   int64  `json:"coinsLv1"`   //一级推广获益金币
+	CoinsLv2   int64  `json:"coinsLv2"`   //二级推广获益金币
+	CoinsLv3   int64  `json:"coinsLv3"`   //三级推广获益金币
+	CoinsLv4   int64  `json:"coinsLv4"`   //四级推广获益金币
+}
+
+type InvitRankUser struct {
+	Name     string `json:"name"`     //用户名
+	Portrait string `json:"portrait"` //头像
+	Coins    int64  `json:"coins"`    //金币数
+}
+
+type InvitActInfo struct {
+	User  InvitActUser    `json:"user"`
+	Ranks []InvitRankUser `json:"ranks"`
+}

models/v/proxymod/proxy.go

@@ -0,0 +1,536 @@
+package proxymod
+
+import (
+	"fmt"
+	"time"
+
+	"91porn-server/common/db"
+	"91porn-server/common/log"
+	"91porn-server/models"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+const table = models.Invitation
+
+func coll(t *db.MongoTool) *db.MongoTool {
+	if t == nil {
+		return mdb.Coll(table)
+	}
+	return t.Coll(table)
+}
+
+// initIndex 索引设置
+func initIndex() {
+	many := []mongo.IndexModel{ //batch set indexes   //value is the type 1 or -1
+		{
+			Keys: bson.D{{Key: "uid", Value: 1}},
+		},
+		{
+			Keys:    bson.D{{Key: "invitee", Value: 1}},
+			Options: options.Index().SetUnique(true),
+		},
+		{
+			Keys: bson.D{{Key: "createdAt", Value: 1}},
+		},
+		{
+			Keys: bson.D{{Key: "inviteTime", Value: 1}},
+		},
+	}
+	if _, err := coll(nil).CreateIndex(many); err != nil {
+		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
+	}
+}
+
+// GetInvitation 获取一级代理
+func GetInvitation(uid uint64) ([]uint64, error) {
+	data := []UIDList{}
+	if err := coll(nil).Aggregate(&data, []bson.M{
+		{"$match": bson.M{"uid": uid}},
+		{"$project": bson.M{"_id": 0, "invitee": 1}},
+		{"$group": bson.M{"_id": 1, "ids": bson.M{"$push": "$invitee"}}},
+	}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInvitation", table, "Aggregate", err), log.Any("uid", uid))
+		return nil, err
+	}
+	if len(data) == 0 {
+		return make([]uint64, 0), nil
+	}
+	return data[0].IDS, nil
+}
+
+// GetInvrLv1 获取上一级代理
+func GetInvrLv1(uid uint64) (uint64, error) {
+	data := Invitation{}
+	if err := coll(nil).FindOne(&data, bson.M{"invitee": uid}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInvrLv1", table, "FindOne", err), log.Any("uid", uid))
+		return 0, err
+	}
+	return data.UID, nil
+}
+
+// GetInvrLv1Map 获取上一级代理uid Map
+func GetInvrLv1Map(uidList []uint64) (map[uint64]uint64, error) {
+	if len(uidList) == 0 {
+		return make(map[uint64]uint64), nil
+	}
+	filter := bson.M{
+		"invitee": bson.M{
+			"$in": uidList,
+		},
+	}
+	invrList := make([]Invitation, 0, len(uidList))
+	if err := coll(nil).Find(&invrList, filter); err != nil {
+		return nil, err
+	}
+	m := make(map[uint64]uint64, len(invrList))
+	for _, invr := range invrList {
+		m[invr.Invitee] = invr.UID
+	}
+	return m, nil
+}
+
+// GetInvitationByUID 获取下级代理绑定记录
+func GetInvitationByUID(uid uint64, pageNumber int64, pageSize int64) (data []*Invitation, hasNext bool, err error) {
+	data = make([]*Invitation, 0)
+	skip := pageSize * (pageNumber - 1)
+	limit := pageSize + 1
+	opt := options.FindOptions{
+		Skip:  &skip,
+		Limit: &limit,
+		Sort:  bson.D{{Key: "createdAt", Value: -1}},
+	}
+	if err = coll(nil).Find(&data, bson.M{"uid": uid}, &opt); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInvitationByUID", table, "Find", err), log.Any("uid", uid))
+		return
+	}
+	if len(data) > int(pageSize) {
+		hasNext = true
+		data = data[:pageSize]
+	}
+	return
+}
+
+// GetInveNext 获取下级级代理
+func GetInveNext(uids []uint64) (ids []uint64, total int64, err error) {
+	data := []UIDList{}
+	if err = coll(nil).Aggregate(&data, []bson.M{
+		{"$match": bson.M{"uid": bson.M{"$in": uids}}},
+		{"$project": bson.M{"_id": 0, "invitee": 1}},
+		{"$group": bson.M{"_id": 1, "ids": bson.M{"$push": "$invitee"}, "total": bson.M{"$sum": 1}}},
+	}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInveNext", table, "Aggregate", err), log.Any("uids", uids))
+		return
+	}
+	if len(data) > 0 {
+		ids = data[0].IDS
+		total = data[0].Total
+	}
+	return
+}
+
+// GetInviteesCount 获取下级代理总数
+func GetInviteesCount(uids []uint64, startTime time.Time, endTime time.Time) (count int64, err error) {
+	count, err = coll(nil).Count(bson.M{"createdAt": bson.M{"$gte": startTime, "$lte": endTime}, "uid": bson.M{"$in": uids}})
+	if err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInviteesCount", table, "Count", err),
+			log.Any("uids", uids),
+			log.Any("startTime", startTime),
+			log.Any("endTime", endTime),
+		)
+		return
+	}
+	return
+}
+
+// GetInviteesCount 获取下级代理总数map
+func GetInviteesCountMap(uids []uint64) (map[uint64]int64, error) {
+	if len(uids) == 0 {
+		return make(map[uint64]int64), nil
+	}
+	pipeLine := []bson.M{
+		{
+			"$match": bson.M{
+				"uid": bson.M{"$in": uids},
+			},
+		},
+		{
+			"$group": bson.M{
+				"_id": "$uid",
+				"count": bson.M{
+					"$sum": 1,
+				},
+			},
+		},
+	}
+	list := make([]struct {
+		UID   uint64 `bson:"_id"`
+		Count int64  `bson:"count"`
+	}, len(uids))
+	if err := coll(nil).Aggregate(&list, pipeLine); err != nil {
+		return nil, err
+	}
+	countMap := make(map[uint64]int64, len(list))
+	for _, v := range list {
+		countMap[v.UID] = v.Count
+	}
+	return countMap, nil
+}
+
+// GetInve 获取N级代理
+func GetInve(uids []uint64, lev int) ([]uint64, error) {
+	data := []UIDList{}
+	if err := coll(nil).Aggregate(&data, []bson.M{
+		{"$match": bson.M{"uid": bson.M{"$in": uids}}},
+		{"$project": bson.M{"_id": 0, "invitee": 1}},
+		{"$group": bson.M{"_id": 1, "ids": bson.M{"$push": "$invitee"}}},
+	}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInve", table, "Aggregate", err),
+			log.Any("uids", uids),
+			log.Any("lev", lev),
+		)
+		return nil, err
+	}
+	if len(data) == 0 {
+		return nil, nil
+	}
+	ids := data[0].IDS
+	if lev == 1 || len(ids) <= 0 {
+		return ids, nil
+	}
+	return GetInve(ids, lev-1)
+}
+
+func CountByUID(uid uint64) (i int64, err error) {
+	count, err := coll(nil).Count(bson.M{"uid": uid})
+	if err != nil {
+		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountByUID", table, "Count", err), log.Any("uid", uid))
+		return 0, err
+	}
+	return count, nil
+}
+func CountByInviteeID(uid uint64) (i int64, err error) {
+	count, err := coll(nil).Count(bson.M{"invitee": uid})
+	if err != nil {
+		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountByInviteeID", table, "Count", err), log.Any("uid", uid))
+		return 0, err
+	}
+	return count, nil
+}
+
+func CountPayUserByUID(uid uint64) (i int64, err error) {
+	count, err := coll(nil).Count(bson.M{"uid": uid, "isRecharge": true})
+	if err != nil {
+		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountPayUserByUID", table, "Count", err), log.Any("uid", uid))
+		return 0, err
+	}
+	return count, nil
+}
+
+func CountAfter22_02_10(uid uint64) (i int64, err error) {
+	count, err := coll(nil).Count(bson.M{"uid": uid, "createdAt": bson.M{"$gt": time.Unix(1612890000, 0)}})
+	if err != nil {
+		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountByUID", table, "Count", err), log.Any("uid", uid))
+		return 0, err
+	}
+	return count, nil
+}
+
+func CountByUIDAndTime(uid uint64, startTime time.Time) (i int64, err error) {
+	count, err := coll(nil).Count(bson.M{"uid": uid, "createdAt": bson.M{"$gt": startTime}})
+	if err != nil {
+		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountByUIDAndTime", table, "Count", err), log.Any("uid", uid))
+		return 0, err
+	}
+	return count, nil
+}
+
+// GetInveNextDetails 获取下级代理详情
+func GetInveNextDetails(uids []uint64) (invs []Invitation, err error) {
+	invs = make([]Invitation, 0)
+	if err = coll(nil).Find(&invs, bson.M{"uid": bson.M{"$in": uids}}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInveNextDetails", table, "Find", err), log.Any("uids", uids))
+		return
+	}
+	return
+}
+
+// GetInvr 获取上级代理
+func GetInvr(uid uint64, lev int, ids *[]uint64) error {
+	i := Invitation{}
+	if err := coll(nil).FindOne(&i, bson.M{"invitee": uid}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInvr", table, "FindOne", err),
+			log.Any("uid", uid),
+			log.Any("lev", lev),
+			log.Any("ids", ids),
+		)
+		return err
+	}
+	if i.UID == 0 {
+		return nil
+	}
+	*ids = append(*ids, i.UID)
+	if lev == 1 {
+		return nil
+	}
+	return GetInvr(i.UID, lev-1, ids)
+}
+
+// GetInvrDetails 获取上级代理详情
+func GetInvrDetails(uid uint64, lev int) ([]Invitation, error) {
+	ids := make([]Invitation, 0)
+	bufI := Invitation{}
+	if err := coll(nil).FindOne(&bufI, bson.M{"invitee": uid}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInvrDetails", table, "FindOne", err),
+			log.Any("uid", uid),
+			log.Any("lev", lev),
+			log.Any("ids", ids),
+		)
+		return nil, err
+	}
+	if bufI.UID == 0 {
+		return ids, nil
+	}
+	ids = append(ids, bufI)
+	if lev == 1 {
+		return ids, nil
+	}
+	list, err := GetInvrDetails(bufI.UID, lev-1)
+	if err != nil {
+		return ids, nil
+	}
+	ids = append(ids, list...)
+	return ids, nil
+}
+
+// WebGetUIDList 绑定记录列表，获取某邀请码的邀请关系和收益
+func WebGetUIDList(start time.Time, end time.Time) (data []UIDList, err error) {
+	data = make([]UIDList, 0)
+	p := []bson.M{
+		{"$match": bson.M{"createdAt": bson.M{"$gte": start, "$lt": end}}},
+		{"$group": bson.M{"_id": "$uid", "ids": bson.M{"$push": "$invitee"}, "promotionCode": bson.M{"$first": "$promotionCode"}}},
+	}
+	if err = coll(nil).Aggregate(&data, p); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "WebGetUIDList", table, "Aggregate", err),
+			log.Any("start", start),
+			log.Any("end", end),
+		)
+		return
+	}
+	return
+}
+
+// LoopInviteError 循环推广错误
+type LoopInviteError struct {
+	Parent uint64
+	UID    uint64
+}
+
+func (l LoopInviteError) Error() string {
+	return fmt.Sprintf("Loop Invite Error! parent: %d uid: %d", l.Parent, l.UID)
+}
+
+// InsertOne 插入一条邀请关系
+func InsertOne(invitation Invitation) error {
+	count, err := CountByInviteeID(invitation.Invitee)
+	if err != nil {
+		return err
+	}
+	if count != 0 {
+		return LoopInviteError{invitation.Invitee, invitation.UID}
+	}
+	if _, err = coll(nil).InsertOne(invitation); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertOne", table, "InsertOne", err))
+		return err
+	}
+	return nil
+}
+
+// FindMany 查询所有
+func FindMany(filter bson.M, opts *options.FindOptions) (total int64, data []*Invitation, err error) {
+	data = make([]*Invitation, 0)
+	if err = coll(nil).Find(&data, filter, opts); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindMany", table, "Find", err), log.Any("filter", filter))
+		return
+	}
+	total, err = coll(nil).Count(filter)
+	if err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindMany", table, "Count", err), log.Any("filter", filter))
+	}
+	return
+}
+
+// ProxyUserCount 一段时间内邀请用户数
+func ProxyUserCount(start time.Time, end time.Time) (map[uint64]int64, []uint64, error) {
+	m := make(map[uint64]int64)
+	pipeLine := []bson.M{
+		{"$match": bson.M{"createdAt": bson.M{"$gte": start, "$lt": end}}},
+		{"$group": bson.M{"_id": "$uid", "count": bson.M{"$sum": 1}}},
+	}
+	docList := []struct {
+		UID   uint64 `bson:"_id"`
+		Count int64  `bson:"count"`
+	}{}
+	uids := []uint64{}
+	if err := coll(nil).Aggregate(&docList, pipeLine); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "ProxyUserCount", table, "Aggregate", err),
+			log.Any("start", start),
+			log.Any("end", end),
+		)
+		return m, uids, err
+	}
+	for _, doc := range docList {
+		m[doc.UID] = doc.Count
+		uids = append(uids, doc.UID)
+	}
+	return m, uids, nil
+}
+
+// InvitListByCreatedAt 通过CreatedAt获取Invitation List
+func InvitListByCreatedAt(start, end time.Time) ([]Invitation, error) {
+	filter := bson.M{
+		"createdAt": bson.M{
+			"$gte": start,
+			"$lt":  end,
+		},
+	}
+	invitList := make([]Invitation, 0)
+	if err := coll(nil).Find(&invitList, filter); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InvitListByCreatedAt", table, "Find", err),
+			log.Any("start", start),
+			log.Any("end", end),
+		)
+		return nil, err
+	}
+	return invitList, nil
+}
+
+// GetParentInvitList 获取指定uidList的父级Invitation List
+func GetParentInvitList(uids []uint64) ([]Invitation, error) {
+	filter := bson.M{
+		"invitee": bson.M{"$in": uids},
+	}
+	list := make([]Invitation, 0, len(uids))
+	if err := coll(nil).Find(&list, filter); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetParentInvitList", table, "Find", err), log.Any("uids", uids))
+		return nil, err
+	}
+	return list, nil
+}
+
+// GetSuperiorInvitList 获取上级Invitation
+func GetSuperiorInvitList(invitees []uint64, depth int) ([]Invitation, error) {
+	invitList := []Invitation{}
+	for i := 0; i < depth; i++ {
+		if len(invitees) == 0 {
+			break
+		}
+		parentInvitList, err := GetParentInvitList(invitees)
+		if err != nil {
+			return nil, err
+		}
+		parentUIDList := make([]uint64, len(parentInvitList))
+		for i, v := range parentInvitList {
+			parentUIDList[i] = v.UID
+		}
+		invitList = append(invitList, parentInvitList...)
+		invitees = parentUIDList
+	}
+	return invitList, nil
+}
+
+func NextProxyCount(uid uint64, start time.Time, end time.Time) (int64, error) {
+	f := bson.M{"uid": uid, "createdAt": bson.M{"$gte": start, "$lt": end}}
+	c, err := coll(nil).Count(f)
+	if err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "NextProxyCount", table, "count", err), log.Any("filter", f))
+		return 0, err
+	}
+	return c, nil
+}
+
+// UserInvitees 获取用户推广人数
+func UserInvitees(startTime time.Time, endTime time.Time) (map[uint64]int, error) {
+	data := make(map[uint64]int)
+	infos := []InviteeCount{}
+	pipeline := []bson.M{
+		{
+			"$match": bson.M{"createdAt": bson.M{"$gt": startTime, "$lte": endTime}},
+		},
+		{
+			"$group": bson.M{"_id": "$uid", "count": bson.M{"$sum": 1}},
+		},
+	}
+	if err := coll(nil).Aggregate(&infos, pipeline); err != nil {
+		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UserInvitees", table, "Aggregate", err),
+			log.Any("startTime", startTime),
+			log.Any("endTime", endTime))
+		return data, err
+	}
+	for _, v := range infos {
+		data[v.UID] = v.Count
+	}
+	return data, nil
+}
+
+func StatCenterSyncInviteList(time time.Time, size int64) ([]Invitation, error) {
+	opt := (&options.FindOptions{})
+	opt.SetLimit(size)
+	opt.SetSort(bson.M{"inviteTime": 1})
+	filter := bson.M{"inviteTime": bson.M{"$gt": time}}
+	data := make([]Invitation, 0)
+	return data, coll(nil).Find(&data, filter, opt)
+}
+
+func NewStatCenterSyncInviteList(id string, size int64) ([]Invitation, error) {
+	opt := (&options.FindOptions{})
+	opt.SetLimit(size)
+	opt.SetSort(bson.M{"_id": 1})
+	_id, _ := primitive.ObjectIDFromHex(id)
+	filter := bson.M{"_id": bson.M{"$gt": _id}}
+	data := make([]Invitation, 0)
+	return data, coll(nil).Find(&data, filter, opt)
+}
+
+// FindManyByApp app分页查询所有
+func FindManyByApp(uid, pageNumber, pageSize uint64) (total int64, data []*Invitation, err error) {
+	filter := bson.M{"uid": uid}
+	opts := &options.FindOptions{}
+	opts.SetSkip(int64((pageNumber - 1) * pageSize)).SetLimit(int64(pageSize + 1))
+	opts.SetSort(bson.D{{Key: "createdAt", Value: -1}})
+	data = make([]*Invitation, 0)
+	if err = coll(nil).Find(&data, filter, opts); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindManyByApp", table, "Find", err), log.Any("filter", filter))
+		return
+	}
+	total, err = coll(nil).Count(filter)
+	if err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindManyByApp", table, "Count", err), log.Any("filter", filter))
+	}
+	return
+}
+
+// FindTotal 查询所有总数
+func FindTotal(uid uint64) (total int64, err error) {
+	filter := bson.M{"uid": uid}
+	total, err = coll(nil).Count(filter)
+	if err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindTotal", table, "Count", err), log.Any("filter", filter))
+	}
+	return
+}
+
+// UpdateByUid 修改
+func UpdateByUid(t *db.MongoTool, uid, proxyUserId uint64) error {
+	cond := bson.M{"isRecharge": true, "updateAt": time.Now()}
+	if _, err := coll(t).UpdateOne(bson.M{"invitee": uid, "uid": proxyUserId}, bson.M{"$set": cond}); err != nil {
+		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UpdateByUid", table, "UpdateOne", err),
+			log.Any("uid", uid),
+		)
+		return err
+	}
+	return nil
+}

models/v/proxymod/type.go

@@ -0,0 +1,43 @@
+package proxymod
+
+import (
+	"time"
+
+	"91porn-server/common/db"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+const FreeDay int64 = 3
+
+var mdb *db.MongoDB
+
+const (
+	LoginType = "login"
+	BindType  = "bind"
+)
+
+// Invitation 邀请关系
+type Invitation struct {
+	ID              primitive.ObjectID `json:"id"              bson:"_id,omitempty"`   // 推广邀请id
+	UID             uint64             `json:"uid"             bson:"uid"`             // 邀请用户id
+	Invitee         uint64             `json:"invitee"         bson:"invitee"`         // 被邀请的用户id,也就是一级用户
+	InviteePortrait string             `json:"inviteePortrait" bson:"inviteePortrait"` // 被邀请人头像
+	InviteeName     string             `json:"inviteeName"     bson:"inviteeName"`     // 被邀请的用户姓名
+	InviteTime      time.Time          `json:"inviteTime"      bson:"inviteTime"`      // 手动绑定时间
+	InviteCode      string             `json:"inviteCode"      bson:"InviteCode"`      // 邀请码
+	IsRecharge      bool               `json:"isRecharge"      bson:"isRecharge"`      // 邀请用户是否充值
+	UpdateAt        time.Time          `json:"updateAt"        bson:"updateAt"`        // 更新时间
+	CreatedAt       time.Time          `json:"createdAt"       bson:"createdAt"`       // 创时时间
+}
+
+// InviteeCount 用户推广人数统计
+type InviteeCount struct {
+	UID   uint64 ` json:"uid" bson:"_id"` //邀请用户id
+	Count int    `json:"count" bson:"count"`
+}
+
+func Init() {
+	mdb = db.Init(table)
+	initIndex()
+}

models/v/proxymod/web.go

@@ -0,0 +1,16 @@
+package proxymod
+
+import "time"
+
+// Invitation 邀请关系
+type InvitationQueryReq struct {
+	UID *uint64 `form:"uid" json:"uid,omitempty" bson:"uid"` //邀请用户id
+}
+
+// InvitationWebRes 查询结构返回体
+type InvitationWebRes struct {
+	UID       uint64    `json:"uid"`
+	IID       uint64    `json:"iid"`
+	Lv        int       `json:"lv"`
+	CreatedAt time.Time `json:"createdAt"`
+}