blockchain/contract.go

@@ -1,7 +1,9 @@
 package blockchain
 
 import (
+	"errors"
 	"ktogame/controller"
+	"ktogame/dbUtil"
 	"ktogame/models"
 	"ktogame/util"
 	"strconv"
@@ -11,12 +13,23 @@ import (
 	"github.com/go-xorm/xorm"
 )
 
-func participate(engine *xorm.Engine, user, inviter, hash string, amount float64) error {
+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, err := engine.Id(inviter).Get(&dui)
-	if err != nil {
-		logs.Info(err)
-		return err
+	ok, Error := sesion.ID(inviter).Get(&dui)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 	if !ok {
 		dui.Id = -1
@@ -35,83 +48,108 @@ func participate(engine *xorm.Engine, user, inviter, hash string, amount float64
 	ui.State = 1
 	ui.CreateTime = util.NowTimeString()
 	ui.Hash = hash
+	ui.BackNum = 0
 	logs.Info("user info:", ui.Direct, ui.Indirect, ui.Superiors)
-	okk, err := engine.Id(ui.Addr).Get(&dui)
-	if err != nil {
-		logs.Info(err)
-		return err
+	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
 	}
-	_, err = engine.Insert(&ui)
-	if err != nil {
-		logs.Info(err)
-		return err
+	_, 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
-	_, err = engine.Insert(&uper)
-	if err != nil {
-		return err
+	_, Error = sesion.Insert(&uper)
+	if Error != nil {
+		return Error
 	}
 
 	//update rewards pool
-	err = controller.UpdateRewardsPool(engine, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	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 != "" {
-		err := controller.UpdateAvailableRewards(rewards, ui.Direct, true, true)
-		if err != nil {
-			logs.Info(err)
-			return err
+		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 != "" {
-		err := controller.UpdateAvailableRewards(rewards, ui.Indirect, true, false)
-		if err != nil {
-			logs.Info(err)
-			return err
+		Error = controller.UpdateAvailableRewards(sesion, rewards, ui.Indirect, true, false)
+		if Error != nil {
+			logs.Info(Error)
+			return Error
 		}
 	}
 
 	//update all supers performance (15%)
-	err = controller.UpdateSuperiorsPerformance(engine, ui.Superiors, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateSuperiorsPerformance(sesion, ui.Superiors, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 	//update Community Gift(50%)
-	err = controller.UpdateCommunityGift(engine, amount, inviter)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateCommunityGift(sesion, amount, inviter)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 
 	//Update Community Nodes(5%)
-	err = controller.UpdateCommunityNodes(engine, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	Error = controller.UpdateCommunityNodes(sesion, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
 
-	//update Market(10%)
-	err = controller.UpdateMarket(engine, amount)
-	if err != nil {
-		logs.Info(err)
-		return err
+	//update Market(10%) tuan dui fu dao
+	Error = controller.UpdateMarket(sesion, amount)
+	if Error != nil {
+		logs.Info(Error)
+		return Error
 	}
-	logs.Info("participate end")
 	return nil
 }
 

blockchain/scan.go

@@ -61,6 +61,7 @@ func scanBlock() {
 		return
 	}
 	currentBlock = uint64(bi.BlockNumber) + 1
+	logs.Info("currentBlock===", currentBlock)
 	for {
 		time.Sleep(time.Second * 3)
 
@@ -123,7 +124,7 @@ func scanBlock() {
 						}
 						logs.Info("participate data:", ev.Participant.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()/controller.Decimals))
 						//handle user participate
-						err = participate(dbUtil.Engine, ev.Participant.String(), ev.Inviter.String(), v.HashToString(), float64(ev.Amount.Uint64()/controller.Decimals))
+						err = participate(ev.Participant.String(), ev.Inviter.String(), v.HashToString(), float64(PARTICIPATEVALUE))
 						if err != nil {
 							logs.Error(err)
 							ERR = err

blockchain/types.go

@@ -7,13 +7,16 @@ import (
 )
 
 const (
-	TOPIC_PARTICIPATE           = "0x8ed860f76da405897619eab937f09dcb4d0d9b56cf68a3d489130a2489cf151f"
-	TOPIC_CLAIM                 = "0x4804104ccbc53649f5b8b29ecf858272a4a6ed6b9949f0d30237c7a147e84671"
-	COLLECT_PARTICIPATE         = "Participate"
-	COLLECT_CLAIMREWARDS        = "Claim"
-	COLLECTCONTRACT             = "0xC6Ff5462e5409d11AF6B080ADC3dc0a17E94b0A6" //test
-	CONFIRMINTERVAL             = 600
-	TimeLayout           string = "2006-01-02 15:04:05"
+	TOPIC_PARTICIPATE    = "0x8ed860f76da405897619eab937f09dcb4d0d9b56cf68a3d489130a2489cf151f"
+	TOPIC_CLAIM          = "0x4804104ccbc53649f5b8b29ecf858272a4a6ed6b9949f0d30237c7a147e84671"
+	COLLECT_PARTICIPATE  = "Participate"
+	COLLECT_CLAIMREWARDS = "Claim"
+	//COLLECTCONTRACT             = "0xC6Ff5462e5409d11AF6B080ADC3dc0a17E94b0A6" //test
+	COLLECTCONTRACT        = "0xB90c10FD18B57822f47812D538B3D7130E762f06"
+	CONFIRMINTERVAL        = 600
+	TimeLayout      string = "2006-01-02 15:04:05"
+
+	PARTICIPATEVALUE = 1000
 )
 
 type EventParticipate struct {

controller/calculate.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"fmt"
-	"ktogame/dbUtil"
 	"ktogame/models"
 	"strings"
 
@@ -11,7 +10,7 @@ import (
 	"github.com/go-xorm/xorm"
 )
 
-func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount float64) error {
+func UpdateSuperiorsPerformance(engine *xorm.Session, superiorsStr string, amount float64) error {
 	logs.Info("into UpdateSuperiorsPerformance:", superiorsStr, amount)
 	ids := strings.Split(superiorsStr, ",")
 	if len(ids) <= 0 {
@@ -36,14 +35,14 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 	}
 
 	var rp models.RewardsPool
-	_, err := engine.Id(1).Get(&rp)
+	_, err := engine.ID(1).Get(&rp)
 	if err != nil {
 		return err
 	}
 
 	for _, super := range supers {
 		var per models.Performance
-		ok, err := engine.Id(super.Addr).Get(&per)
+		ok, err := engine.ID(super.Addr).Get(&per)
 		if err != nil {
 			fmt.Println(err)
 			continue
@@ -56,7 +55,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 		per.TotalPerformance += amount
 		if per.TotalPerformance >= float64(CommunityMarket) {
 			var super models.Performance
-			ok, err := engine.Id(per.Addr).Get(&super)
+			ok, err := engine.ID(per.Addr).Get(&super)
 			if err != nil {
 				fmt.Println(err)
 				continue
@@ -94,7 +93,7 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 					//update available
 					logs.Debug("Performance check=====2,", per.Addr, level, amount, ratio, rewards)
 
-					err := UpdateAvailableRewards(rewards, super.Addr, false, false)
+					err := UpdateAvailableRewards(engine, rewards, super.Addr, false, false)
 					if err != nil {
 						return err
 					}
@@ -113,14 +112,14 @@ func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount
 	if err != nil {
 		return err
 	}
-	logs.Info("into UpdateSuperiorsPerformance end:", rp)
+	logs.Info("UpdateSuperiorsPerformance end:", rp)
 	return nil
 }
 
-func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
+func UpdateRewardsPool(engine *xorm.Session, amount float64) error {
 	logs.Info("into UpdateRewardsPool:", amount)
 	var rp models.RewardsPool
-	_, err := dbUtil.Engine.Id(1).Get(&rp)
+	_, err := engine.ID(1).Get(&rp)
 	if err != nil {
 		return err
 	}
@@ -136,12 +135,15 @@ func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
 	return nil
 }
 
-func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool) error {
+func UpdateAvailableRewards(engine *xorm.Session, rewards float64, uaddr string, join, isdirect bool) error {
+	if rewards <= 0 {
+		return nil
+	}
 	logs.Info("into UpdateAvailableRewards:", rewards, uaddr, join, isdirect)
 	a_rewards := rewards * 60 / 100
 	a_reinput := rewards * 40 / 100
 	var user models.UserInfo
-	ok, err := dbUtil.Engine.Id(uaddr).Get(&user)
+	ok, err := engine.ID(uaddr).Get(&user)
 	if err != nil {
 		return err
 	}
@@ -156,7 +158,7 @@ func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool)
 			user.DirectNumber += 1
 			user.DirectRewards += rewards
 			logs.Info("check direct info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
-			_, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput,direct_number,direct_rewards").Update(&user)
+			_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput,direct_number,direct_rewards").Update(&user)
 			if err != nil {
 				return err
 			}
@@ -164,26 +166,26 @@ func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool)
 			user.IndirectNumber += 1
 			user.IndirectRewards += rewards
 			logs.Info("check indirect info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
-			_, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput,indirect_number,indirect_rewards").Update(&user)
+			_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput,indirect_number,indirect_rewards").Update(&user)
 			if err != nil {
 				return err
 			}
 		}
 	} else {
 		logs.Info("check else info=====:", user.AvailableClaim, user.AvailableReinput)
-		_, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput").Update(&user)
+		_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput").Update(&user)
 		if err != nil {
 			return err
 		}
 	}
-	logs.Info("into UpdateAvailableRewards end:", user)
+	logs.Info("UpdateAvailableRewards end:", user)
 	return nil
 }
 
-func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) error {
+func UpdateCommunityGift(engine *xorm.Session, amount float64, uaddr string) error {
 	logs.Info("into UpdateCommunityGift:", amount, uaddr)
-	var user, tmpUser models.UserInfo
-	ok, err := engine.Id(uaddr).Get(&user)
+	var user models.UserInfo
+	ok, err := engine.ID(uaddr).Get(&user)
 	if err != nil {
 		return err
 	}
@@ -191,51 +193,183 @@ func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) erro
 		return nil
 	}
 
-	ok, err = engine.Desc("id").Get(&tmpUser)
+	//front 10
+	var leftNum int64
+	if user.Id > 10 {
+		leftNum = 10
+	} else {
+		leftNum = user.Id - 1
+	}
+	rewards := amount * (float64(leftNum) / 100)
+
+	err = UpdateGift(engine, user.Addr, rewards)
 	if err != nil {
 		return err
 	}
-	if !ok {
-		logs.Info("%v not exist!", uaddr)
-		return nil
-	}
 
-	var leftNum, rightNum int64
-	if user.Id >= 26 {
-		leftNum = 25
+	//back 10
+	var fronts []models.UserInfo
+	if user.Id > 10 {
+		err := engine.Where("id >= ? and id < ?", user.Id-10, user.Id).Find(&fronts)
+		if err != nil {
+			return err
+		}
 	} else {
-		leftNum = user.Id - 1
+		err := engine.Where("id >= ? and id < ?", 1, user.Id).Find(&fronts)
+		if err != nil {
+			return err
+		}
 	}
-	if tmpUser.Id-user.Id >= 25 {
-		rightNum = 25
-	} else {
-		rightNum = tmpUser.Id - user.Id
+	if len(fronts) > 0 {
+		backrewards := amount / 100
+		for _, u := range fronts {
+			err = UpdateGift(engine, u.Addr, backrewards)
+			if err != nil {
+				return err
+			}
+		}
 	}
 
-	rewards := amount * (float64(leftNum+rightNum) / 100)
-	err = UpdateAvailableRewards(rewards, user.Addr, false, false)
-	if err != nil {
-		return err
+	//inviter front 10-25%
+	if user.Direct != "" {
+		var inviter models.UserInfo
+		ok, err := engine.ID(user.Direct).Get(&inviter)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return nil
+		}
+		var frontNum int64
+		if inviter.DirectNumber == 1 {
+			//front 10 - 15
+			if inviter.Id <= 10 {
+				frontNum = 0
+			}
+			if inviter.Id > 10 && inviter.Id <= 15 {
+				frontNum = inviter.Id - 10
+			}
+			if inviter.Id > 15 {
+				frontNum = 5
+			}
+		} else if inviter.DirectNumber == 2 {
+			//front 16 - 20
+			if inviter.Id <= 15 {
+				frontNum = 0
+			}
+			if inviter.Id > 15 && inviter.Id <= 20 {
+				frontNum = inviter.Id - 15
+			}
+			if inviter.Id > 20 {
+				frontNum = 5
+			}
+		} else if inviter.DirectNumber == 3 {
+			//front 21 - 25
+			if inviter.Id <= 20 {
+				frontNum = 0
+			}
+			if inviter.Id > 20 && inviter.Id <= 25 {
+				frontNum = inviter.Id - 20
+			}
+			if inviter.Id > 25 {
+				frontNum = 5
+			}
+		} else {
+			frontNum = 0
+		}
+
+		frontrewards := amount * (float64(frontNum / 100))
+		err = UpdateGift(engine, inviter.Addr, frontrewards)
+		if err != nil {
+			return err
+		}
 	}
 
-	var per models.Performance
-	ok, err = engine.Id(uaddr).Get(&per)
+	//back 10-25%,DirectNumber 1,2,3===============
+	var frontUsers []models.UserInfo
+	err = engine.Where("back_users like ?", "%,"+fmt.Sprint(user.Id)+"%").Find(&frontUsers)
 	if err != nil {
 		return err
 	}
-	if !ok {
-		return nil
+	for _, fu := range frontUsers {
+		var num int64 = 0
+		if fu.DirectNumber == 0 {
+			continue
+		}
+		if fu.DirectNumber >= 1 {
+			if fu.BackNum < 5 {
+				num = user.Id - (fu.Id + 10) - fu.BackNum
+				fu.BackNum += num
+			}
+		}
+		if fu.DirectNumber >= 2 {
+			if fu.BackNum >= 5 && fu.BackNum < 10 {
+				num += user.Id - (fu.Id + 10) - fu.BackNum
+				fu.BackNum += num
+			}
+		}
+		if fu.DirectNumber >= 3 {
+			if fu.BackNum >= 10 && fu.BackNum < 15 {
+				num += user.Id - (fu.Id + 10) - fu.BackNum
+				fu.BackNum += num
+			}
+		}
+		_, err = engine.ID(user).Cols("back_num").Update(&fu)
+		if err != nil {
+			return err
+		}
+		invitrewards := amount * (float64(num / 100))
+		err = UpdateGift(engine, fu.Addr, invitrewards)
+		if err != nil {
+			return err
+		}
 	}
-	per.CommunityGift += rewards
-	_, err = engine.ID(uaddr).Cols("community_gift").Update(&per)
-	if err != nil {
-		return err
+	//back >25, DirectNumber 1,2,3
+	if user.Direct != "" {
+		var inviter models.UserInfo
+		ok, err := engine.ID(user.Direct).Get(&inviter)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return nil
+		}
+		var backNum int64 = 0
+		if user.Id > inviter.Id+25 && inviter.BackNum < 15 {
+			if inviter.DirectNumber >= 1 {
+				if inviter.BackNum < 5 {
+					backNum += 5 - inviter.BackNum
+				}
+			}
+			if inviter.DirectNumber >= 2 {
+				if inviter.BackNum >= 5 && inviter.BackNum < 10 {
+					backNum += 10 - inviter.BackNum - backNum
+				}
+			}
+			if inviter.DirectNumber >= 3 {
+				if inviter.BackNum >= 10 && inviter.BackNum < 15 {
+					backNum += 15 - inviter.BackNum - backNum
+				}
+			}
+			inviter.BackNum += backNum
+
+			_, err = engine.ID(user).Cols("back_num").Update(&inviter)
+			if err != nil {
+				return err
+			}
+			rewards := amount * (float64(backNum / 100))
+			err = UpdateGift(engine, inviter.Addr, rewards)
+			if err != nil {
+				return err
+			}
+		}
 	}
-	logs.Info("into UpdateCommunityGift end:", amount, uaddr)
+
+	logs.Info("UpdateCommunityGift end:", amount, uaddr)
 	return nil
 }
 
-func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
+func UpdateCommunityNodes(engine *xorm.Session, amount float64) error {
 	logs.Info("into UpdateCommunityNodes:", amount)
 	var nodes []models.UserInfo
 	err := engine.Where("state = ?", CommunityUsers).Find(&nodes)
@@ -247,14 +381,14 @@ func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
 	}
 	rewards := (amount * 5 / 100) / float64(len(nodes))
 	for _, node := range nodes {
-		err = UpdateAvailableRewards(rewards, node.Addr, false, false)
+		err = UpdateAvailableRewards(engine, rewards, node.Addr, false, false)
 		if err != nil {
 			fmt.Println(err)
 			continue
 		}
 
 		var per models.Performance
-		_, err = engine.Id(node.Addr).Get(&per)
+		_, err = engine.ID(node.Addr).Get(&per)
 		if err != nil {
 			fmt.Println(err)
 			continue
@@ -267,11 +401,11 @@ func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
 			continue
 		}
 	}
-	logs.Info("into UpdateCommunityNodes end:", amount)
+	logs.Info("UpdateCommunityNodes end:", amount)
 	return nil
 }
 
-func UpdateMarket(engine *xorm.Engine, amount float64) error {
+func UpdateMarket(engine *xorm.Session, amount float64) error {
 	logs.Info("into UpdateMarket:", amount)
 	var pers []models.Performance
 	err := engine.Where("market_num >= ?", 2).Find(&pers)
@@ -279,7 +413,7 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 		return err
 	}
 	var rp models.RewardsPool
-	ok, err := engine.Id(1).Get(&rp)
+	ok, err := engine.ID(1).Get(&rp)
 	if err != nil {
 		return err
 	}
@@ -308,7 +442,7 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 					//update available
 					logs.Debug(" UpdateMarket=====2,", per.Addr, rewards)
 
-					err := UpdateAvailableRewards(rewards, per.Addr, false, false)
+					err := UpdateAvailableRewards(engine, rewards, per.Addr, false, false)
 					if err != nil {
 						return err
 					}
@@ -326,6 +460,31 @@ func UpdateMarket(engine *xorm.Engine, amount float64) error {
 	if err != nil {
 		return err
 	}
-	logs.Info("into UpdateMarket end:", amount)
+	logs.Info("UpdateMarket end:", amount)
+	return nil
+}
+
+func UpdateGift(engine *xorm.Session, user string, rewards float64) error {
+	if rewards <= 0 {
+		return nil
+	}
+	err := UpdateAvailableRewards(engine, rewards, user, false, false)
+	if err != nil {
+		return err
+	}
+
+	var per models.Performance
+	ok, err := engine.ID(user).Get(&per)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return nil
+	}
+	per.CommunityGift += rewards
+	_, err = engine.ID(user).Cols("community_gift").Update(&per)
+	if err != nil {
+		return err
+	}
 	return nil
 }

controller/controller.go

@@ -1,71 +1,98 @@
 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, err := uc.engine.Id(user).Get(&ui)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	ok, Error := uc.engine.Id(user).Get(&ui)
+	if Error != nil {
 		return
 	}
 	if !ok {
-		ErrResponse(uc.Controller, "user not exist!")
+		Error = errors.New("user not exist")
 		return
 	}
 
 	///update availableReinput by left in db
 	///update totalReinput
 	if ui.AvailableReinput < ModBase {
-		ErrResponse(uc.Controller, "no available reinput balance")
+		Error = errors.New("no available reinput balance")
 		return
 	}
 	num := uint64(ui.AvailableReinput) / uint64(ModBase)
-
 	reinputValue := float64(num * ModBase)
-	logs.Info("check Reinput user:%v,num:%v available:%v,reinputValue=======%v", user, num, ui.AvailableReinput, reinputValue)
+
+	//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 != "" {
-		err := UpdateAvailableRewards(rewards, ui.Direct, false, false)
-		if err != nil {
-			logs.Error("check err=======", err)
-			ErrResponse(uc.Controller, err)
+		Error = UpdateAvailableRewards(sesion, rewards, ui.Direct, false, false)
+		if Error != nil {
 			return
 		}
 	}
 	///update indirect recommend rewards
 	if ui.Indirect != "" {
-		err := UpdateAvailableRewards(rewards, ui.Indirect, false, false)
-		if err != nil {
-			logs.Error("check err=======", err)
-			ErrResponse(uc.Controller, err)
+		Error = UpdateAvailableRewards(sesion, rewards, ui.Indirect, false, false)
+		if Error != nil {
 			return
 		}
 	}
-	err = UpdateRewardsPool(uc.engine, reinputValue)
-	if err != nil {
-		logs.Error("check err=======", err)
-		ErrResponse(uc.Controller, err)
+	Error = UpdateRewardsPool(sesion, reinputValue)
+	if Error != nil {
 		return
 	}
-	err = UpdateSuperiorsPerformance(uc.engine, ui.Superiors, reinputValue)
-	if err != nil {
-		logs.Error("check err=======", err)
-		ErrResponse(uc.Controller, err)
+	//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
 	}
 
@@ -75,10 +102,8 @@ func (uc *UserController) Reinput() {
 	if ui.TotalReinputed >= CommunityLimit {
 		ui.State = CommunityUsers
 	}
-	_, err = uc.engine.ID(user).Cols("available_reinput,total_reinputed,state").Update(&ui)
-	if err != nil {
-		logs.Error("check err=======", err)
-		ErrResponse(uc.Controller, err)
+	_, Error = uc.engine.ID(user).Cols("available_reinput,total_reinputed,state").Update(&ui)
+	if Error != nil {
 		return
 	}
 	TxObjectResponse(uc.Controller, "ok")
@@ -99,8 +124,6 @@ func (uc *UserController) GetClaimSignature() {
 		return
 	}
 
-	// format := time.Now().AddDate(0, 0, 1).Format("2006-01-02")
-	// te, _ := time.ParseInLocation("2006-01-02", format, time.Local)
 	i_time := time.Now().Unix() + 3600*2
 
 	pow := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(18)))
@@ -117,36 +140,46 @@ func (uc *UserController) SetClaimHash() {
 	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, err := uc.engine.Id(addr).Get(&ua)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	ok, Error := uc.engine.Id(addr).Get(&ua)
+	if Error != nil {
 		return
 	}
 	if !ok {
-		ErrResponse(uc.Controller, "user not exist!")
+		Error = errors.New("user not exist")
 		return
 	}
 	if ua.AvailableClaim == 0 {
-		ErrResponse(uc.Controller, "暂无收益领取")
+		Error = errors.New("user no available rewards to claim")
 		return
 	}
+
 	amount := ua.AvailableClaim
 	ua.TotalClaimed += amount
 	ua.AvailableClaim = 0
-	_, err = uc.engine.ID(addr).Cols("available_claim,total_claimed").Update(&ua)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	_, 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()}
-	_, err = uc.engine.Insert(&claimTx)
-	if err != nil {
-		ErrResponse(uc.Controller, err)
+	_, Error = sesion.Insert(&claimTx)
+	if Error != nil {
 		return
 	}
+
 	TxObjectResponse(uc.Controller, "ok")
 	return
 }
@@ -210,7 +243,71 @@ func (uc *UserController) TotalUsers() {
 		ErrResponse(uc.Controller, err)
 		return
 	}
-	us.Id = c
+	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
+}

controller/types.go

@@ -5,18 +5,17 @@ type UserController struct {
 }
 
 const (
-	Decimals         = 100000000000
-	PARTICIPATEVALUE = 1030
-	ModBase          = 100
-	CommunityLimit   = 1000
-	CommunityMarket  = 1000000
+	Decimals        = 100000000000
+	ModBase         = 100
+	CommunityLimit  = 1000
+	CommunityMarket = 1000000
 
 	CommonUser     = 0
 	OfficialUser   = 1
 	CommunityUsers = 2
 )
 
-//var PerformanceLevel = [6]float64{1, 3, 5, 7, 9, 11}	//test
+//var PerformanceLevel = [6]float64{1, 3, 5, 7, 9, 11} //test
 
 var PerformanceLevel = [6]float64{10000, 30000, 100000, 300000, 1000000, 900000000}
 var PerformanceRatio = [6]float64{0, 0.03, 0.06, 0.09, 0.12, 0.15}

dbUtil/dbCoon.go

@@ -19,12 +19,11 @@ func init() {
 	dbname := beego.AppConfig.String("mysqldb")
 	port := beego.AppConfig.String("mysqlport")
 
-	fmt.Println(u, p, url, dbname, port)
+	fmt.Println(u, url, dbname, port)
 	e, err := xorm.NewEngine("mysql", u+":"+p+"@tcp("+url+":+"+port+")/"+dbname+"?charset=utf8")
 	if err != nil {
 		log.Fatal("错误=", err)
 	}
 	Engine = e
 	fmt.Println("dbUtil init")
-	//Engine.ShowSQL(true)
 }

enums/CommonErrorResult.go

@@ -1,77 +0,0 @@
-package enums
-
-type CommonErrorResult int
-
-const (
-	SUCCESSFUL                 = 0
-	REQUEST_ERROR              = 100
-	SYS_ERROR                  = 400
-	REGISTER_FAIL              = 1001
-	USER_LOGIN_FAIL            = 1006
-	CHECK_SMS_FAIL             = 1002
-	REGISTER_PHONE_AGAIN       = 1004
-	REGISTER_ORGCODE_NOTEXISTS = 1005
-	ETH_ACCESS_CREATE_ERROR    = 1007
-	GET_USER_INFO_ERROR        = 1008
-	ERROR_MSG_INFO             = 1010
-	ORM_INSER_ERROR            = 2001
-	ETH_DIAL_ERROR             = 3001
-	GENERE_FALID               = 4202
-
-	MAX_FHL_BLOCK  = "max_fhl_block:"  //最大块号
-	USE_FHL_BLOCK  = "use_fhl_block:"  //当前处理块号
-	USE_SWAP_NFT   = "use_swap_nft:"   //当前处理块号
-	USE_WITHDRAWAL = "use_withdrawal:" //用户提取
-
-	USDRIDO    = "Transfer"    //转账
-	GDLIDO     = "Approval"    //授权
-	WITHDRAWAL = "newWithdraw" //提取
-	NEWDEPOSIT = "newDeposit"  //下注
-	//WITHDRAWCONTRACT = "0x868c9fFfcA5483931219B624e4F6A3033Dfe7a3b"  //取款合约
-	WITHDRAWCONTRACT = "0x5620CA8Ed0636d967c511bBB47a48460a9327f84" //测试取款合约
-	USDTMINTCONTRACT = "0x5620CA8Ed0636d967c511bBB47a48460a9327f84" //usdt正式申购
-	//USDTMINTCONTRACT = "0x3Aa22DA9B16D9BBCf60A45aC598508fB3F05e92c" //测试申购合约事件
-	//
-	AMOUNTCONTRACT = "0xb544f5Cef94fE0B2C3BB3a4886ea8918Bbe444f5" //获取价格
-	VERIFYCONTRACT = "0x8e437A9a89E16ED807Ab1841C029e5e9C4A82c74"
-	USDT           = "0xa6ea066bae96432414ac62818e62e2ecaa570de3" //usdt合约
-	//GDLCONTRACT = "0x9830c7dbcff54eb564ef952e2e5634787fc1c5d8" //代币合约地址
-	KTOCONTRACT = "0x3850D46C0442A86AaDd41D99f635e316c8788269" //kto合约地址
-	//DIGIT       = "0xc14771a70de44653a1fea2f9ab9eb3d69dbcbee7352bf3aee607c541955eb9ee" //签名验证的盐test
-	DIGIT = "0xce832387833fd72921b64fcb454dcc394940a5cdb53125e579ed10d529799e3c"
-)
-
-func (c CommonErrorResult) String() string {
-	switch c {
-	case SUCCESSFUL:
-		return "操作成功"
-	case SYS_ERROR:
-		return "系统异常"
-	case REQUEST_ERROR:
-		return "请重新登录"
-	case REGISTER_FAIL:
-		return "注册失败"
-	case USER_LOGIN_FAIL:
-		return "用户名或密码错误"
-	case CHECK_SMS_FAIL:
-		return "验证码错误或失效"
-	case REGISTER_PHONE_AGAIN:
-		return "该账户已被使用"
-	case REGISTER_ORGCODE_NOTEXISTS:
-		return "邀请码不存在"
-	case ERROR_MSG_INFO:
-		return "自定义错误返回"
-	case ETH_ACCESS_CREATE_ERROR:
-		return "钱包创建失败，稍后再试"
-	case ORM_INSER_ERROR:
-		return "数据创建出现错误"
-	case GET_USER_INFO_ERROR:
-		return "获取用户信息失败"
-	case ETH_DIAL_ERROR:
-		return "eth Dial not connect"
-	case GENERE_FALID:
-		return "GenerateKey is faild"
-	default:
-		return "UNKNOWN"
-	}
-}

main.go

@@ -4,6 +4,7 @@ import (
 	_ "ktogame/blockchain"
 	_ "ktogame/dbUtil"
 	_ "ktogame/routers"
+	_ "ktogame/util"
 
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego/logs"
@@ -14,7 +15,7 @@ import (
 func main() {
 	log := logs.NewLogger()
 	log.SetLogger(logs.AdapterConsole, `{"level":1,"color":false}`)
-	logs.SetLogger(logs.AdapterFile, `{"filename":"listener.log","maxsize":512000,"maxlines":10000,"daily":true}`)
+	logs.SetLogger(logs.AdapterFile, `{"filename":"listener.log","maxsize":2000000000,"maxlines":100000,"daily":true}`)
 	logs.EnableFuncCallDepth(true)
 	logs.SetLogFuncCallDepth(3)
 	logs.Async()

models/tables.go

@@ -15,6 +15,8 @@ type UserInfo struct {
 	AvailableReinput  float64 `xorm:"Decimal"` //可用复投
 	TotalReinputed    float64 `xorm:"Decimal"` //总复投
 	ParticipateAmount float64 `xorm:"Decimal"` //总参与
+	BackNum           int64   //本人后11-25领取个数
+	BackUsers         string  //本人后11-25用户id
 
 	State      int //身份   0 普通 	 1 正式   2 社区
 	CreateTime string

util/utils.go

@@ -3,14 +3,21 @@ package util
 import (
 	"crypto/md5"
 	"encoding/hex"
-	"ktogame/enums"
 	"time"
 
+	"github.com/astaxie/beego"
 	"github.com/astaxie/beego/logs"
 
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
+var DIGIT string
+
+func init() {
+	DIGIT = beego.AppConfig.String("digit")
+	logs.Info("init digit==", DIGIT[len(DIGIT)-4:])
+}
+
 func NowTimeString() string {
 	return time.Now().Format("2006-01-02 15:04:05")
 }
@@ -27,7 +34,7 @@ func Md5(str string) string {
 
 func Sign(amountStr, addr, timeStr string) string {
 	logs.Info("Sign==========", amountStr, addr, timeStr)
-	keccakA := crypto.Keccak256([]byte(amountStr), []byte(enums.DIGIT))
+	keccakA := crypto.Keccak256([]byte(amountStr), []byte(DIGIT))
 	keccakS := crypto.Keccak256(keccakA, []byte(timeStr), []byte(addr))
 	return "0x" + hex.EncodeToString(keccakS)
 }