ktogame/blockchain/contract.go

package blockchain

import (
	"errors"
	"ktogame/controller"
	"ktogame/dbUtil"
	"ktogame/models"
	"ktogame/util"
	"strconv"

	"github.com/astaxie/beego/logs"

	"github.com/go-xorm/xorm"
)

func participate(user, inviter, hash string, amount float64) error {
	logs.Info("into participate=====")
	sesion := dbUtil.Engine.NewSession()
	var Error error
	defer func() {
		if Error != nil {
			sesion.Rollback()
		} else {
			sesion.Commit()
			logs.Info("participate end=====")
		}
	}()
	var ui, dui models.UserInfo
	ok, Error := sesion.ID(inviter).Get(&dui)
	if Error != nil {
		logs.Info(Error)
		return Error
	}
	if !ok {
		dui.Id = -1
		dui.Direct = ""
		dui.Superiors = "-1"
		ui.Direct = ""
	} else {
		ui.Direct = inviter
	}
	logs.Info("inviter info:", dui.Id, dui.Direct, dui.Indirect, dui.Superiors)
	//insert new user info
	ui.Addr = user
	ui.Indirect = dui.Direct
	ui.Superiors = dui.Superiors + "," + strconv.FormatInt(dui.Id, 10)
	ui.ParticipateAmount = amount
	ui.State = 1
	ui.CreateTime = util.NowTimeString()
	ui.Hash = hash
	ui.BackNum = 0
	logs.Info("user info:", ui.Direct, ui.Indirect, ui.Superiors)
	okk, Error := sesion.ID(ui.Addr).Get(&dui)
	if Error != nil {
		logs.Info(Error)
		return Error
	}
	if okk {
		Error = errors.New("user already participated")
		logs.Info("%v already participated!", ui.Addr)
		return nil
	}
	_, Error = sesion.Insert(&ui)
	if Error != nil {
		logs.Info(Error)
		return Error
	}

	{
		var newUser models.UserInfo
		ok, Error := sesion.ID(ui.Addr).Get(&newUser)
		if Error != nil {
			logs.Info(Error)
			return Error
		}
		if !ok {
			Error = errors.New("new user not exist")
			return Error
		}
		var backUsers string
		backUsers = strconv.FormatInt(newUser.Id, 10)
		for id := 11; id <= 25; id++ {
			backUsers = backUsers + "," + strconv.FormatInt(newUser.Id+int64(id), 10)
		}
		newUser.BackUsers = backUsers
		_, Error = sesion.ID(newUser.Addr).Cols("back_users").Update(&newUser)
		if Error != nil {
			logs.Info(Error)
			return Error
		}
	}

	//insert new user Performance
	var uper models.Performance
	uper.Addr = user
	_, Error = sesion.Insert(&uper)
	if Error != nil {
		return Error
	}

	//update rewards pool
	Error = controller.UpdateRewardsPool(sesion, amount)
	if Error != nil {
		logs.Info(Error)
		return Error
	}

	///update Recommendation Rewards
	///update direct recommend rewards(10%)
	rewards := amount * 10 / 100
	if ui.Direct != "" {
		Error = controller.UpdateAvailableRewards(sesion, rewards, ui.Direct, true, true)
		if Error != nil {
			logs.Info(Error)
			return Error
		}
	}
	///update indirect recommend rewards(10%)
	if ui.Indirect != "" {
		Error = controller.UpdateAvailableRewards(sesion, rewards, ui.Indirect, true, false)
		if Error != nil {
			logs.Info(Error)
			return Error
		}
	}

	//update all supers performance (15%)
	Error = controller.UpdateSuperiorsPerformance(sesion, ui.Superiors, amount)
	if Error != nil {
		logs.Info(Error)
		return Error
	}
	//update Community Gift(50%)
	Error = controller.UpdateCommunityGift(sesion, amount, inviter)
	if Error != nil {
		logs.Info(Error)
		return Error
	}

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

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

func checkClaim(engine *xorm.Engine, addr, hash string, height int64, amount float64, sign string) error {
	var tx models.ClaimedTxs
	ok, err := engine.Id(hash).Get(&tx)
	if err != nil {
		logs.Error(err)
		return err
	}
	if !ok {
		logs.Info("set new claim record,addr:%v,hash:%v", addr, hash)
		itx := models.ClaimedTxs{
			Addr:        addr,
			BlockHeight: height,
			Hash:        hash,
			Signature:   sign,
			Amount:      amount,
			State:       1,
			Droped:      0,
			CreateTime:  util.NowTimeString(),
		}
		_, err := engine.Insert(&itx)
		if err != nil {
			return err
		}
		return nil
	}
	logs.Info("update record========:", addr, hash)
	tx.State = 1
	tx.BlockHeight = height
	_, err = engine.ID(hash).Cols("block_height,state").Update(&tx)
	if err != nil {
		return err
	}
	return nil
}