controller.go 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313
  1. package controller
  2. import (
  3. "errors"
  4. "fmt"
  5. "ktogame/models"
  6. "ktogame/util"
  7. "strings"
  8. "time"
  9. "github.com/go-xorm/xorm"
  10. "github.com/astaxie/beego/logs"
  11. "github.com/shopspring/decimal"
  12. )
  13. func (uc *UserController) Reinput() {
  14. sesion := uc.engine.NewSession()
  15. var Error error
  16. defer func() {
  17. if Error != nil {
  18. sesion.Rollback()
  19. ErrResponse(uc.Controller, Error)
  20. } else {
  21. sesion.Commit()
  22. }
  23. }()
  24. user := uc.GetString("addr")
  25. var ui models.UserInfo
  26. ok, Error := uc.engine.Id(user).Get(&ui)
  27. if Error != nil {
  28. return
  29. }
  30. if !ok {
  31. Error = errors.New("user not exist")
  32. return
  33. }
  34. ///update availableReinput by left in db
  35. ///update totalReinput
  36. if ui.AvailableReinput < ModBase {
  37. Error = errors.New("no available reinput balance")
  38. return
  39. }
  40. num := uint64(ui.AvailableReinput) / uint64(ModBase)
  41. reinputValue := float64(num * ModBase)
  42. //test
  43. //reinputValue := ui.AvailableReinput
  44. //test end
  45. logs.Info("check Reinput user:%v,num:%v available:%v,reinputValue=======%v", user, ui.AvailableReinput, reinputValue)
  46. ///update Recommendation Rewards
  47. ///update direct recommend rewards
  48. rewards := reinputValue * 10 / 100
  49. if ui.Direct != "" {
  50. Error = UpdateAvailableRewards(sesion, rewards, ui.Direct, false, false)
  51. if Error != nil {
  52. return
  53. }
  54. }
  55. ///update indirect recommend rewards
  56. if ui.Indirect != "" {
  57. Error = UpdateAvailableRewards(sesion, rewards, ui.Indirect, false, false)
  58. if Error != nil {
  59. return
  60. }
  61. }
  62. Error = UpdateRewardsPool(sesion, reinputValue)
  63. if Error != nil {
  64. return
  65. }
  66. //15%
  67. Error = UpdateSuperiorsPerformance(sesion, ui.Superiors, reinputValue)
  68. if Error != nil {
  69. return
  70. }
  71. //50%
  72. Error = frontAndBackRewards(sesion, ui.Addr, reinputValue)
  73. if Error != nil {
  74. return
  75. }
  76. //Update Community Nodes(5%)
  77. Error = UpdateCommunityNodes(sesion, reinputValue)
  78. if Error != nil {
  79. logs.Info(Error)
  80. return
  81. }
  82. //update Market(10%) tuan dui fu dao
  83. Error = UpdateMarket(sesion, reinputValue)
  84. if Error != nil {
  85. logs.Info(Error)
  86. return
  87. }
  88. ui.AvailableReinput -= reinputValue
  89. ui.TotalReinputed += reinputValue
  90. if ui.TotalReinputed >= CommunityLimit {
  91. ui.State = CommunityUsers
  92. }
  93. _, Error = uc.engine.ID(user).Cols("available_reinput,total_reinputed,state").Update(&ui)
  94. if Error != nil {
  95. return
  96. }
  97. TxObjectResponse(uc.Controller, "ok")
  98. return
  99. }
  100. func (uc *UserController) GetClaimSignature() {
  101. addr := uc.GetString("addr")
  102. s := uc.GetString("sign")
  103. user := util.GetPri(s, addr[len(addr)-16:])
  104. if strings.ToLower(user) != strings.ToLower(addr) {
  105. ErrResponse(uc.Controller, "无效地址")
  106. return
  107. }
  108. var ua models.UserInfo
  109. uc.engine.Id(user).Get(&ua)
  110. if ua.AvailableClaim == 0 {
  111. ErrResponse(uc.Controller, "暂无收益领取")
  112. return
  113. }
  114. i_time := time.Now().Unix() + 3600*2
  115. pow := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(18)))
  116. amount := decimal.NewFromFloat(ua.AvailableClaim).Mul(pow).BigInt().String()
  117. out1 := util.Sign(amount, strings.ToLower(user[2:]), fmt.Sprint(i_time))
  118. sign := out1 + "-" + amount + "-" + fmt.Sprint(i_time)
  119. code := util.EnPriCode(sign, addr[len(addr)-16:])
  120. TxObjectResponse(uc.Controller, code)
  121. return
  122. }
  123. func (uc *UserController) SetClaimHash() {
  124. addr := uc.GetString("addr")
  125. hash := uc.GetString("hash")
  126. sign := uc.GetString("sign")
  127. sesion := uc.engine.NewSession()
  128. var Error error
  129. defer func() {
  130. if Error != nil {
  131. sesion.Rollback()
  132. ErrResponse(uc.Controller, Error)
  133. return
  134. }
  135. sesion.Commit()
  136. }()
  137. var ua models.UserInfo
  138. ok, Error := uc.engine.Id(addr).Get(&ua)
  139. if Error != nil {
  140. return
  141. }
  142. if !ok {
  143. Error = errors.New("user not exist")
  144. return
  145. }
  146. if ua.AvailableClaim == 0 {
  147. Error = errors.New("user no available rewards to claim")
  148. return
  149. }
  150. amount := ua.AvailableClaim
  151. ua.TotalClaimed += amount
  152. ua.AvailableClaim = 0
  153. _, Error = sesion.ID(addr).Cols("available_claim,total_claimed").Update(&ua)
  154. if Error != nil {
  155. return
  156. }
  157. logs.Info("check SetClaimHash---------:", addr, hash, ua.AvailableClaim, ua.TotalClaimed, amount)
  158. claimTx := models.ClaimedTxs{Addr: addr, Amount: amount, Hash: hash,
  159. Signature: sign, State: 0, Droped: 0, CreateTime: util.NowTimeString()}
  160. _, Error = sesion.Insert(&claimTx)
  161. if Error != nil {
  162. return
  163. }
  164. TxObjectResponse(uc.Controller, "ok")
  165. return
  166. }
  167. func (uc *UserController) GetUserInfo() {
  168. user := uc.GetString("addr")
  169. var us models.UserInfo
  170. uc.engine.Id(user).Get(&us)
  171. TxObjectResponse(uc.Controller, us)
  172. return
  173. }
  174. func (uc *UserController) GetTeamList() {
  175. user := uc.GetString("addr")
  176. s, err := uc.GetInt("size")
  177. if err != nil {
  178. TxObjectResponse(uc.Controller, err)
  179. return
  180. }
  181. l, err := uc.GetInt("limit")
  182. if err != nil {
  183. TxObjectResponse(uc.Controller, err)
  184. return
  185. }
  186. var us models.UserInfo
  187. var teamList []models.UserInfo
  188. ok, err := uc.engine.Id(user).Get(&us)
  189. if err != nil {
  190. TxObjectResponse(uc.Controller, err)
  191. return
  192. }
  193. if !ok {
  194. TxObjectResponse(uc.Controller, us)
  195. return
  196. }
  197. c, err := uc.engine.Where("superiors like ?", "%,"+fmt.Sprint(us.Id)+"%").FindAndCount(&teamList)
  198. if err != nil {
  199. TxObjectResponse(uc.Controller, err)
  200. return
  201. }
  202. var addrList []string
  203. for _, u := range teamList {
  204. addrList = append(addrList, u.Addr)
  205. }
  206. res := models.Page{Limit: l, Size: s, Total: c, DataList: addrList}
  207. TxObjectResponse(uc.Controller, res)
  208. return
  209. }
  210. func (uc *UserController) GetPerformance() {
  211. user := uc.GetString("addr")
  212. var per models.Performance
  213. uc.engine.Id(user).Get(&per)
  214. TxObjectResponse(uc.Controller, per)
  215. return
  216. }
  217. func (uc *UserController) TotalUsers() {
  218. var us models.UserInfo
  219. c, err := uc.engine.Count(&us)
  220. if err != nil {
  221. ErrResponse(uc.Controller, err)
  222. return
  223. }
  224. us.Id = c - 1
  225. TxObjectResponse(uc.Controller, us)
  226. return
  227. }
  228. func frontAndBackRewards(sesion *xorm.Session, addr string, reinputValue float64) error {
  229. var user models.UserInfo
  230. ok, err := sesion.ID(addr).Get(&user)
  231. if err != nil {
  232. return err
  233. }
  234. if !ok {
  235. return nil
  236. }
  237. //front 25%
  238. var fronts []models.UserInfo
  239. if user.Id > 25 {
  240. err := sesion.Where("id >= ? and id < ?", user.Id-25, user.Id).Find(&fronts)
  241. if err != nil {
  242. return err
  243. }
  244. } else {
  245. err := sesion.Where("id >= ? and id < ?", 1, user.Id).Find(&fronts)
  246. if err != nil {
  247. return err
  248. }
  249. }
  250. if len(fronts) > 0 {
  251. backrewards := reinputValue / 100
  252. for _, u := range fronts {
  253. err := UpdateAvailableRewards(sesion, backrewards, u.Addr, false, false)
  254. if err != nil {
  255. return err
  256. }
  257. }
  258. }
  259. //back 25%
  260. var currUser models.UserInfo
  261. ok, err = sesion.Desc("id").Get(&currUser)
  262. if err != nil {
  263. return err
  264. }
  265. if !ok {
  266. return nil
  267. }
  268. var backs []models.UserInfo
  269. if user.Id+25 <= currUser.Id {
  270. err := sesion.Where("id > ? and id <= ?", user.Id, currUser.Id+25).Find(&backs)
  271. if err != nil {
  272. return err
  273. }
  274. } else {
  275. err := sesion.Where("id > ? and id <= ?", user.Id, currUser.Id).Find(&backs)
  276. if err != nil {
  277. return err
  278. }
  279. }
  280. if len(backs) > 0 {
  281. backrewards := reinputValue / 100
  282. for _, b := range backs {
  283. err := UpdateAvailableRewards(sesion, backrewards, b.Addr, false, false)
  284. if err != nil {
  285. return err
  286. }
  287. }
  288. }
  289. return nil
  290. }