chunhao_admin/controller/v1/userBehavior.go

package v1

import (
	"context"
	"designs/app/common/request"
	"designs/app/common/response"
	"designs/global"
	"designs/service"
	"designs/utils"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
	"math"
	"strconv"
	"time"
)

// 总览
func Summary(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid string `form:"gid" json:"gid" binding:"required"`
		Pf  string `form:"pf" json:"pf" binding:"required"`
	}{})

	//查询用户总数
	var userCount int64
	err := global.App.DB.Table("user").
		Where("gid", form.Gid).
		Where("pf", form.Pf).
		Count(&userCount).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//查询近七日活跃总数
	now := time.Now()
	sevenDayAgo := now.AddDate(0, 0, -7)
	thirtyDayAgo := now.AddDate(0, 0, -30)

	var activeUserCount7 int64
	err = global.App.DB.Table("user_login").
		Where("gid", form.Gid).
		Where("pf", form.Pf).
		Where("loginTime", ">=", sevenDayAgo).
		Where("loginTime", "<=", now).
		Distinct("userId").
		Count(&activeUserCount7).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	var activeUserCount30 int64
	err = global.App.DB.Table("user_login").
		Where("gid", form.Gid).
		Where("pf", form.Pf).
		Where("loginTime", ">=", thirtyDayAgo).
		Where("loginTime", "<=", now).
		Distinct("userId").
		Count(&activeUserCount30).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//从redis中读取缓存
	var avgTimeString string
	avgTimeKey := fmt.Sprintf("%s|%s|avgTime", form.Gid, form.Pf)
	avgTimeString, _ = global.App.Redis.Get(context.Background(), avgTimeKey).Result()
	if avgTimeString == "" {
		//查询 近7日单设备日均使用时长
		res, err := service.UserOnlineSummary(form.Gid, form.Pf, "", sevenDayAgo.Format("2006-01-02 15:04:05"), now.Format("2006-01-02 15:04:05"))
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		var avgTime int
		for _, v := range res {
			avgTime = avgTime + int(v)
		}

		if avgTime != 0 {
			avgTime = int(math.Round(float64(avgTime / len(res))))

			avgTimeString = utils.TimeStampToMDS(avgTime)
		} else {
			avgTimeString = "00.00"
		}
		global.App.Redis.Set(context.Background(), avgTimeKey, avgTimeString, time.Second*3000)
	}
	response.Success(c, gin.H{
		"data": map[string]interface{}{
			"userCount":            userCount,
			"activeUserCount7":     activeUserCount7,
			"activeUserCount30":    activeUserCount30,
			"activeUserCount7Time": avgTimeString,
		},
	})
}

// 时段分布
func TimeDistributionData(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid  string `form:"gid" json:"gid" binding:"required"`
		Pf   string `form:"pf" json:"pf" binding:"required"`
		Type int    `form:"type" json:"type" binding:"required"`
	}{})

	var data interface{}
	if form.Type == 1 {
		//新增用户
		todayTimeDistribution, yesterdayTimeDistribution, yesterdayCount, todayCount, yesterdayThisTimeCount, err := service.GetRegisterTimeDistribution(form.Pf, form.Gid)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}

		data = map[string]interface{}{
			"today":                  todayTimeDistribution,
			"yesterday":              yesterdayTimeDistribution,
			"yesterdayCount":         yesterdayCount,
			"yesterdayThisTimeCount": yesterdayThisTimeCount,
			"todayCount":             todayCount,
		}
	} else if form.Type == 2 {
		//活跃设备
		todayTimeDistribution, yesterdayTimeDistribution, yesterdayCount, todayCount, yesterdayThisTimeCount, err := service.GetActiveTimeDistribution(form.Pf, form.Gid)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data = map[string]interface{}{
			"today":                  todayTimeDistribution,
			"yesterday":              yesterdayTimeDistribution,
			"yesterdayCount":         yesterdayCount,
			"yesterdayThisTimeCount": yesterdayThisTimeCount,
			"todayCount":             todayCount,
		}
	} else if form.Type == 3 {
		//启动次数
		todayTimeDistribution, yesterdayTimeDistribution, yesterdayCount, todayCount, yesterdayThisTimeCount, err := service.GetActionDistribution(form.Pf, form.Gid)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data = map[string]interface{}{
			"today":                  todayTimeDistribution,
			"yesterday":              yesterdayTimeDistribution,
			"yesterdayCount":         yesterdayCount,
			"yesterdayThisTimeCount": yesterdayThisTimeCount,
			"todayCount":             todayCount,
		}

	} else {
		response.Fail(c, 1003, "type错误")
		return
	}

	response.Success(c, gin.H{
		"data": data,
	})
}

// 30日趋势
func MouthDistributionData(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid  string `form:"gid" json:"gid" binding:"required"`
		Pf   string `form:"pf" json:"pf" binding:"required"`
		Type int    `form:"type" json:"type" binding:"required"`
	}{})
	now := time.Now()
	EndTime := now.AddDate(0, 0, 1).Format("2006-01-02")
	StartTime := now.AddDate(0, 0, -29).Format("2006-01-02")

	data := make(map[string]interface{})
	if form.Type == 1 {
		//查询新增设备趋势图
		TimeDistribution, count, avg, err := service.GetRegisterDayDistribution(form.Pf, form.Gid, StartTime, EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["timeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg

	} else if form.Type == 2 {
		//查询活跃用户趋势图
		TimeDistribution, count, avg, err := service.GetActiveDayDistribution(form.Pf, form.Gid, StartTime, EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["timeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg
	} else if form.Type == 3 {
		//查询启动次数
		TimeDistribution, count, avg, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, StartTime, EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["timeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg

	} else if form.Type == 4 {
		//查询单用户使用时长
		TimeDistribution, count, avg, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, StartTime, EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["timeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg
	} else if form.Type == 5 {
		//查询用户留存率
		//todo

	} else {
		response.Fail(c, 1003, "type错误")
		return
	}

	response.Success(c, gin.H{
		"data": data,
	})
}

// 用户趋势 总览
func UserTrendsOverview(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid       string `form:"gid" json:"gid" binding:"required"`
		Pf        string `form:"pf" json:"pf" binding:"required"`
		StartTime string `form:"startTime" json:"startTime" binding:"required"`
		EndTime   string `form:"endTime" json:"endTime" binding:"required"`
	}{})

	//查询用户新增
	var registerCount int64
	err := global.App.DB.Table("user").
		Where("gid", form.Gid).
		Where("pf", form.Pf).
		Where("createdAt", ">=", form.StartTime).
		Where("createdAt", "<=", form.EndTime).
		Count(&registerCount).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//查询活跃设备
	var activeCount int64
	err = global.App.DB.Table("user_online").
		Where("gid", form.Gid).
		Where("pf", form.Pf).
		Where("logTime", ">=", form.StartTime).
		Where("logTime", "<=", form.EndTime).
		Distinct("userId").Count(&activeCount).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//查询启动次数
	var loginCount int64
	err = global.App.DB.Table("user_login").
		Where("gid", form.Gid).
		Where("pf", form.Pf).
		Where("loginTime", ">=", form.StartTime).
		Where("loginTime", "<=", form.EndTime).
		Count(&loginCount).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}
	//查询平均启动时长
	//查询活跃用户月趋势图
	_, _, activeTime, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//查询 DAU/MAU
	//todo 查询方式需要更新
	dauMau := 0.3

	response.Success(c, gin.H{
		"data": map[string]interface{}{
			"registerCount": registerCount,
			"activeCount":   activeCount,
			"loginCount":    loginCount,
			"activeTime":    activeTime,
			"dauMau":        dauMau,
		},
	})
}

// 数据趋势
func DataTrades(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid       string `form:"gid" json:"gid" binding:"required"`
		Pf        string `form:"pf" json:"pf" binding:"required"`
		StartTime string `form:"startTime" json:"startTime" binding:"required"`
		EndTime   string `form:"endTime" json:"endTime" binding:"required"`
		Type      int    `form:"type" json:"type" binding:"required"`
	}{})
	data := make(map[string]interface{})

	form.EndTime = form.EndTime + " 23:59:59"

	if form.Type == 1 {
		//查询新增设备趋势图
		TimeDistribution, count, avg, err := service.GetRegisterDayDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["imeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg
	} else if form.Type == 2 {
		//查询活跃用户趋势图
		TimeDistribution, count, avg, err := service.GetActiveDayDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["imeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg
	} else if form.Type == 3 {
		//查询活跃用户周趋势图
		TimeDistribution, count, avg, err := service.GetActiveWeekDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["imeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg

	} else if form.Type == 4 {
		//查询活跃用户月趋势图
		TimeDistribution, count, avg, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["imeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg
	} else if form.Type == 5 {
		//查询启动次数
		TimeDistribution, count, avg, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["imeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg
	} else if form.Type == 6 {
		//查询平均启动时间
		TimeDistribution, count, avg, err := service.UserOnlineSummaryByDay(form.Gid, form.Pf, form.StartTime, form.EndTime)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
		data["imeDistribution"] = TimeDistribution
		data["count"] = count
		data["avg"] = avg

	} else {
		response.Fail(c, 1003, "type 错误")
		return
	}

	response.Success(c, gin.H{
		"data": data,
	})
}

// 数据趋势的整合
func DataTradesDetail(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid       string `form:"gid" json:"gid" binding:"required"`
		Pf        string `form:"pf" json:"pf" binding:"required"`
		StartTime string `form:"startTime" json:"startTime" binding:"required"`
		EndTime   string `form:"endTime" json:"endTime" binding:"required"`
	}{})
	form.EndTime = form.EndTime + " 23:59:59"
	type dayData struct {
		NewUser         int `json:"newUser"`
		ActiveUser      int `json:"activeUser"`
		ActiveUserWeek  int `json:"activeUserWeek"`
		ActiveUserMouth int `json:"activeUserMouth"`
		ActiveStart     int `json:"activeStart"`
		AvgTime         int `json:"avgTime"`
	}
	var data = make(map[string]dayData)

	//查询新增设备趋势图
	NewUser, _, _, err := service.GetRegisterDayDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}
	//查询活跃用户趋势图
	ActiveUser, _, _, err := service.GetActiveDayDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}
	//查询活跃用户周趋势图
	ActiveUserWeek, _, _, err := service.GetActiveWeekDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}
	//查询活跃用户月趋势图
	ActiveUserMouth, _, _, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}
	//查询启动次数
	ActiveStart, _, _, err := service.GetActiveMouthDistribution(form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//查询平均启动时间
	AvgTime, _, _, err := service.UserOnlineSummaryByDay(form.Gid, form.Pf, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}
	for k := range AvgTime {
		data[k] = dayData{
			NewUser:         NewUser[k],
			ActiveUser:      ActiveUser[k],
			ActiveUserWeek:  ActiveUserWeek[k],
			ActiveUserMouth: ActiveUserMouth[k],
			ActiveStart:     ActiveStart[k],
			AvgTime:         AvgTime[k],
		}
	}

	response.Success(c, gin.H{
		"data": data,
	})

}

func RemainDataBydDay(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid       string `form:"gid" json:"gid" binding:"required"`
		Pf        string `form:"pf" json:"pf" binding:"required"`
		StartTime string `form:"startTime" json:"startTime" binding:"required"`
		EndTime   string `form:"endTime" json:"endTime" binding:"required"`
		Type      int    `form:"type" json:"type" binding:"required"`
	}{})

	data, err := service.RemainDataBydDay(form.Type, form.Pf, form.Gid, form.StartTime, form.EndTime)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data": data,
	})
}

type AdData struct {
	Pid           string `json:"pid"`
	Aid           string `json:"aid"`
	Cid           string `json:"cid"`
	ReportUrl     string `json:"reportUrl"`
	Reported      bool   `json:"reported"`
	Duration      int64  `json:"duration"`
	AdReqCount    uint8  `json:"adReqCount"`
	AdEposedcount uint8  `json:"adEposedcount"`
	CreateTime    int    `json:"createTime"`
}

type UserBehavior struct {
	Id                 string      `bson:"_id,omitempty"`
	Gid                string      `bson:"gid"`
	Pf                 string      `bson:"pf"`
	OpenId             string      `bson:"openId"`
	AdData             interface{} `bson:"adData"`
	AdFromCount        int         `bson:"adFromCount"`
	TotalDuration      int         `bson:"totalDuration"`
	TotalAdReqCount    int         `bson:"totalAdReqCount"`
	TotalAdEposedCount int         `bson:"totalAdEposedCount"`
}

type BehaviorFilter struct {
	Gt  int `json:"gt"`
	Gte int `json:"gte"`
	Lte int `json:"lte"`
	Lt  int `json:"lt"`
	Ne  int `json:"ne"`
	//$gt 大于
	//$gte：大于或等于
	//$lt：小于
	//$lte：小于或等于
	//$ne：不等于
}

func BehaviorList(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid    string `form:"gid" json:"gid" binding:"required"`
		Pf     string `form:"pf" json:"pf" binding:"required"`
		OpenId string `form:"search" json:"search" binding:""`
		Offset int    `form:"offset" json:"offset" binding:""`
		Limit  int    `form:"limit" json:"limit" binding:""`

		Reported string `form:"reported" json:"reported" binding:""` //all true false
		Pid      string `form:"pid" json:"pid" binding:""`
		Aid      string `form:"aid" json:"aid" binding:""`
		Cid      string `form:"cid" json:"cid" binding:""`

		Duration      interface{} `form:"duration" json:"duration" binding:""`
		AdReqCount    interface{} `form:"adReqCount" json:"adReqCount" binding:""`
		AdEposedcount interface{} `form:"adEposedcount" json:"adEposedcount" binding:""`

		AdFromCount        interface{} `form:"adFromCount" json:"adFromCount" binding:""`
		TotalDuration      interface{} `form:"totalDuration" json:"totalDuration" binding:""`
		TotalAdReqCount    interface{} `form:"totalAdReqCount" json:"totalAdReqCount" binding:""`
		TotalAdEposedCount interface{} `form:"totalAdEposedCount" json:"totalAdEposedCount" binding:""`
	}{})

	collection := global.App.MongoDB.Database("chunhao").Collection("userBehavior")

	ctx := context.Background()
	filter := bson.M{"gid": form.Gid, "pf": form.Pf}

	if form.OpenId != "" {
		filter["openId"] = bson.M{"$regex": form.OpenId}
	}
	if form.Pid != "" {
		filter["adData.pid"] = form.Pid
	}
	if form.Aid != "" {
		filter["adData.aid"] = form.Aid
	}
	if form.Cid != "" {
		filter["adData.cid"] = form.Cid
	}

	if form.AdFromCount != nil {
		fmt.Println(form.AdFromCount)
		marsh, _ := json.Marshal(form.AdFromCount)
		var adFromCount BehaviorFilter
		json.Unmarshal(marsh, &adFromCount)

		filters := bson.M{}
		if adFromCount.Gt != 0 {
			filters["$gt"] = adFromCount.Gt
		}
		if adFromCount.Gte != 0 {
			filters["$gte"] = adFromCount.Gte
		}
		if adFromCount.Lte != 0 {
			filters["$lte"] = adFromCount.Lte
		}
		if adFromCount.Lt != 0 {
			filters["$lt"] = adFromCount.Lt
		}
		if adFromCount.Lt != 0 {
			filters["$ne"] = adFromCount.Ne
		}

		if len(filters) > 0 {
			filter["adFromCount"] = filters
		}
	}

	if form.TotalDuration != nil {
		marsh, _ := json.Marshal(form.TotalDuration)
		var totalDuration BehaviorFilter
		json.Unmarshal(marsh, &totalDuration)

		filters := bson.M{}
		if totalDuration.Gt != 0 {
			filters["$gt"] = totalDuration.Gt
		}
		if totalDuration.Gte != 0 {
			filters["$gte"] = totalDuration.Gte
		}
		if totalDuration.Lte != 0 {
			filters["$lte"] = totalDuration.Lte
		}
		if totalDuration.Lt != 0 {
			filters["$lt"] = totalDuration.Lt
		}
		if totalDuration.Lt != 0 {
			filters["$ne"] = totalDuration.Ne
		}

		if len(filters) > 0 {
			filter["TotalDuration"] = filters
		}
	}

	if form.TotalAdReqCount != nil {
		marsh, _ := json.Marshal(form.TotalAdReqCount)
		var totalAdReqCount BehaviorFilter
		json.Unmarshal(marsh, &totalAdReqCount)

		filters := bson.M{}
		if totalAdReqCount.Gt != 0 {
			filters["$gt"] = totalAdReqCount.Gt
		}
		if totalAdReqCount.Gte != 0 {
			filters["$gte"] = totalAdReqCount.Gte
		}
		if totalAdReqCount.Lte != 0 {
			filters["$lte"] = totalAdReqCount.Lte
		}
		if totalAdReqCount.Lt != 0 {
			filters["$lt"] = totalAdReqCount.Lt
		}
		if totalAdReqCount.Lt != 0 {
			filters["$ne"] = totalAdReqCount.Ne
		}

		if len(filters) > 0 {
			filter["totalAdReqCount"] = filters
		}
	}

	if form.TotalAdEposedCount != nil {
		marsh, _ := json.Marshal(form.TotalAdEposedCount)
		var totalAdEposedCount BehaviorFilter
		json.Unmarshal(marsh, &totalAdEposedCount)

		filters := bson.M{}
		if totalAdEposedCount.Gt != 0 {
			filters["$gt"] = totalAdEposedCount.Gt
		}
		if totalAdEposedCount.Gte != 0 {
			filters["$gte"] = totalAdEposedCount.Gte
		}
		if totalAdEposedCount.Lte != 0 {
			filters["$lte"] = totalAdEposedCount.Lte
		}
		if totalAdEposedCount.Lt != 0 {
			filters["$lt"] = totalAdEposedCount.Lt
		}
		if totalAdEposedCount.Lt != 0 {
			filters["$ne"] = totalAdEposedCount.Ne
		}

		if len(filters) > 0 {
			filter["totalAdEposedCount"] = filters
		}
	}

	if form.Duration != nil {
		marsh, _ := json.Marshal(form.Duration)
		var duration BehaviorFilter
		json.Unmarshal(marsh, &duration)

		filters := bson.M{}
		if duration.Gt != 0 {
			filters["$gt"] = duration.Gt
		}
		if duration.Gte != 0 {
			filters["$gte"] = duration.Gte
		}
		if duration.Lte != 0 {
			filters["$lte"] = duration.Lte
		}
		if duration.Lt != 0 {
			filters["$lt"] = duration.Lt
		}
		if duration.Lt != 0 {
			filters["$ne"] = duration.Ne
		}

		if len(filters) > 0 {
			filter["adData.duration"] = filters
		}
	}

	if form.AdReqCount != nil {
		marsh, _ := json.Marshal(form.AdReqCount)
		var adReqCount BehaviorFilter
		json.Unmarshal(marsh, &adReqCount)

		filters := bson.M{}
		if adReqCount.Gt != 0 {
			filters["$gt"] = adReqCount.Gt
		}
		if adReqCount.Gte != 0 {
			filters["$gte"] = adReqCount.Gte
		}
		if adReqCount.Lte != 0 {
			filters["$lte"] = adReqCount.Lte
		}
		if adReqCount.Lt != 0 {
			filters["$lt"] = adReqCount.Lt
		}
		if adReqCount.Lt != 0 {
			filters["$ne"] = adReqCount.Ne
		}

		if len(filters) > 0 {
			filter["adData.adReqCount"] = filters
		}
	}

	if form.AdEposedcount != nil {
		marsh, _ := json.Marshal(form.AdEposedcount)
		var adEposedcount BehaviorFilter
		json.Unmarshal(marsh, &adEposedcount)

		filters := bson.M{}
		if adEposedcount.Gt != 0 {
			filters["$gt"] = adEposedcount.Gt
		}
		if adEposedcount.Gte != 0 {
			filters["$gte"] = adEposedcount.Gte
		}
		if adEposedcount.Lte != 0 {
			filters["$lte"] = adEposedcount.Lte
		}
		if adEposedcount.Lt != 0 {
			filters["$lt"] = adEposedcount.Lt
		}
		if adEposedcount.Lt != 0 {
			filters["$ne"] = adEposedcount.Ne
		}

		if len(filters) > 0 {
			filter["adData.adEposedcount"] = filters
		}
	}

	option := options.Find()
	option.SetLimit(int64(form.Limit))
	option.SetSkip(int64(form.Offset))

	cur, err := collection.Find(ctx, filter, option)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	count, err := collection.CountDocuments(ctx, filter)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	var data []UserBehavior
	err = cur.All(ctx, &data)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data":  data,
		"count": count,
	})
}

// ConversionCondition 转化条件
type ConversionCondition struct {
	Id               string  `bson:"_id" json:"id"`
	Gid              string  `bson:"gid" json:"gid"`
	Pid              int64   `bson:"pid" json:"pid"`
	Aid              int64   `bson:"aid" json:"aid"`
	Type             string  `bson:"type"  json:"type"`
	StartNum         int     `bson:"start_num" json:"start_num"` //启动次数
	EstimatedRevenue float32 `bson:"revenue" json:"revenue"`     //当日预估收益
	Duration         int64   `bson:"duration" json:"duration"`   //当日在线时长
	ReqRewardedAd    int     `bson:"req_count" json:"req_count"` //当日的激励视频广告请求次数
	ExpRewardedAd    int     `bson:"exp_count" json:"exp_count"` //当日的激励视频广告曝光次数
}

func SetGameCondition(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid              string  `form:"gid" json:"gid" binding:"required"`
		Pid              int64   `form:"pid" json:"pid" binding:""`
		Aid              int64   `form:"aid" json:"aid" binding:""`
		Type             string  `form:"type" json:"type" binding:"required"`
		StartNum         int     `form:"start_num" json:"start_num" binding:""`
		EstimatedRevenue float32 `form:"revenue" json:"revenue" binding:""`
		Duration         int64   `form:"duration" json:"duration" binding:""`
		ReqRewardedAd    int     `form:"req_count" json:"req_count" binding:""`
		ExpRewardedAd    int     `form:"exp_count" json:"exp_count" binding:""`
	}{})

	id := fmt.Sprintf("%s|%s|%s|%s", form.Gid, strconv.Itoa(int(form.Pid)), strconv.Itoa(int(form.Aid)), form.Type)

	collection := global.App.MongoDB.Database("chunhao").Collection("conversionCondition")
	filter := bson.M{"_id": id}

	var conversionCondition ConversionCondition
	err := collection.FindOne(context.TODO(), filter).Decode(&conversionCondition)
	//if err != nil {
	//	response.Fail(c, 1002, err.Error())
	//	return
	//}

	if conversionCondition.Id != "" {
		//存在，更新
		update := bson.M{
			"$set": struct {
				StartNum         int     `bson:"start_num"` //启动次数
				EstimatedRevenue float32 `bson:"revenue"`   //当日预估收益
				Duration         int64   `bson:"duration"`  //当日在线时长
				ReqRewardedAd    int     `bson:"req_count"` //当日的激励视频广告请求次数
				ExpRewardedAd    int     `bson:"exp_count"` //当日的激励视频广告曝光次数
			}{
				StartNum:         form.StartNum,
				EstimatedRevenue: form.EstimatedRevenue,
				Duration:         form.Duration,
				ReqRewardedAd:    form.ReqRewardedAd,
				ExpRewardedAd:    form.ExpRewardedAd,
			},
		}
		_, err = collection.UpdateOne(context.TODO(), filter, update)
		if err != nil {
			response.Fail(c, 1003, err.Error())
			return
		}
	} else {
		//不存在，新增
		insert := ConversionCondition{
			Id:               id,
			Pid:              form.Pid,
			Aid:              form.Aid,
			Gid:              form.Gid,
			Type:             form.Type,
			StartNum:         form.StartNum,
			EstimatedRevenue: form.EstimatedRevenue,
			Duration:         form.Duration,
			ReqRewardedAd:    form.ReqRewardedAd,
			ExpRewardedAd:    form.ExpRewardedAd,
		}

		_, err = collection.InsertOne(context.TODO(), insert)
		if err != nil {
			response.Fail(c, 1001, err.Error())
			return
		}
	}

	response.Success(c, gin.H{})
}

func GameConditionList(c *gin.Context) {
	form := request.Check(c, &struct {
		Gid    string `form:"gid" json:"gid" binding:"required"`
		Pid    int64  `form:"pid" json:"pid" binding:""`
		Aid    int64  `form:"aid" json:"aid" binding:""`
		Type   string `form:"type" json:"type" binding:""`
		Offset int    `form:"offset" json:"offset" binding:""`
		Limit  int    `form:"limit" json:"limit" binding:"required"`
	}{})

	collection := global.App.MongoDB.Database("chunhao").Collection("conversionCondition")

	filter := bson.M{"gid": form.Gid, "type": form.Type}
	if form.Type != "" {
		filter["type"] = form.Type
	}
	if form.Pid != 0 {
		filter["pid"] = form.Pid
	}
	if form.Aid != 0 {
		filter["aid"] = form.Aid
	}

	ctx := context.Background()
	option := options.Find()
	option.SetLimit(int64(form.Limit))
	option.SetSkip(int64(form.Offset))

	cur, err := collection.Find(ctx, filter, option)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	count, err := collection.CountDocuments(ctx, filter)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	var data []ConversionCondition
	err = cur.All(ctx, &data)
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data":  data,
		"count": count,
	})
}