zyos_camp_task/one_circles/hdl/hdl_base.go

package hdl

import (
	"applet/app/cfg"
	commDb "applet/app/comm/db"
	"applet/app/comm/e"
	commSvc "applet/app/comm/svc"
	"applet/app/comm/utils"
	"applet/app/comm/utils/cache"
	"applet/app/comm/utils/logx"
	"applet/one_circles/db"
	db2 "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model"
	enum2 "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/enum"
	md2 "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/md"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/rule"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/rule/one_circles"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/rule/one_circles/enum"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/rule/one_circles/md"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/svc"
	zhios_order_relate_utils "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/shopspring/decimal"
	"github.com/syyongx/php2go"
	"math"
	"strconv"
	"time"
)

func GetStyle(c *gin.Context) {
	Db := commSvc.MasterDb(c)

	greenEnergyHomepage, err := commDb.SysModFindByName(c, Db, "greenEnergyHomepage") //主页
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyHomepageStyle interface{}
	if greenEnergyHomepage != nil {
		err = json.Unmarshal([]byte(greenEnergyHomepage.Data), &greenEnergyHomepageStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyFlowDetail, err := commDb.SysModFindByName(c, Db, "greenEnergyFlowDetail") //绿色能量明细
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyFlowDetailStyle interface{}
	if greenEnergyFlowDetail != nil {
		err = json.Unmarshal([]byte(greenEnergyFlowDetail.Data), &greenEnergyFlowDetailStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyActivityPointFlowDetail, err := commDb.SysModFindByName(c, Db, "greenEnergyActivityPointFlowDetail") //活跃积分能量明细
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyActivityPointFlowDetailStyle interface{}
	if greenEnergyActivityPointFlowDetail != nil {
		err = json.Unmarshal([]byte(greenEnergyActivityPointFlowDetail.Data), &greenEnergyActivityPointFlowDetailStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyPointsCenter, err := commDb.SysModFindByName(c, Db, "greenEnergyPointsCenter") //积分中心
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyPointsCenterStyle interface{}
	if greenEnergyPointsCenter != nil {
		err = json.Unmarshal([]byte(greenEnergyPointsCenter.Data), &greenEnergyPointsCenterStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyEcologicalApplicationManual, err := commDb.SysModFindByName(c, Db, "greenEnergyEcologicalApplicationManual") //生态应用说明书
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyEcologicalApplicationManualStyle interface{}
	if greenEnergyPointsCenter != nil {
		err = json.Unmarshal([]byte(greenEnergyEcologicalApplicationManual.Data), &greenEnergyEcologicalApplicationManualStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyBasalRate, err := commDb.SysModFindByName(c, Db, "greenEnergyBasalRate") //基础速率
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyBasalRateStyle interface{}
	if greenEnergyPointsCenter != nil {
		err = json.Unmarshal([]byte(greenEnergyBasalRate.Data), &greenEnergyBasalRateStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyTotalRate, err := commDb.SysModFindByName(c, Db, "greenEnergyTotalRate") //总速率
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyTotalRateStyle interface{}
	if greenEnergyTotalRate != nil {
		err = json.Unmarshal([]byte(greenEnergyTotalRate.Data), &greenEnergyTotalRateStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyMyTeam, err := commDb.SysModFindByName(c, Db, "greenEnergyMyTeam") //我的团队
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyMyTeamStyle interface{}
	if greenEnergyMyTeam != nil {
		err = json.Unmarshal([]byte(greenEnergyMyTeam.Data), &greenEnergyMyTeamStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyHeroList, err := commDb.SysModFindByName(c, Db, "greenEnergyHeroList") //英雄榜单
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyHeroListStyle interface{}
	if greenEnergyHeroList != nil {
		err = json.Unmarshal([]byte(greenEnergyHeroList.Data), &greenEnergyHeroListStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	greenEnergyWelfareActivities, err := commDb.SysModFindByName(c, Db, "greenEnergyWelfareActivities") //福利活动
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	var greenEnergyWelfareActivitiesStyle interface{}
	if greenEnergyWelfareActivities != nil {
		err = json.Unmarshal([]byte(greenEnergyWelfareActivities.Data), &greenEnergyWelfareActivitiesStyle)
		if err != nil {
			e.OutErr(c, e.ERR, err)
			return
		}
	}

	//
	e.OutSuc(c, map[string]interface{}{
		"style": map[string]interface{}{
			"greenEnergyHomepageStyle":                    greenEnergyHomepageStyle,
			"greenEnergyFlowDetailStyle":                  greenEnergyFlowDetailStyle,
			"greenEnergyActivityPointFlowDetailStyle":     greenEnergyActivityPointFlowDetailStyle,
			"greenEnergyPointsCenterStyle":                greenEnergyPointsCenterStyle,
			"greenEnergyEcologicalApplicationManualStyle": greenEnergyEcologicalApplicationManualStyle,
			"greenEnergyBasalRateStyle":                   greenEnergyBasalRateStyle,
			"greenEnergyTotalRateStyle":                   greenEnergyTotalRateStyle,
			"greenEnergyMyTeamStyle":                      greenEnergyMyTeamStyle,
			"greenEnergyHeroListStyle":                    greenEnergyHeroListStyle,
			"greenEnergyWelfareActivitiesStyle":           greenEnergyWelfareActivitiesStyle,
		},
	}, nil)
	return
}

func UserData(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	//2、获取虚拟币值
	var userWalletAmount, userWalletNums string
	wallet, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	if wallet == nil {
		userWalletAmount = "0.00000000"
		userWalletNums = "0.00000000"
	} else {
		userWalletNums = wallet.Amount
		walletAmount, _ := decimal.NewFromString(wallet.Amount)
		nowPrice, _ := decimal.NewFromString(oneCirclesGreenEnergyBasicSetting.NowPrice)
		userWalletAmount = walletAmount.Mul(nowPrice).RoundFloor(8).String()
	}
	e.OutSuc(c, map[string]interface{}{
		"user_green_energy_nums":   userWalletNums,
		"user_green_energy_amount": userWalletAmount,
	}, nil)
	return
}

func HeroList(c *gin.Context) {
	kind := c.DefaultQuery("kind", "1")
	startDate := c.DefaultQuery("start_date", "")
	endDate := c.DefaultQuery("end_date", "")
	page := utils.StrToInt(c.DefaultQuery("page", "1"))
	limit := utils.StrToInt(c.DefaultQuery("limit", "10"))
	offset := (page - 1) * limit
	if offset < 0 {
		offset = 0
	}

	engine := commSvc.MasterDb(c)
	var sql string
	if kind == "1" {
		sql = "SELECT SUM(amout) AS sum_value, user_virtual_coin_flow.uid, user.nickname as username, user_profile.avatar_url FROM `user_virtual_coin_flow` " +
			"LEFT JOIN `user` ON user_virtual_coin_flow.uid = user.uid " +
			"LEFT JOIN `user_profile` ON user_virtual_coin_flow.uid = user_profile.uid where 1=1"
		if startDate != "" {
			sql += " AND  user_virtual_coin_flow.create_time >= '" + startDate + "'"
		}
		if endDate != "" {
			sql += " AND  user_virtual_coin_flow.create_time <= '" + endDate + "'"
		}
		sql += " GROUP BY user_virtual_coin_flow.uid ORDER BY sum_value DESC LIMIT %d, %d;"
	} else {
		sql = "SELECT COUNT(*) AS sum_value, user_relate.uid, user.nickname as username, user_profile.avatar_url FROM `user_relate` " +
			"LEFT JOIN `user` ON user_relate.uid = user.uid " +
			"LEFT JOIN `user_profile` ON user_relate.uid = user_profile.uid WHERE 1=1"
		if startDate != "" {
			sql += " AND user_relate.invite_time >= '" + startDate + "'"
		}
		if endDate != "" {
			sql += " AND  user_relate.invite_time <= '" + endDate + "'"
		}
		sql += " GROUP BY user_relate.parent_uid ORDER BY sum_value DESC LIMIT %d, %d;"
	}
	sql = fmt.Sprintf(sql, offset, limit)
	results, err := commDb.QueryNativeString(engine, sql)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	var isEnd bool
	if len(results) < limit {
		isEnd = true
	}
	e.OutSuc(c, map[string]interface{}{
		"list":   results,
		"is_end": isEnd,
	}, nil)
	return
}

func WelfareActivities(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var welfareOrdersLimit *md.WelfareOrdersLimit
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.WelfareOrdersLimit), &welfareOrdersLimit)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	//2、统计当前会员用户数
	var sql = "SELECT COUNT(*)total FROM user "
	results, err := commDb.QueryNativeString(engine, sql)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	nowTotal := utils.StrToInt64(results[0]["total"])

	//3、进行循环比较
	var diffMembers int64
	for _, v := range welfareOrdersLimit.PlatformMembers {
		from := v.From
		to := v.To
		if utils.StrToInt64(from) <= nowTotal && nowTotal <= utils.StrToInt64(to) {
			diffMembers = utils.StrToInt64(to) - nowTotal
		}
	}
	//4、组装抢购条件语句
	var welfareOrdersLimitText []string
	welfareOrdersLimitText = append(welfareOrdersLimitText, fmt.Sprintf("1、会员本人连续日活 %s 天;", welfareOrdersLimit.ContinuousDailyActivityNums))
	welfareOrdersLimitText = append(welfareOrdersLimitText, fmt.Sprintf("2、直推用户不低于 %s 名，且连续日活 %s 天;", welfareOrdersLimit.DirectPushLimit.DirectPushUserNums, welfareOrdersLimit.DirectPushLimit.ContinuousDailyActivityNums))
	welfareOrdersLimitText = append(welfareOrdersLimitText, fmt.Sprintf("3、单个账号，每次开启仅限购 %s 份;", welfareOrdersLimit.SingleUserLimitBuyNums))
	welfareOrdersLimitText = append(welfareOrdersLimitText, "4、最终解释权归平台所有;")
	e.OutSuc(c, map[string]interface{}{
		"now_members":               nowTotal,
		"diff_members":              diffMembers,
		"welfare_orders_limit_text": welfareOrdersLimitText,
	}, nil)
	return
}

func EcologicalApplicationManual(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var signInRewards []*md.SignInRewardStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.SignInReward), &signInRewards)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//2、统计全网用户数
	sqlStr := "SELECT COUNT(*) AS total FROM user "
	nativeString, _ := commDb.QueryNativeString(engine, sqlStr)
	userCount := zhios_order_relate_utils.StrToInt64(nativeString[0]["total"])

	var nextReduceMembers string
	for k, v := range signInRewards {
		if zhios_order_relate_utils.StrToInt64(v.VipMemberEndNums) >= userCount && userCount >= zhios_order_relate_utils.StrToInt64(v.VipMemberStartNums) {
			nextReduceMembers = utils.Int64ToStr(utils.StrToInt64(signInRewards[k+1].VipMemberStartNums) - userCount)
		}
	}

	//3、组装抢购条件语句
	var welfareOrdersLimit *md.WelfareOrdersLimit
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.WelfareOrdersLimit), &welfareOrdersLimit)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var welfareOrdersLimitText []string
	welfareOrdersLimitText = append(welfareOrdersLimitText, fmt.Sprintf("1、会员本人连续日活 %s 天;", welfareOrdersLimit.ContinuousDailyActivityNums))
	welfareOrdersLimitText = append(welfareOrdersLimitText, fmt.Sprintf("2、直推用户不低于 %s 名，且连续日活 %s 天;", welfareOrdersLimit.DirectPushLimit.DirectPushUserNums, welfareOrdersLimit.DirectPushLimit.ContinuousDailyActivityNums))
	welfareOrdersLimitText = append(welfareOrdersLimitText, fmt.Sprintf("3、单个账号，每次开启仅限购 %s 份;", welfareOrdersLimit.SingleUserLimitBuyNums))
	welfareOrdersLimitText = append(welfareOrdersLimitText, "4、最终解释权归平台所有;")

	//4、查找 `OneCirclesPublicPlatoonBasicSetting` 基础设置
	oneCirclesPublicPlatoonBasicSetting, err := db.OneCirclesPublicPlatoonBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	systemPunishReplace := oneCirclesPublicPlatoonBasicSetting.SystemPunishReplaceValue

	//5、会员权益
	var vipEquitySetting []*md.VipEquitySettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.VipEquitySetting), &vipEquitySetting)
	if err != nil {
		return
	}
	lvList := commDb.UserLevelByAllMap(engine)
	var vipEquitySettingText []map[string]string
	var upgradeConditions = []string{
		"免费注册", "邀请20名", "邀请30名", "邀请50名", "邀请100名", "邀请300名", "邀请500名", "邀请1000名", "邀请3000名", "邀请5000名",
	}
	for k, v := range vipEquitySetting {
		if lvList[utils.StrToInt(v.VipLevelId)] != nil {
			vipEquitySettingText = append(vipEquitySettingText, map[string]string{
				"name":                         lvList[utils.StrToInt(v.VipLevelId)].LevelName,
				"exchange_account_balance_fee": v.ExchangeAccountBalanceFee + "%",
				"dividend_ratio":               v.DividendRatio + "%",
				"upgrade_conditions":           upgradeConditions[k],
			})
		}
	}
	e.OutSuc(c, map[string]interface{}{
		"next_reduce_members":       nextReduceMembers,
		"system_punish_replace":     systemPunishReplace,
		"now_members":               userCount,
		"welfare_orders_limit_text": welfareOrdersLimitText,
		"upgrade_conditions":        vipEquitySettingText,
	}, nil)
	return
}

func BasalRate(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	now := time.Now()
	var oneRoundDuration = zhios_order_relate_utils.StrToInt(teamRewardSetting.OneRoundDuration)
	startTime := now.Add(-time.Hour * time.Duration(oneRoundDuration)).Format("2006-01-02 15:04:05")
	var oneCirclesGreenEnergySignIn model.OneCirclesGreenEnergySignIn
	get, err := engine.Where("start_time >= ?", startTime).And("uid =?", user.Info.Uid).And("is_completed =?", 0).Get(&oneCirclesGreenEnergySignIn)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	var signRewardGreenEnergy string
	var signCountdown string
	if !get {
		signRewardGreenEnergy = "0.00"
	} else {
		err, signRewardGreenEnergy = one_circles.CalcNowSignInGreenEnergy(engine, oneCirclesGreenEnergyBasicSetting)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
		endTime := utils.String2Time(oneCirclesGreenEnergySignIn.EndTime)
		duration := endTime.Sub(now)                  // 计算时间差值
		hours := duration / time.Hour                 // 获取小时部分
		minutes := duration % time.Hour / time.Minute // 获取分钟部分（先除去小时后再乘以60）
		seconds := int64(duration/time.Second) % 60
		signCountdown = fmt.Sprintf("%d:%d:%d", hours, minutes, seconds) //收益倒计时
	}
	nowBasalRate := utils.StrToFloat64(signRewardGreenEnergy) * 60 * 60 //每小时基础速率

	//2、组装距状图数据
	var signInRewards []*md.SignInRewardStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.SignInReward), &signInRewards)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var barChartYData, barChartXData []string
	for _, v := range signInRewards {
		barChartYData = append(barChartYData, utils.Float64ToStrPrec8(utils.StrToFloat64(v.RewardValue)*60*60))
		var vipMemberStartNum, vipMemberEndNums int64
		vipMemberStartNum = utils.StrToInt64(v.VipMemberStartNums)
		vipMemberEndNums = utils.StrToInt64(v.VipMemberEndNums)
		var vipMemberStartNumStr, vipMemberEndNumsStr string
		if vipMemberStartNum >= 10000 && vipMemberStartNum < 100000 {
			vipMemberStartNum = vipMemberStartNum / 10000
			vipMemberStartNumStr = utils.Int64ToStr(vipMemberStartNum) + "万"
		} else if vipMemberStartNum >= 100000 && vipMemberStartNum < 1000000 {
			vipMemberStartNum = vipMemberStartNum / 100000
			vipMemberStartNumStr = utils.Int64ToStr(vipMemberStartNum) + "十万"
		} else if vipMemberStartNum >= 1000000 && vipMemberStartNum < 10000000 {
			vipMemberStartNum = vipMemberStartNum / 1000000
			vipMemberStartNumStr = utils.Int64ToStr(vipMemberStartNum) + "百万"
		} else if vipMemberStartNum >= 10000000 {
			vipMemberStartNum = vipMemberStartNum / 10000000
			vipMemberStartNumStr = utils.Int64ToStr(vipMemberStartNum) + "千万"
		} else {
			vipMemberStartNumStr = utils.Int64ToStr(vipMemberStartNum)
		}

		if vipMemberEndNums >= 10000 && vipMemberEndNums < 100000 {
			vipMemberEndNums = vipMemberEndNums / 10000
			vipMemberEndNumsStr = utils.Int64ToStr(vipMemberEndNums) + "万"
		} else if vipMemberEndNums >= 100000 && vipMemberEndNums < 1000000 {
			vipMemberEndNums = vipMemberEndNums / 100000
			vipMemberEndNumsStr = utils.Int64ToStr(vipMemberEndNums) + "十万"
		} else if vipMemberEndNums >= 1000000 && vipMemberEndNums < 10000000 {
			vipMemberEndNums = vipMemberEndNums / 1000000
			vipMemberEndNumsStr = utils.Int64ToStr(vipMemberEndNums) + "百万"
		} else if vipMemberEndNums >= 10000000 {
			vipMemberEndNums = vipMemberEndNums / 10000000
			vipMemberEndNumsStr = utils.Int64ToStr(vipMemberEndNums) + "千万"
		} else {
			vipMemberEndNumsStr = utils.Int64ToStr(vipMemberEndNums)

		}
		barChartXData = append(barChartXData, vipMemberStartNumStr+"~"+vipMemberEndNumsStr)
	}

	//3、统计当前平台累计用户、距离下次减产还剩多少人
	results, err := commDb.QueryNativeString(engine, "SELECT COUNT(*)AS total FROM user")
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	userCount := utils.StrToInt64(results[0]["total"])
	var nextReduceMembers string
	for k, v := range signInRewards {
		if zhios_order_relate_utils.StrToInt64(v.VipMemberEndNums) >= userCount && userCount >= zhios_order_relate_utils.StrToInt64(v.VipMemberStartNums) {
			nextReduceMembers = utils.Int64ToStr(utils.StrToInt64(signInRewards[k+1].VipMemberStartNums) - userCount)
		}
	}
	e.OutSuc(c, map[string]interface{}{
		"now_basal_rate":      nowBasalRate,
		"sign_countdown":      signCountdown,
		"user_count":          userCount,
		"next_reduce_members": nextReduceMembers,
		"bar_chart_data": map[string]interface{}{
			"x_data": barChartXData,
			"y_data": barChartYData,
		},
	}, nil)
	return
}

func TotalRate(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	now := time.Now()
	var oneRoundDuration = zhios_order_relate_utils.StrToInt(teamRewardSetting.OneRoundDuration)
	startTime := now.Add(-time.Hour * time.Duration(oneRoundDuration)).Format("2006-01-02 15:04:05")
	var oneCirclesGreenEnergySignIn model.OneCirclesGreenEnergySignIn
	get, err := engine.Where("start_time >= ?", startTime).And("uid =?", user.Info.Uid).And("is_completed =?", 0).Get(&oneCirclesGreenEnergySignIn)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	var signRewardGreenEnergy string
	if !get {
		signRewardGreenEnergy = "0.00"
	} else {
		err, signRewardGreenEnergy = one_circles.CalcNowSignInGreenEnergy(engine, oneCirclesGreenEnergyBasicSetting)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	}
	nowBasalRate := utils.StrToFloat64(signRewardGreenEnergy) * 60 * 60 //每小时基础速率

	//2、统计当前平台累计用户、下次减产奖励值
	var signInRewards []*md.SignInRewardStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.SignInReward), &signInRewards)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	results, err := commDb.QueryNativeString(engine, "SELECT COUNT(*)AS total FROM user")
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	userCount := utils.StrToInt64(results[0]["total"])
	var nextReduceValue string
	for k, v := range signInRewards {
		if zhios_order_relate_utils.StrToInt64(v.VipMemberEndNums) >= userCount && userCount >= zhios_order_relate_utils.StrToInt64(v.VipMemberStartNums) {
			nextReduceValue = utils.Float64ToStrPrec8(utils.StrToFloat64(signInRewards[k+1].RewardValue) * 60 * 60)
		}
	}

	//3、计算当前团队速率
	userRelates, err := db2.DbsUserRelateByParentUid(engine, user.Info.Uid, 0)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var userRelatesUids []int
	var userRelatesMap = map[int]model.UserRelate{}
	if userRelates != nil {
		for _, userRelate := range *userRelates {
			userRelatesUids = append(userRelatesUids, userRelate.Uid)
			userRelatesMap[userRelate.Uid] = userRelate
		}
	}

	var oneCirclesGreenEnergySignIns []*model.OneCirclesGreenEnergySignIn
	err = engine.Where("start_time >= ?", startTime).In("uid", userRelatesUids).And("is_completed =?", 0).Find(&oneCirclesGreenEnergySignIns)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	var nowTeamRate float64 //每小时基础速率
	nowBasalRateValue := decimal.NewFromFloat(nowBasalRate)
	for _, vv := range oneCirclesGreenEnergySignIns {
		rewardDecrementValue := utils.StrToFloat64(teamRewardSetting.RewardDecrementValue) / 100
		tmpRewardBase := decimal.NewFromFloat(math.Pow(rewardDecrementValue, float64(userRelatesMap[vv.Uid].Level)))
		tmpReward := nowBasalRateValue.Mul(tmpRewardBase)
		rewardEndValue, _ := decimal.NewFromString(teamRewardSetting.RewardEndValue)
		if tmpReward.GreaterThanOrEqual(rewardEndValue) {
			tmpRewardValue, _ := tmpReward.Float64()
			nowTeamRate += tmpRewardValue
		}
	}

	e.OutSuc(c, map[string]interface{}{
		"now_basal_rate":               nowBasalRate,
		"next_reduce_value":            nextReduceValue,
		"now_team_rate":                nowTeamRate,
		"now_team_user_online":         len(oneCirclesGreenEnergySignIns),
		"now_team_user_online_formula": fmt.Sprintf("%d * %s * ... * %f", len(oneCirclesGreenEnergySignIns), teamRewardSetting.RewardDecrementValue, nowBasalRate),
	}, nil)
	return
}

func MyTeam(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	now := time.Now()
	var oneRoundDuration = zhios_order_relate_utils.StrToInt(teamRewardSetting.OneRoundDuration)
	startTime := now.Add(-time.Hour * time.Duration(oneRoundDuration)).Format("2006-01-02 15:04:05")
	var oneCirclesGreenEnergySignIn model.OneCirclesGreenEnergySignIn
	get, err := engine.Where("start_time >= ?", startTime).And("uid =?", user.Info.Uid).And("is_completed =?", 0).Get(&oneCirclesGreenEnergySignIn)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	var signRewardGreenEnergy string
	if !get {
		signRewardGreenEnergy = "0.00"
	} else {
		err, signRewardGreenEnergy = one_circles.CalcNowSignInGreenEnergy(engine, oneCirclesGreenEnergyBasicSetting)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	}
	nowBasalRate := utils.StrToFloat64(signRewardGreenEnergy) * 60 * 60 //每小时基础速率

	//2、统计当前平台累计用户、下次减产奖励值
	var signInRewards []*md.SignInRewardStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.SignInReward), &signInRewards)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	results, err := commDb.QueryNativeString(engine, "SELECT COUNT(*)AS total FROM user")
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	userCount := utils.StrToInt64(results[0]["total"])
	var nextReduceValue string
	for k, v := range signInRewards {
		if zhios_order_relate_utils.StrToInt64(v.VipMemberEndNums) >= userCount && userCount >= zhios_order_relate_utils.StrToInt64(v.VipMemberStartNums) {
			nextReduceValue = signInRewards[k+1].RewardValue
		}
	}

	//3、计算当前团队速率
	userRelates, err := db2.DbsUserRelateByParentUid(engine, user.Info.Uid, 0)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var userRelatesUids []int
	var userRelatesMap = map[int]model.UserRelate{}
	if userRelates != nil {
		for _, userRelate := range *userRelates {
			userRelatesUids = append(userRelatesUids, userRelate.Uid)
			userRelatesMap[userRelate.Uid] = userRelate
		}
	}

	var oneCirclesGreenEnergySignIns []*model.OneCirclesGreenEnergySignIn
	err = engine.Where("start_time >= ?", startTime).In("uid", userRelatesUids).And("is_completed =?", 0).Find(&oneCirclesGreenEnergySignIns)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	var nowTeamRate float64 //每小时基础速率
	nowBasalRateValue := decimal.NewFromFloat(nowBasalRate)
	for _, vv := range oneCirclesGreenEnergySignIns {
		rewardDecrementValue := utils.StrToFloat64(teamRewardSetting.RewardDecrementValue) / 100
		tmpRewardBase := decimal.NewFromFloat(math.Pow(rewardDecrementValue, float64(userRelatesMap[vv.Uid].Level)))
		tmpReward := nowBasalRateValue.Mul(tmpRewardBase)
		rewardEndValue, _ := decimal.NewFromString(teamRewardSetting.RewardEndValue)
		if tmpReward.GreaterThanOrEqual(rewardEndValue) {
			tmpRewardValue, _ := tmpReward.Float64()
			nowTeamRate += tmpRewardValue
		}
	}

	e.OutSuc(c, map[string]interface{}{
		"now_basal_rate":               nowBasalRate,
		"next_reduce_value":            nextReduceValue,
		"now_team_rate":                nowTeamRate,
		"now_team_user":                len(*userRelates),
		"now_team_user_online":         len(oneCirclesGreenEnergySignIns),
		"now_team_user_online_formula": fmt.Sprintf("%d * %s * ... * %f", len(oneCirclesGreenEnergySignIns), teamRewardSetting.RewardDecrementValue, nowBasalRate),
	}, nil)
	return
}

func GreenEnergyDetails(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	user := commSvc.GetUser(c)
	args["uid"] = utils.IntToStr(user.Info.Uid)
	if args["kind"] == "1" {
		args["coin_id"] = utils.IntToStr(oneCirclesGreenEnergyBasicSetting.TeamGreenEnergyCoinId)
	} else {
		args["coin_id"] = utils.IntToStr(oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId)
	}
	flow := commDb.GetUserVirtualAmountFlow(engine, args)
	var list = make([]map[string]string, 0)
	if flow != nil {
		for _, v := range *flow {
			var tmp = map[string]string{
				"title":         v.Title,
				"time":          v.CreateTime.Format("2006-01-02 15:04"),
				"type":          utils.IntToStr(v.Direction),
				"value":         commSvc.GetPrec(c, v.Amout, "8"),
				"transfer_type": utils.IntToStr(v.TransferType),
				"price":         "",
				//"ico":   "http://teamplate.zhios.cn/%E7%AC%A6%E5%8F%B7%E5%A4%87%E4%BB%BD6%402x.png",
			}
			list = append(list, tmp)
		}
	}

	//3、获取当前用户 绿色能量(可用+结算)、 预估总价值
	var totalGreenEnergy, totalGreenEnergyPrice float64
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	personGreenEnergy, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	teamGreenEnergy, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.TeamGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	totalGreenEnergy = utils.StrToFloat64(personGreenEnergy.Amount) + utils.StrToFloat64(teamGreenEnergy.Amount)
	totalGreenEnergyPrice = totalGreenEnergy * utils.StrToFloat64(oneCirclesGreenEnergyBasicSetting.NowPrice)

	res := map[string]interface{}{
		"person_green_energy":      utils.StrToFloat64(personGreenEnergy.Amount),
		"team_green_energy":        utils.StrToFloat64(teamGreenEnergy.Amount),
		"total_green_energy":       totalGreenEnergy,
		"total_green_energy_price": totalGreenEnergyPrice,
		"list":                     list,
		"transfer_type_list": []map[string]interface{}{
			{
				"value": md2.OneCirclesGreenEnergySignInSettlementPersonalRewardForUserVirtualCoinFlow,
				"name":  md2.OneCirclesGreenEnergySignInSettlementPersonalReward,
			},
			{
				"value": md2.OneCirclesGreenEnergySignInSettlementTeamRewardForUserVirtualCoinFlow,
				"name":  md2.OneCirclesGreenEnergySignInSettlementTeamReward,
			},
			{
				"value": md2.OneCirclesBalanceExchangeForGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesBalanceExchangeForGreenEnergy,
			},
			{
				"value": md2.OneCirclesGreenEnergyExchangeForBalanceForUserVirtualCoinFlow,
				"name":  md2.OneCirclesGreenEnergyExchangeForBalance,
			},
			{
				"value": md2.OneCirclesPersonalActiveCoinExchangeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesPersonalActiveCoinExchangeGreenEnergy,
			},
			{
				"value": md2.OneCirclesTeamActiveCoinExchangeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesTeamActiveCoinExchangeGreenEnergy,
			},
			{
				"value": md2.OneCirclesSettlementGreenEnergyExchangeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesSettlementGreenEnergyExchangeGreenEnergy,
			},
			{
				"value": md2.OneCirclesWelfareOrdersExchangeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesWelfareOrdersExchangeGreenEnergy,
			},
			{
				"value": md2.OneCirclesConsumeOrdersExchangeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesConsumeOrdersExchangeGreenEnergy,
			},
			{
				"value": md2.OneCirclesSettlementGreenEnergyExchangeTobeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesSettlementGreenEnergyExchangeTobeGreenEnergy,
			},
		},
	}
	e.OutSuc(c, res, nil)
	return
}

func NineDimensionalSpace(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	//1、 查找 `one_circles_public_platoon_basic_setting` 基础设置
	oneCirclesPublicPlatoonBasicSetting, err := db.OneCirclesPublicPlatoonBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	if oneCirclesPublicPlatoonBasicSetting == nil {
		e.OutErr(c, e.ERR_NO_DATA, err.Error())
		return
	}
	uid := commSvc.GetUser(c).Info.Uid

	var list []map[string]interface{}
	for i := 1; i <= oneCirclesPublicPlatoonBasicSetting.SeveralRows; i++ {
		var tmpSql = fmt.Sprintf("SELECT COUNT(*)AS total FROM `one_circles_public_platoon_user_relation` WHERE father_uid%d = %d", i, uid)
		tmpNativeString, _ := commDb.QueryNativeString(engine, tmpSql)
		nowUserCount := zhios_order_relate_utils.StrToInt64(tmpNativeString[0]["total"])
		list = append(list, map[string]interface{}{
			"name":      utils.IntToStr(i) + "维",
			"max_count": math.Pow(float64(oneCirclesPublicPlatoonBasicSetting.SeveralTimes), float64(i)),
			"now_count": nowUserCount,
		})
	}

	////2、计算当前全网人数
	//sql := "SELECT COUNT(*) AS total FROM `one_circles_public_platoon_user_relation`"
	//nativeString, _ := commDb.QueryNativeString(engine, sql)
	//userCount := zhios_order_relate_utils.StrToInt64(nativeString[0]["total"])

	//3、统计当前用户下多少人数
	sql := fmt.Sprintf("SELECT COUNT(*)AS total FROM `one_circles_public_platoon_user_relation` WHERE father_uid1 = %d OR father_uid2= %d OR father_uid3= %d OR father_uid4= %d OR father_uid5= %d OR father_uid6= %d OR father_uid7= %d OR father_uid8= %d", uid, uid, uid, uid, uid, uid, uid, uid)
	nativeString1, _ := commDb.QueryNativeString(engine, sql)
	hasUserCount := zhios_order_relate_utils.StrToInt64(nativeString1[0]["total"])

	res := map[string]interface{}{
		"space_total_nums": 29523,
		"space_nums":       hasUserCount,
		"space_list":       list,
		"a_lot_of_nums":    29523,
	}
	e.OutSuc(c, res, nil)
	return
}

func ActivePointsDetails(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	//1、 查找 `OneCirclesPublicPlatoonBasicSetting` 基础设置
	oneCirclesPublicPlatoonBasicSetting, err := db.OneCirclesPublicPlatoonBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	user := commSvc.GetUser(c)
	args["uid"] = utils.IntToStr(user.Info.Uid)
	if args["kind"] == "1" {
		args["coin_id"] = utils.IntToStr(oneCirclesPublicPlatoonBasicSetting.PersonActivePointsCoinId)
	} else {
		args["coin_id"] = utils.IntToStr(oneCirclesPublicPlatoonBasicSetting.TeamActivePointsCoinId)
	}
	flow := commDb.GetUserVirtualAmountFlow(engine, args)
	var list = make([]map[string]string, 0)
	if flow != nil {
		for _, v := range *flow {
			var tmp = map[string]string{
				"title":         v.Title,
				"time":          v.CreateTime.Format("2006-01-02 15:04"),
				"type":          utils.IntToStr(v.Direction),
				"value":         commSvc.GetPrec(c, v.Amout, "8"),
				"price":         "",
				"transfer_type": utils.IntToStr(v.TransferType),
				//"ico":   "http://teamplate.zhios.cn/%E7%AC%A6%E5%8F%B7%E5%A4%87%E4%BB%BD6%402x.png",
			}
			list = append(list, tmp)
		}
	}

	var totalActivePoints float64
	personActivePoints, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesPublicPlatoonBasicSetting.PersonActivePointsCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	teamActivePoints, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesPublicPlatoonBasicSetting.TeamActivePointsCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	totalActivePoints = utils.StrToFloat64(personActivePoints.Amount) + utils.StrToFloat64(teamActivePoints.Amount)
	coin, _ := commDb.VirtualCoinGetOneById(engine, oneCirclesPublicPlatoonBasicSetting.PersonActivePointsCoinId)
	exchangeRatio, _ := decimal.NewFromString(coin.ExchangeRatio)
	totalActivePointsValue := decimal.NewFromFloat(totalActivePoints)
	totalActivePointsAmount := totalActivePointsValue.Div(exchangeRatio).String()

	res := map[string]interface{}{
		"person_active_points":       utils.StrToFloat64(personActivePoints.Amount),
		"team_active_points":         utils.StrToFloat64(teamActivePoints.Amount),
		"total_active_points":        totalActivePoints,
		"total_active_points_amount": totalActivePointsAmount,
		"list":                       list,
		"transfer_type_list": []map[string]interface{}{
			{
				"value": md2.OneCirclesWatchAdRewardPersonalActiveCoinForUserVirtualCoinFlow,
				"name":  md2.OneCirclesWatchAdRewardPersonalActiveCoin,
			},
			{
				"value": md2.OneCirclesWatchAdRewardTeamActiveCoinForUserVirtualCoinFlow,
				"name":  md2.OneCirclesWatchAdRewardTeamActiveCoin,
			},
			{
				"value": md2.OneCirclesPersonalActiveCoinExchangeToBeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesPersonalActiveCoinExchangeToBeGreenEnergy,
			},
			{
				"value": md2.OneCirclesTeamActiveCoinExchangeToBeGreenEnergyForUserVirtualCoinFlow,
				"name":  md2.OneCirclesTeamActiveCoinExchangeToBeGreenEnergy,
			},
		},
	}
	e.OutSuc(c, res, nil)
	return
}

func MyTeamUserList(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	now := time.Now()
	user := commSvc.GetUser(c)

	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var oneRoundDuration = zhios_order_relate_utils.StrToInt(teamRewardSetting.OneRoundDuration)
	startTime := now.Add(-time.Hour * time.Duration(oneRoundDuration)).Format("2006-01-02 15:04:05")
	userRelates, err := db2.DbsUserRelateByParentUid(engine, user.Info.Uid, 1)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var userRelatesUids []string
	var userSignInMap = map[int]interface{}{}
	var results []map[string]string
	if userRelates != nil {
		for _, userRelate := range *userRelates {
			userRelatesUids = append(userRelatesUids, utils.IntToStr(userRelate.Uid))
		}

		var oneCirclesGreenEnergySignIns []*model.OneCirclesGreenEnergySignIn
		err = engine.Where("start_time >= ?", startTime).In("uid", userRelatesUids).And("is_completed =?", 0).Find(&oneCirclesGreenEnergySignIns)
		if err != nil {
			e.OutErr(c, e.ERR_DB_ORM, err.Error())
			return
		}
		for _, oneCirclesGreenEnergySignIn := range oneCirclesGreenEnergySignIns {
			userSignInMap[oneCirclesGreenEnergySignIn.Uid] = *oneCirclesGreenEnergySignIn
		}

		var sql string
		sql = "SELECT user_relate.*,user.*,user_profile.* FROM `user_relate` " +
			"LEFT JOIN `user` ON user_relate.uid = user.uid " +
			"LEFT JOIN `user_profile` ON user.uid = user_profile.uid " +
			"where 1=1 AND user_relate.uid IN(%s) GROUP BY user_relate.uid"
		sql += " ORDER BY user_relate.invite_time DESC;"
		uidStr := php2go.Implode(",", userRelatesUids)
		sql = fmt.Sprintf(sql, uidStr)
		results, err = commDb.QueryNativeString(engine, sql)
		if err != nil {
			e.OutErr(c, e.ERR_DB_ORM, err.Error())
			return
		}
	}

	var data []interface{}
	for _, v := range results {
		isOnline := false
		if userSignInMap[int(utils.AnyToInt64(v["uid"]))] != nil {
			isOnline = true
		}
		data = append(data, map[string]interface{}{
			"is_on_line":  isOnline,
			"avatar_url":  v["avatar_url"],
			"nickname":    v["nickname"],
			"invite_time": v["invite_time"],
		})
	}

	e.OutSuc(c, map[string]interface{}{
		"list": data,
	}, nil)
	return
}

func PointsCenterCalcExchange(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	kind := c.DefaultQuery("kind", "1")
	amount := c.DefaultQuery("amount", "")

	var value = "0.00000000"
	var err error
	if kind == "1" { //绿色能量兑换余额
		err, value, _, _, _, _ = one_circles.CalcPriceReductionFormula(engine, amount, strconv.Itoa(user.Level.Id))
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	} else { //余额兑换绿色能量
		err, value, _, _ = one_circles.CalcPriceIncreaseFormula(engine, amount)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
	}

	e.OutSuc(c, map[string]interface{}{
		"value": value,
	}, nil)
	return
}

func PointsCenterExchange(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	kind := c.DefaultQuery("kind", "1")
	amount := c.DefaultQuery("amount", "")

	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	err = rule.InitForIntegralRelease(cfg.RedisAddr)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	session := engine.NewSession()
	defer func() {
		session.Close()
		if err := recover(); err != nil {
			_ = logx.Error(err)
		}
	}()
	session.Begin()
	if kind == "1" { //绿色能量兑换余额
		err1, value, _, greenEnergyFee, _, afterPriceValue := one_circles.CalcPriceReductionFormula(engine, amount, strconv.Itoa(user.Level.Id))
		if err != nil {
			e.OutErr(c, e.ERR, err1.Error())
			return
		}

		//处理绿色能量各区积分流水
		err1 = one_circles.DealAvailableGreenEnergyCoin(session, int(enum.GreenEnergyExchangeBalance), utils.StrToFloat64(amount), utils.StrToFloat64(greenEnergyFee), enum.GreenEnergyExchangeBalance.String(), oneCirclesGreenEnergyBasicSetting, afterPriceValue)
		if err1 != nil {
			session.Rollback()
			e.OutErr(c, 400, err1.Error())
			return
		}
		//增加用户余额
		orderType := enum2.FinUserFlowOrderActionString(md2.GreenEnergyExchangeForBalanceForFinUserFlow)
		err1 = svc.DealUserAmount(session, md2.DealUserAmount{
			Kind:      "add",
			Mid:       c.GetString("mid"),
			Title:     md2.GreenEnergyExchangeForBalanceTitleForFinUserFlow,
			OrderType: orderType,
			OrdAction: md2.GreenEnergyExchangeForBalanceForFinUserFlow,
			OrdId:     "",
			Uid:       user.Info.Uid,
			Amount:    utils.StrToFloat64(value),
			Num:       "",
		})
		if err1 != nil {
			session.Rollback()
			e.OutErr(c, 400, err1.Error())
			return
		}
		//减少用户虚拟币余额
		err = one_circles.DealUserCoin(session, md2.DealUserCoinReq{
			Kind:         "sub",
			Mid:          c.GetString("mid"),
			Title:        md2.OneCirclesGreenEnergyExchangeForBalance,
			TransferType: md2.OneCirclesGreenEnergyExchangeForBalanceForUserVirtualCoinFlow,
			OrdId:        "",
			CoinId:       oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId,
			Uid:          user.Info.Uid,
			Amount:       utils.StrToFloat64(amount),
		})
		if err != nil {
			session.Rollback()
			e.OutErr(c, 400, err.Error())
			return
		}
	} else { //余额兑换绿色能量
		err1, value, _, afterPriceValue := one_circles.CalcPriceIncreaseFormula(engine, amount)
		if err1 != nil {
			e.OutErr(c, e.ERR, err1.Error())
			return
		}
		//处理绿色能量各区积分流水
		err1 = one_circles.DealAvailableGreenEnergyCoin(session, int(enum.AccountBalanceExchange), utils.StrToFloat64(value), utils.StrToFloat64(amount), enum.AccountBalanceExchange.String(), oneCirclesGreenEnergyBasicSetting, afterPriceValue)
		if err1 != nil {
			session.Rollback()
			e.OutErr(c, 400, err1.Error())
			return
		}
		//减少用户余额
		orderType := enum2.FinUserFlowOrderActionString(md2.BalanceExchangeForGreenEnergyForFinUserFlow)
		fmt.Println(c.GetString("mid"))
		err1 = svc.DealUserAmount(session, md2.DealUserAmount{
			Kind:      "sub",
			Mid:       c.GetString("mid"),
			Title:     md2.BalanceExchangeForGreenEnergyTitleForFinUserFlow,
			OrderType: orderType,
			OrdAction: md2.BalanceExchangeForGreenEnergyForFinUserFlow,
			OrdId:     "",
			Uid:       user.Info.Uid,
			Amount:    utils.StrToFloat64(amount),
			Num:       "",
		})
		if err1 != nil {
			fmt.Println(err1.Error())
			session.Rollback()
			e.OutErr(c, 400, err1.Error())
			return
		}
		//增加用户绿色能量
		err = one_circles.DealUserCoin(session, md2.DealUserCoinReq{
			Kind:         "add",
			Mid:          c.GetString("mid"),
			Title:        md2.OneCirclesBalanceExchangeForGreenEnergy,
			TransferType: md2.OneCirclesBalanceExchangeForGreenEnergyForUserVirtualCoinFlow,
			OrdId:        "",
			CoinId:       oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId,
			Uid:          user.Info.Uid,
			Amount:       utils.StrToFloat64(value),
		})
		if err != nil {
			session.Rollback()
			e.OutErr(c, 400, err.Error())
			return
		}
	}
	session.Commit()
	e.OutSuc(c, "success", nil)
	return
}

func PointsCenterPriceCurve(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	kind := c.DefaultQuery("kind", "1")
	now := time.Now()
	////1、查找 `one_circles_green_energy_basic_setting` 基础设置
	//oneCirclesGreenEnergyBasicSetting, err := db.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
	//	"key":   "is_open",
	//	"value": 1,
	//})
	//if err != nil {
	//	e.OutErr(c, e.ERR, err.Error())
	//	return
	//}

	var yData []interface{}
	var xData []interface{}
	switch kind {
	case "1":
		var date = now.AddDate(0, 0, -6).Format("2006-01-02")
		var sql = fmt.Sprintf("SELECT price,date FROM `one_circles_green_energy_price` WHERE HOUR = 23 AND DATE >= \"%s\" ORDER BY DATE ASC ", date)
		results, _ := commDb.QueryNativeString(engine, sql)
		for _, v := range results {
			tmpDate := utils.String2TimeV2(v["date"])
			yData = append(yData, v["price"])
			xData = append(xData, tmpDate.Format("01-02"))
		}
		break
	case "2":
		for i := 6; i >= 1; i-- {
			date := now.Add(-time.Hour * 4 * time.Duration(i)).Format("2006-01-02")
			hour := now.Add(-time.Hour * 4 * time.Duration(i)).Hour()
			var sql = "SELECT price,date,hour FROM `one_circles_green_energy_price` WHERE HOUR = %d AND DATE = \"%s\" "
			sql = fmt.Sprintf(sql, hour, date)
			results, _ := commDb.QueryNativeString(engine, sql)
			if results != nil {
				if results[0]["date"] != now.Format("2006-01-02") {
					continue
				}
				yData = append(yData, results[0]["price"])
				xData = append(xData, results[0]["hour"]+":00")
			}
		}
		break
	case "3":
		for i := 6; i >= 1; i-- {
			var date = now.AddDate(0, 0, -7*i).Format("2006-01-02")
			var sql = "SELECT price,date FROM `one_circles_green_energy_price` WHERE HOUR = 23 AND DATE = \"%s\" "
			sql = fmt.Sprintf(sql, date)
			results, _ := commDb.QueryNativeString(engine, sql)
			if results != nil {
				tmpDate := utils.String2TimeV2(results[0]["date"])
				yData = append(yData, results[0]["price"])
				xData = append(xData, tmpDate.Format("01-02"))
			}
		}
		break
	}

	e.OutSuc(c, map[string]interface{}{
		"yData": yData,
		"xData": xData,
	}, nil)
	return
}

func PointsCenter(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)

	//1、查找 `one_circles_green_energy_basic_setting` 基础设置 && 查找 `OneCirclesPublicPlatoonBasicSetting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	oneCirclesPublicPlatoonBasicSetting, err := db.OneCirclesPublicPlatoonBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//2、计算今日涨幅
	err, rises, isRises := one_circles.CalcTodayGreenEnergyPriceRises(engine, oneCirclesGreenEnergyBasicSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//3、获取当前用户 绿色能量(可用+结算)、 预估总价值
	var totalGreenEnergy, totalGreenEnergyPrice float64
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	personGreenEnergy, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	teamGreenEnergy, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.TeamGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	totalGreenEnergy = utils.StrToFloat64(personGreenEnergy.Amount) + utils.StrToFloat64(teamGreenEnergy.Amount)
	totalGreenEnergyPrice = totalGreenEnergy * utils.StrToFloat64(oneCirclesGreenEnergyBasicSetting.NowPrice)

	//4、活跃积分(个人+团队)、预估总价值
	var totalActivePoints float64
	personActivePoints, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesPublicPlatoonBasicSetting.PersonActivePointsCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	teamActivePoints, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesPublicPlatoonBasicSetting.TeamActivePointsCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	totalActivePoints = utils.StrToFloat64(personActivePoints.Amount) + utils.StrToFloat64(teamActivePoints.Amount)
	coin, _ := commDb.VirtualCoinGetOneById(engine, oneCirclesPublicPlatoonBasicSetting.PersonActivePointsCoinId)
	exchangeRatio, _ := decimal.NewFromString(coin.ExchangeRatio)
	totalActivePointsValue := decimal.NewFromFloat(totalActivePoints)
	totalActivePointsAmount := totalActivePointsValue.Div(exchangeRatio).String()
	//err, totalActivePointsExchangeGreenNums, _, _ := one_circles.CalcPriceIncreaseFormula(engine, totalActivePointsAmount)
	//if err != nil {
	//	return
	//}

	//5、个人可用余额、预估总价值
	err, totalAmountExchangeGreenNums, _, _ := one_circles.CalcPriceIncreaseFormula(engine, user.Profile.FinValid)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//5、计算动态数据
	var sql1 = fmt.Sprintf("SELECT SUM(amount) AS total FROM `user_virtual_amount` WHERE coin_id = %d", oneCirclesGreenEnergyBasicSetting.TeamGreenEnergyCoinId)
	var sql2 = fmt.Sprintf("SELECT SUM(amount) AS total FROM `user_virtual_amount` WHERE coin_id = %d", oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId)
	var sql3 = fmt.Sprintf("SELECT SUM(amount) AS total FROM `one_circles_available_green_energy_points_flow` WHERE kind = %d", enum.SignInReward)
	results1, _ := commDb.QueryNativeString(engine, sql1) //待释放总量
	results2, _ := commDb.QueryNativeString(engine, sql2) //用户持有总量
	results3, _ := commDb.QueryNativeString(engine, sql3) // 已赠送总量

	var vipEquitySetting []*md.VipEquitySettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.VipEquitySetting), &vipEquitySetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var exchangeAccountBalanceFeeValue string
	for _, v := range vipEquitySetting {
		if v.VipLevelId == utils.IntToStr(user.Level.Id) {
			exchangeAccountBalanceFeeValue = v.ExchangeAccountBalanceFee
		}
	}
	if exchangeAccountBalanceFeeValue == "" {
		e.OutErr(c, e.ERR, "未查询到当前会员等级兑换余额手续费")
		return
	}
	var tipsStr = "温馨提示：当前兑换余额积分手续费%s，升级可降低手续费至%s哟！"
	topLevel, err := commDb.UserLevelTop(engine)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	if user.Level.Id == topLevel.Id {
		tipsStr = "温馨提示：当前兑换余额积分手续费%s"
		tipsStr = fmt.Sprintf(tipsStr, exchangeAccountBalanceFeeValue+"%")
	} else {
		tipsStr = fmt.Sprintf(tipsStr, exchangeAccountBalanceFeeValue+"%", vipEquitySetting[len(vipEquitySetting)-1].ExchangeAccountBalanceFee+"%")
	}
	e.OutSuc(c, map[string]interface{}{
		"total_green_energy":               totalGreenEnergy,
		"total_green_energy_price":         totalGreenEnergyPrice,
		"total_active_points":              totalActivePoints,
		"total_active_points_amount":       totalActivePointsAmount,
		"total_amount":                     user.Profile.FinValid,
		"total_amount_exchange_green_nums": totalAmountExchangeGreenNums,
		"green_energy_now_price":           oneCirclesGreenEnergyBasicSetting.NowPrice,
		"initial_price":                    oneCirclesGreenEnergyBasicSetting.InitialPrice,
		"is_rises":                         isRises,
		"rises":                            rises,
		"release_data": map[string]interface{}{
			"total_issuance_amount":        oneCirclesGreenEnergyBasicSetting.TotalIssuanceAmount,
			"initial_price":                oneCirclesGreenEnergyBasicSetting.InitialPrice,
			"total_technology_team":        oneCirclesGreenEnergyBasicSetting.TotalTechnologyTeam,
			"total_technology_team_ratio":  "5%",
			"total_operate_team":           oneCirclesGreenEnergyBasicSetting.TotalOperateTeam,
			"total_operate_team_ratio":     "5%",
			"total_active_giveaways":       oneCirclesGreenEnergyBasicSetting.TotalActiveGiveaways,
			"total_active_giveaways_ratio": "5%",
			"ecological_application":       oneCirclesGreenEnergyBasicSetting.EcologicalApplication,
			"ecological_application_ratio": "5%",
			"original_quantity_nums":       oneCirclesGreenEnergyBasicSetting.OriginalQuantityNums,
			"original_quantity_nums_ratio": "5%",
		},
		"trends_data": map[string]interface{}{
			"total_to_be_released ":      results1[0]["total"],
			"destruction_quantity_nums":  oneCirclesGreenEnergyBasicSetting.DestructionQuantityNums,
			"total_gifted":               results3[0]["total"],
			"total_held_by_users":        results2[0]["total"],
			"public_welfare_and_charity": oneCirclesGreenEnergyBasicSetting.PublicWelfareAndCharity,
		},
		"tips": tipsStr,
	}, nil)
	return
}

func HomePage(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	now := time.Now()

	//1、查找 `one_circles_green_energy_basic_setting` 基础设置 && 查找 `one_circles_public_platoon_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	oneCirclesPublicPlatoonBasicSetting, err := db.OneCirclesPublicPlatoonBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//2、计算今日涨幅
	err, rises, isRises := one_circles.CalcTodayGreenEnergyPriceRises(engine, oneCirclesGreenEnergyBasicSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//3、获取当前用户 绿色能量(可用+结算+今日签到预估绿色能量)
	var isSign bool
	var signCountdown string
	var signGreenEnergy string
	var signRewardGreenEnergy string
	var totalGreenEnergy float64
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var oneRoundDuration = zhios_order_relate_utils.StrToInt(teamRewardSetting.OneRoundDuration)
	startTime := now.Add(-time.Hour * time.Duration(oneRoundDuration)).Format("2006-01-02 15:04:05")
	var oneCirclesGreenEnergySignIn model.OneCirclesGreenEnergySignIn
	get, err := engine.Where("start_time >= ?", startTime).And("uid =?", user.Info.Uid).And("is_completed =?", 0).Get(&oneCirclesGreenEnergySignIn)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if !get {
		signGreenEnergy = "0.00"
		signRewardGreenEnergy = "0.00"
	} else {
		var signInRewards []*md.SignInRewardStruct
		err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.SignInReward), &signInRewards)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
		err, signRewardGreenEnergy = one_circles.CalcNowSignInGreenEnergy(engine, oneCirclesGreenEnergyBasicSetting)
		if err != nil {
			e.OutErr(c, e.ERR, err.Error())
			return
		}
		signRewardGreenEnergyValue, err1 := decimal.NewFromString(signRewardGreenEnergy)
		if err != nil {
			e.OutErr(c, e.ERR, err1.Error())
			return
		}
		diffSeconds := decimal.NewFromInt(int64(now.Sub(zhios_order_relate_utils.String2Time(oneCirclesGreenEnergySignIn.StartTime)).Seconds()))
		signGreenEnergy = signRewardGreenEnergyValue.Mul(diffSeconds).String()
		isSign = true
		signCountdown = oneCirclesGreenEnergySignIn.EndTime
	}
	personGreenEnergy, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.PersonGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	teamGreenEnergy, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesGreenEnergyBasicSetting.TeamGreenEnergyCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	signGreenEnergyValue, _ := decimal.NewFromString(signGreenEnergy)
	personGreenEnergyValue, _ := decimal.NewFromString(personGreenEnergy.Amount)
	teamGreenEnergyValue, _ := decimal.NewFromString(teamGreenEnergy.Amount)

	totalGreenEnergy, _ = signGreenEnergyValue.Add(personGreenEnergyValue).Add(teamGreenEnergyValue).Float64()

	//4、活跃积分(个人+团队)
	var totalActivePoints float64
	personActivePoints, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesPublicPlatoonBasicSetting.PersonActivePointsCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	teamActivePoints, err2 := commDb.GetUserVirtualWallet(engine, user.Info.Uid, int(utils.AnyToInt64(oneCirclesPublicPlatoonBasicSetting.TeamActivePointsCoinId)))
	if err2 != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	totalActivePoints = utils.StrToFloat64(personActivePoints.Amount) + utils.StrToFloat64(teamActivePoints.Amount)

	//5、计算当前基础速率、团队速率
	nowBasalRate := utils.StrToFloat64(signRewardGreenEnergy) * 60 * 60 //每小时基础速率
	userRelates, err := db2.DbsUserRelateByParentUid(engine, user.Info.Uid, 0)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var userRelatesUids []int
	var userRelatesMap = map[int]model.UserRelate{}
	if userRelates != nil {
		for _, userRelate := range *userRelates {
			userRelatesUids = append(userRelatesUids, userRelate.Uid)
			userRelatesMap[userRelate.Uid] = userRelate
		}
	}

	var oneCirclesGreenEnergySignIns []*model.OneCirclesGreenEnergySignIn
	err = engine.Where("start_time >= ?", startTime).In("uid", userRelatesUids).And("is_completed =?", 0).Find(&oneCirclesGreenEnergySignIns)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	var nowTeamRate float64 //每小时基础速率
	nowBasalRateValue := decimal.NewFromFloat(nowBasalRate)
	for _, vv := range oneCirclesGreenEnergySignIns {
		rewardDecrementValue := utils.StrToFloat64(teamRewardSetting.RewardDecrementValue) / 100
		tmpRewardBase := decimal.NewFromFloat(math.Pow(rewardDecrementValue, float64(userRelatesMap[vv.Uid].Level)))
		tmpReward := nowBasalRateValue.Mul(tmpRewardBase)
		rewardEndValue, _ := decimal.NewFromString(teamRewardSetting.RewardEndValue)
		if tmpReward.GreaterThanOrEqual(rewardEndValue) {
			tmpRewardValue, _ := tmpReward.Float64()
			nowTeamRate += tmpRewardValue
		}
	}

	decimalRate := decimal.NewFromInt(100) //百分比
	risesValue, _ := decimal.NewFromFloat(rises).Mul(decimalRate).Float64()
	e.OutSuc(c, map[string]interface{}{
		"is_sign":                  isSign,
		"sign_end_date":            signCountdown,
		"total_green_energy":       totalGreenEnergy,
		"sign_reward_green_energy": utils.StrToFloat64(signRewardGreenEnergy),
		"total_active_points":      totalActivePoints,
		"green_energy_now_price":   oneCirclesGreenEnergyBasicSetting.NowPrice,
		"initial_price":            oneCirclesGreenEnergyBasicSetting.InitialPrice,
		"is_rises":                 isRises,
		"rises":                    risesValue,
		"now_basal_rate":           nowBasalRate,
		"now_team_rate":            nowTeamRate,
	}, nil)
	return
}

func HomePageRealTime(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	results, err := commDb.QueryNativeString(engine, "SELECT COUNT(*)AS total FROM user")
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	userCount := results[0]["total"]
	e.OutSuc(c, map[string]interface{}{
		"user_count": userCount,
	}, nil)
	return
}

func HomePageStartSignIn(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	now := time.Now()

	//1、查找 `one_circles_green_energy_basic_setting` 基础设置
	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//2、新增 `one_circles_green_energy_sign_in` 记录
	var oneRoundDuration = zhios_order_relate_utils.StrToInt(teamRewardSetting.OneRoundDuration)
	endTime := now.Add(time.Hour * time.Duration(oneRoundDuration)).Format("2006-01-02 15:04:05")
	_, err = db2.OneCirclesGreenEnergySignInInsert(engine, &model.OneCirclesGreenEnergySignIn{
		Uid:         user.Info.Uid,
		StartTime:   now.Format("2006-01-02 15:04:05"),
		EndTime:     endTime,
		IsCompleted: 0,
	})
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	//3、新增 `one_circles_user_activity` 记录
	var m model.OneCirclesUserActivity
	has, err := engine.Where("uid =? and date =?", user.Info.Uid, now.Format("2006-01-02")).Get(&m)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}
	if !has {
		affected, err1 := db2.OneCirclesUserActivityInsert(engine, &model.OneCirclesUserActivity{
			Uid:  user.Info.Uid,
			Date: now.Format("2006-01-02"),
		})
		if err1 != nil {
			e.OutErr(c, e.ERR_DB_ORM, err1.Error())
			return
		}
		if affected <= 0 {
			e.OutErr(c, e.ERR_DB_ORM, "插入活跃记录失败")
			return
		}
	}

	e.OutSuc(c, "success", nil)
	return
}

func HomePageWatchAdList(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)

	//1、查找 `OneCirclesPublicPlatoonBasicSetting` 基础设置
	oneCirclesPublicPlatoonBasicSetting, err := db.OneCirclesPublicPlatoonBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	//2、计算当前还能看几个广告
	oneCirclesUserWatchRecords, err1 := db2.OneCirclesUserWatchRecordsGetOneByParams(engine, map[string]interface{}{
		"key":   "uid",
		"value": user.Info.Uid,
	})
	if err1 != nil {
		e.OutErr(c, e.ERR, err1.Error())
		return
	}
	var videoRewardSystem *md.VideoRewardSystemStruct
	err = json.Unmarshal([]byte(oneCirclesPublicPlatoonBasicSetting.VideoRewardSystem), &videoRewardSystem)
	if err != nil {
		return
	}
	masterId := c.GetString("mid")
	redisKey := fmt.Sprintf(md.UserNextWatchAdDate, masterId, user.Info.Uid)
	var residueWatchAdNum int
	if oneCirclesUserWatchRecords == nil {
		residueWatchAdNum = utils.StrToInt(videoRewardSystem.RewardTotalNum)
	} else {
		now := time.Now()
		nextWatchAdDate := oneCirclesUserWatchRecords.NextWatchAdDate
		residueWatchAdNum = oneCirclesUserWatchRecords.ResidueWatchAdNum
		if oneCirclesUserWatchRecords.NextWatchAdDate.Before(now) { //TODO::下一轮时间已在当前时间之前
			nextWatchAdDate = now.Add(time.Hour * time.Duration(zhios_order_relate_utils.StrToInt(videoRewardSystem.EachRoundHour)))
			residueWatchAdNum = zhios_order_relate_utils.StrToInt(videoRewardSystem.RewardTotalNum)
			oneCirclesUserWatchRecords.ResidueWatchAdNum = residueWatchAdNum
			oneCirclesUserWatchRecords.NextWatchAdDate = nextWatchAdDate
			_, err2 := db2.OneCirclesUserWatchRecordsUpdate(engine, oneCirclesUserWatchRecords.Id, oneCirclesUserWatchRecords, "residue_watch_ad_num", "next_watch_ad_date")
			if err2 != nil {
				e.OutErr(c, e.ERR_DB_ORM, err2.Error())
				return
			}
			cache.SetEx(redisKey, "", 60*60*12) //TODO::默认缓存1小时
		}
	}
	nextWatchAdDate, _ := cache.GetString(redisKey)

	oneCirclesGreenEnergyBasicSetting, err := db2.OneCirclesGreenEnergyBasicSettingGetOneByParams(engine, map[string]interface{}{
		"key":   "is_open",
		"value": 1,
	})
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}
	var teamRewardSetting *md.TeamRewardSettingStruct
	err = json.Unmarshal([]byte(oneCirclesGreenEnergyBasicSetting.TeamReward), &teamRewardSetting)
	if err != nil {
		return
	}
	e.OutSuc(c, map[string]interface{}{
		"residue_watch_ad_num":          residueWatchAdNum,
		"watch_ad_reward_active_points": videoRewardSystem.RewardValue,
		"next_watch_ad_date":            nextWatchAdDate,
		"each_round_hour":               teamRewardSetting.OneRoundDuration,
	}, nil)
	return
}

func HomePageWatchOverAd(c *gin.Context) {
	engine := commSvc.MasterDb(c)
	user := commSvc.GetUser(c)
	masterId := c.GetString("mid")

	err := one_circles.SettlementPublicGiveActivityCoin(engine, masterId, user.Info.Uid)
	if err != nil {
		e.OutErr(c, e.ERR, err.Error())
		return
	}

	e.OutSuc(c, "success", nil)
	return
}