ktogame/controller/controller.go

package controller

import (
	"errors"
	"fmt"
	"ktogame/models"
	"ktogame/util"
	"strings"
	"time"

	"github.com/go-xorm/xorm"

	"github.com/astaxie/beego/logs"

	"github.com/shopspring/decimal"
)

func (uc *UserController) Reinput() {
	sesion := uc.engine.NewSession()
	var Error error
	defer func() {
		if Error != nil {
			sesion.Rollback()
			ErrResponse(uc.Controller, Error)
		} else {
			sesion.Commit()
		}
	}()
	user := uc.GetString("addr")
	var ui models.UserInfo
	ok, Error := uc.engine.Id(user).Get(&ui)
	if Error != nil {
		return
	}
	if !ok {
		Error = errors.New("user not exist")
		return
	}

	///update availableReinput by left in db
	///update totalReinput
	if ui.AvailableReinput < ModBase {
		Error = errors.New("no available reinput balance")
		return
	}
	num := uint64(ui.AvailableReinput) / uint64(ModBase)
	reinputValue := float64(num * ModBase)

	//test
	//reinputValue := ui.AvailableReinput
	//test end
	logs.Info("check Reinput user:%v,num:%v available:%v,reinputValue=======%v", user, ui.AvailableReinput, reinputValue)

	///update Recommendation Rewards
	///update direct recommend rewards
	rewards := reinputValue * 10 / 100
	if ui.Direct != "" {
		Error = UpdateAvailableRewards(sesion, rewards, ui.Direct, false, false)
		if Error != nil {
			return
		}
	}
	///update indirect recommend rewards
	if ui.Indirect != "" {
		Error = UpdateAvailableRewards(sesion, rewards, ui.Indirect, false, false)
		if Error != nil {
			return
		}
	}
	Error = UpdateRewardsPool(sesion, reinputValue)
	if Error != nil {
		return
	}
	//15%
	Error = UpdateSuperiorsPerformance(sesion, ui.Superiors, reinputValue)
	if Error != nil {
		return
	}
	//50%
	Error = frontAndBackRewards(sesion, ui.Addr, reinputValue)
	if Error != nil {
		return
	}

	//Update Community Nodes(5%)
	Error = UpdateCommunityNodes(sesion, reinputValue)
	if Error != nil {
		logs.Info(Error)
		return
	}

	//update Market(10%) tuan dui fu dao
	Error = UpdateMarket(sesion, reinputValue)
	if Error != nil {
		logs.Info(Error)
		return
	}

	ui.AvailableReinput -= reinputValue
	ui.TotalReinputed += reinputValue

	if ui.TotalReinputed >= CommunityLimit {
		ui.State = CommunityUsers
	}
	_, Error = uc.engine.ID(user).Cols("available_reinput,total_reinputed,state").Update(&ui)
	if Error != nil {
		return
	}
	TxObjectResponse(uc.Controller, "ok")
	return
}
func (uc *UserController) GetClaimSignature() {
	addr := uc.GetString("addr")
	s := uc.GetString("sign")
	user := util.GetPri(s, addr[len(addr)-16:])
	if strings.ToLower(user) != strings.ToLower(addr) {
		ErrResponse(uc.Controller, "无效地址")
		return
	}
	var ua models.UserInfo
	uc.engine.Id(user).Get(&ua)
	if ua.AvailableClaim == 0 {
		ErrResponse(uc.Controller, "暂无收益领取")
		return
	}

	i_time := time.Now().Unix() + 3600*2

	pow := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(18)))
	amount := decimal.NewFromFloat(ua.AvailableClaim).Mul(pow).BigInt().String()

	out1 := util.Sign(amount, strings.ToLower(user[2:]), fmt.Sprint(i_time))
	sign := out1 + "-" + amount + "-" + fmt.Sprint(i_time)
	code := util.EnPriCode(sign, addr[len(addr)-16:])
	TxObjectResponse(uc.Controller, code)
	return
}
func (uc *UserController) SetClaimHash() {
	addr := uc.GetString("addr")
	hash := uc.GetString("hash")
	sign := uc.GetString("sign")

	sesion := uc.engine.NewSession()
	var Error error
	defer func() {
		if Error != nil {
			sesion.Rollback()
			ErrResponse(uc.Controller, Error)
			return
		}
		sesion.Commit()
	}()

	var ua models.UserInfo
	ok, Error := uc.engine.Id(addr).Get(&ua)
	if Error != nil {
		return
	}
	if !ok {
		Error = errors.New("user not exist")
		return
	}
	if ua.AvailableClaim == 0 {
		Error = errors.New("user no available rewards to claim")
		return
	}

	amount := ua.AvailableClaim
	ua.TotalClaimed += amount
	ua.AvailableClaim = 0
	_, Error = sesion.ID(addr).Cols("available_claim,total_claimed").Update(&ua)
	if Error != nil {
		return
	}
	logs.Info("check SetClaimHash---------:", addr, hash, ua.AvailableClaim, ua.TotalClaimed, amount)
	claimTx := models.ClaimedTxs{Addr: addr, Amount: amount, Hash: hash,
		Signature: sign, State: 0, Droped: 0, CreateTime: util.NowTimeString()}
	_, Error = sesion.Insert(&claimTx)
	if Error != nil {
		return
	}

	TxObjectResponse(uc.Controller, "ok")
	return
}
func (uc *UserController) GetUserInfo() {
	user := uc.GetString("addr")
	var us models.UserInfo
	uc.engine.Id(user).Get(&us)

	TxObjectResponse(uc.Controller, us)
	return
}
func (uc *UserController) GetTeamList() {
	user := uc.GetString("addr")
	s, err := uc.GetInt("size")
	if err != nil {
		TxObjectResponse(uc.Controller, err)
		return
	}
	l, err := uc.GetInt("limit")
	if err != nil {
		TxObjectResponse(uc.Controller, err)
		return
	}
	var us models.UserInfo
	var teamList []models.UserInfo

	ok, err := uc.engine.Id(user).Get(&us)
	if err != nil {
		TxObjectResponse(uc.Controller, err)
		return
	}
	if !ok {
		TxObjectResponse(uc.Controller, us)
		return
	}

	c, err := uc.engine.Where("superiors like ?", "%,"+fmt.Sprint(us.Id)+"%").FindAndCount(&teamList)
	if err != nil {
		TxObjectResponse(uc.Controller, err)
		return
	}
	var addrList []string
	for _, u := range teamList {
		addrList = append(addrList, u.Addr)
	}
	res := models.Page{Limit: l, Size: s, Total: c, DataList: addrList}
	TxObjectResponse(uc.Controller, res)
	return
}
func (uc *UserController) GetPerformance() {
	user := uc.GetString("addr")
	var per models.Performance
	uc.engine.Id(user).Get(&per)
	TxObjectResponse(uc.Controller, per)
	return
}
func (uc *UserController) TotalUsers() {
	var us models.UserInfo
	c, err := uc.engine.Count(&us)
	if err != nil {
		ErrResponse(uc.Controller, err)
		return
	}
	us.Id = c - 1
	TxObjectResponse(uc.Controller, us)
	return
}

func frontAndBackRewards(sesion *xorm.Session, addr string, reinputValue float64) error {
	var user models.UserInfo
	ok, err := sesion.ID(addr).Get(&user)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}
	//front 25%
	var fronts []models.UserInfo
	if user.Id > 25 {
		err := sesion.Where("id >= ? and id < ?", user.Id-25, user.Id).Find(&fronts)
		if err != nil {
			return err
		}
	} else {
		err := sesion.Where("id >= ? and id < ?", 1, user.Id).Find(&fronts)
		if err != nil {
			return err
		}
	}
	if len(fronts) > 0 {
		backrewards := reinputValue / 100
		for _, u := range fronts {
			err := UpdateAvailableRewards(sesion, backrewards, u.Addr, false, false)
			if err != nil {
				return err
			}
		}
	}
	//back 25%
	var currUser models.UserInfo
	ok, err = sesion.Desc("id").Get(&currUser)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}
	var backs []models.UserInfo
	if user.Id+25 <= currUser.Id {
		err := sesion.Where("id > ? and id <= ?", user.Id, currUser.Id+25).Find(&backs)
		if err != nil {
			return err
		}
	} else {
		err := sesion.Where("id > ? and id <= ?", user.Id, currUser.Id).Find(&backs)
		if err != nil {
			return err
		}
	}
	if len(backs) > 0 {
		backrewards := reinputValue / 100
		for _, b := range backs {
			err := UpdateAvailableRewards(sesion, backrewards, b.Addr, false, false)
			if err != nil {
				return err
			}
		}
	}
	return nil
}