resovle conflict

models/coin.go

@@ -227,16 +227,6 @@ func DeleteCoin(id int) error {
 	return nil
 }
 
-func GetCoinsPlatform() ([]*Coin, error) {
-	var coins []*Coin
-	err := db.Select("platform").Where("platform <> ?", "").Group("platform").Find(&coins).Error
-	if err != nil && err != gorm.ErrRecordNotFound {
-		return nil, err
-	}
-
-	return coins, nil
-}
-
 func GetCoinChains() ([]*Coin, error) {
 	var coins []*Coin
 	err := db.Select("chain").Where("chain <> ?", "").Group("chain").Find(&coins).Error

models/coin_ticker.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+)
+
+type CoinTicker struct {
+	CoinId     int     `json:"coin_id"`
+	CoinName   string  `json:"coin_name"`
+	Ticker     float32 `json:"ticker"`
+	PlatformId uint8   `json:"platform_id"`
+
+	//CoinInfo *Coin `gorm:"foreignkey:coin_id" json:"coin_info"`
+}
+
+type CoinTickerResp struct {
+	CoinId int     `json:"coin_id"`
+	Ticker float32 `json:"ticker"`
+	Name   string  `json:"name"`
+}
+
+func (c CoinTicker) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".wallet_coin_ticker"
+}
+
+func GetCoinsTicker(maps interface{}) ([]*CoinTicker, error) {
+	var ct []*CoinTicker
+	err := db.Where(maps).Find(&ct).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return ct, nil
+}
+
+func ExistCoin(coin_id int, platform_id uint8) (bool, error) {
+	var coinTicker CoinTicker
+	err := db.Where("coin_id = ? and platform_id = ?", coin_id, platform_id).First(&coinTicker).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return false, err
+	}
+
+	if coinTicker.CoinId > 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func AddCoinTicker(data map[string]interface{}) (error) {
+	coinTicker := CoinTicker{
+		CoinName:   data["coin_name"].(string),
+		CoinId:     data["coin_id"].(int),
+		Ticker:     data["ticker"].(float32),
+		PlatformId: data["platform_id"].(uint8),
+	}
+	if err := db.Create(&coinTicker).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func EditCoinTicker(maps interface{}, data interface{}) error {
+	if err := db.Model(&CoinTicker{}).Where(maps).Updates(data).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteCoinTicker(coin_id int, platform_id uint8) error {
+	if err := db.Where("coin_id = ? and platform_id = ?", coin_id, platform_id).Delete(CoinTicker{}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

models/supported_chain.go

@@ -12,7 +12,7 @@ type SupportedChain struct {
 	PlatformId int `json:"platform_id"` //钱包ID
 	CoinId     int `json:"coin_id"`     //币种ID
 
-	Coin *Coin `gorm:"ForeignKey:Id"`
+	CoinInfo *Coin `gorm:"foreignkey:coin_id" json:"coin_info"`
 }
 
 func (c SupportedChain) TableName() string {
@@ -60,7 +60,7 @@ func GetSupportedChainTotal(maps interface{}) (int, error) {
 func GetSupportedChains(pageNum, pageSize int, maps interface{}) ([]*SupportedChain, error) {
 	var chains []*SupportedChain
 
-	err := db.Preload("Coin").Where(maps).Offset(pageNum).Limit(pageSize).Find(&chains).Error
+	err := db.Preload("CoinInfo").Where(maps).Offset(pageNum).Limit(pageSize).Find(&chains).Error
 	if err != nil && err != gorm.ErrRecordNotFound {
 		return nil, err
 	}

pkg/errno/errno.go

@@ -217,4 +217,11 @@ var (
 	ErrSetPremission  = &Errno{Code: 20107, Message: "The role set premission."}
 	ErrGetPremissions = &Errno{Code: 20108, Message: "The role get premissions."}
 	ErrRoleAdminExits = &Errno{Code: 20109, Message: "There are users in this role."}
+
+	// coin ticker errors
+	ErrCoinTickerNotFound = &Errno{Code: 20101, Message: "The coin ticker was not found."}
+	ErrAddCoinTicker      = &Errno{Code: 20102, Message: "The coin ticker add error."}
+	ErrUpdateCoinTicker   = &Errno{Code: 20103, Message: "The coin ticker update error."}
+	ErrDeleteCoinTicker   = &Errno{Code: 20104, Message: "The coin ticker delete error."}
+	ErrExistCoinTicker    = &Errno{Code: 20105, Message: "The coin ticker already exists."}
 )

routers/api/backend/coin.go

@@ -6,8 +6,11 @@ import (
 	"bwallet/pkg/errno"
 	"bwallet/pkg/handler"
 	"bwallet/pkg/util"
+	"bwallet/service/chain_service"
 	"bwallet/service/coin_service"
 	"bwallet/service/recommend_coin_service"
+	"bwallet/service/trusteeship_coin_service"
+	"bwallet/service/wallet_service"
 	"bwallet/validate_service"
 	"github.com/Unknwon/com"
 	"github.com/astaxie/beego/validation"
@@ -260,22 +263,36 @@ func DeleteCoin(c *gin.Context) {
 	handler.SendResponse(c, nil, nil)
 }
 
-/*
-func GetCoinsPlatform(c *gin.Context) {
-	appG := app.Gin{c}
-	coinService := coin_service.Coin{}
-	coins, err := coinService.GetCoinsPlatform()
+func GetCoinsByPlatform(c *gin.Context) {
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+
+	walletService := wallet_service.Wallet{
+		Id: user.UserInfo.PlatformId,
+	}
+	wallet, _ := walletService.Get()
+
+	chainService := chain_service.Chain{
+		ID: wallet.ChainId,
+	}
+	chain, _ := chainService.Get()
+
+	coinService := coin_service.Coin{
+		PlatformId: util.ToString(user.UserInfo.PlatformId),
+		Platform:   chain.Platform,
+		PageNum:    util.GetPage(c),
+		PageSize:   util.GetLimit(c),
+	}
+
+	column := []string{"id", "name"}
+	coins, err := coinService.GetAllCoins(column)
 	if err != nil {
-		appG.Response(http.StatusInternalServerError, e.ERROR_GET_COIN_FAIL, nil)
+		handler.SendResponse(c, errno.InternalServerError, nil)
 		return
 	}
 
-	data := make(map[string]interface{})
-	data["lists"] = coins
-
-	appG.Response(http.StatusOK, e.SUCCESS, data)
+	handler.SendResponse(c, nil, coins)
 }
-*/
 
 func GetCoinChains(c *gin.Context) {
 	appG := app.Gin{c}

routers/api/backend/coin_ticker.go

+package backend
+
+import (
+	"bwallet/pkg/errno"
+	"bwallet/pkg/handler"
+	"bwallet/pkg/util"
+	"bwallet/service/coin_ticker_service"
+	"bwallet/validate_service"
+	"github.com/Unknwon/com"
+	"github.com/astaxie/beego/validation"
+	"github.com/gin-gonic/gin"
+	"strings"
+)
+
+func CoinsTicker(c *gin.Context) {
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+
+	CoinTickerService := coin_ticker_service.CoinTicker{
+		PlatformId: uint8(user.UserInfo.PlatformId),
+	}
+
+	coins_ticker, err := CoinTickerService.GetAll()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, coins_ticker)
+}
+
+func AddCoinTicker(c *gin.Context) {
+	coin_ticker := validate_service.CoinTicker{}
+	c.ShouldBindJSON(&coin_ticker)
+
+	if ok, errors := validate_service.ValidateInputs(coin_ticker); !ok {
+		for _, err := range errors {
+			handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
+			return
+		}
+	}
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+
+	CoinTickerValidateService := coin_ticker_service.CoinTicker{
+		CoinId:     coin_ticker.CoinId,
+		PlatformId: uint8(user.UserInfo.PlatformId),
+	}
+	exist, _ := CoinTickerValidateService.Exist()
+	if exist {
+		handler.SendResponse(c, errno.ErrExistCoinTicker, nil)
+		return
+	}
+
+	CoinTickerService := coin_ticker_service.CoinTicker{
+		CoinId:     coin_ticker.CoinId,
+		CoinName:   coin_ticker.CoinName,
+		Ticker:     coin_ticker.Ticker,
+		PlatformId: uint8(user.UserInfo.PlatformId),
+	}
+
+	if err := CoinTickerService.Add(); err != nil {
+		handler.SendResponse(c, errno.ErrAddCoinTicker, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func UpdateCoinTicker(c *gin.Context) {
+	coin_ticker := validate_service.CoinTicker{}
+	c.ShouldBindJSON(&coin_ticker)
+
+	if ok, errors := validate_service.ValidateInputs(coin_ticker); !ok {
+		for _, err := range errors {
+			handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
+			return
+		}
+	}
+
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+
+	CoinTickerValidateService := coin_ticker_service.CoinTicker{
+		CoinId:     coin_ticker.CoinId,
+		PlatformId: uint8(user.UserInfo.PlatformId),
+	}
+	exist, _ := CoinTickerValidateService.Exist()
+	if !exist {
+		handler.SendResponse(c, errno.ErrCoinTickerNotFound, nil)
+		return
+	}
+
+	CoinTickerService := coin_ticker_service.CoinTicker{
+		CoinId:     coin_ticker.CoinId,
+		PlatformId: uint8(user.UserInfo.PlatformId),
+		Ticker:     coin_ticker.Ticker,
+	}
+
+	if err := CoinTickerService.Edit(); err != nil {
+		handler.SendResponse(c, errno.ErrAddCoinTicker, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func DeleteCoinTicker(c *gin.Context) {
+	coin_id := com.StrTo(c.DefaultQuery("coin_id", "0")).MustInt()
+	valid := validation.Validation{}
+	valid.Min(coin_id, 1, "coin_id").Message("ID必须大于0")
+	if valid.HasErrors() {
+		handler.SendResponse(c, errno.ErrValidation, nil)
+		return
+	}
+	token := c.Request.Header.Get("Token")
+	user, _ := util.ParseToken(token)
+	CoinTickerService := coin_ticker_service.CoinTicker{
+		CoinId:     coin_id,
+		PlatformId: uint8(user.UserInfo.PlatformId),
+	}
+	exists, err := CoinTickerService.Exist()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrValidation, nil)
+		return
+	}
+
+	if !exists {
+		handler.SendResponse(c, errno.ErrCoinTickerNotFound, nil)
+		return
+	}
+
+	err = CoinTickerService.Delete()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrDeleteCoinTicker, nil)
+		return
+	}
+	handler.SendResponse(c, nil, nil)
+}

routers/router.go

@@ -66,6 +66,12 @@ func InitRouter() *gin.Engine {
 		api.DELETE("/coin", backend.DeleteCoin)
 		api.GET("/primary-chains", backend.GetCoinChains)
 		api.GET("/types", backend.GetTypes)
+		api.GET("/coins-by-platform", backend.GetCoinsByPlatform)
+
+		api.GET("/coins-ticker", backend.CoinsTicker)
+		api.POST("/coin-ticker", backend.AddCoinTicker)
+		api.PUT("/coin-ticker", backend.UpdateCoinTicker)
+		api.DELETE("/coin-ticker", backend.DeleteCoinTicker)
 
 		api.GET("/coin-relation", backend.GetWalletCoinRelationCoinRelations)
 		api.POST("/coin-relation", backend.AddWalletCoinRelationCoinRelation)

service/coin_service/coin.go

@@ -28,6 +28,26 @@ type Coin struct {
 	PageSize int
 }
 
+type CoinResp struct {
+	Id             int             `json:"id,omitempty"`
+	Name           string          `json:"name,omitempty"`
+	Nickname       json.RawMessage `json:"nickname,omitempty"`
+	Icon           string          `json:"icon,omitempty"`
+	Introduce      json.RawMessage `json:"introduce,omitempty"`
+	Official       string          `json:"official,omitempty"`
+	Paper          string          `json:"paper,omitempty"`
+	Platform       string          `json:"platform,omitempty"`
+	Chain          string          `json:"chain,omitempty"`
+	Release        string          `json:"release,omitempty"`
+	AreaSearch     string          `json:"area_search,omitempty"`
+	PublishCount   float64         `json:"publish_count,omitempty"`
+	CirculateCount float64         `json:"circulate_count,omitempty"`
+	Decimals       int             `json:"decimals,omitempty"`
+	Address        string          `json:"address,omitempty"`
+	Treaty         int             `json:"treaty,omitempty"`
+	PlatformId     string          `json:"platform_id,omitempty"`
+}
+
 /**
  * 通过id获取指定币种信息
  * @param id
@@ -179,10 +199,10 @@ func (c *Coin) Delete() error {
 	return models.DeleteCoin(c.Id)
 }
 
-func (c *Coin) GetCoinsPlatform() ([]*models.Coin, error) {
+func (c *Coin) GetCoinChains() ([]*models.Coin, error) {
 	var coins []*models.Coin
 
-	coins, err := models.GetCoinsPlatform()
+	coins, err := models.GetCoinChains()
 	if err != nil {
 		return nil, err
 	}
@@ -190,15 +210,22 @@ func (c *Coin) GetCoinsPlatform() ([]*models.Coin, error) {
 	return coins, nil
 }
 
-func (c *Coin) GetCoinChains() ([]*models.Coin, error) {
-	var coins []*models.Coin
-
-	coins, err := models.GetCoinChains()
+func (c *Coin) GetAllCoins(column []string) ([]*CoinResp, error) {
+	coins, err := models.GetCoins(c.PageNum, c.PageSize, c.getMaps())
 	if err != nil {
 		return nil, err
 	}
 
-	return coins, nil
+	var coinsResp = []*CoinResp{}
+	for _, val := range coins {
+		tmp := &CoinResp{}
+		tmp.Id = val.ID
+		tmp.Name = val.Name
+
+		coinsResp = append(coinsResp, tmp)
+	}
+
+	return coinsResp, nil
 }
 
 func (c *Coin) getMaps() (map[string]interface{}) {

service/coin_ticker_service/coin_ticker.go

+package coin_ticker_service
+
+import (
+	"bwallet/models"
+)
+
+type CoinTicker struct {
+	CoinId     int
+	CoinName   string
+	Ticker     float32
+	PlatformId uint8
+}
+
+func (ct *CoinTicker) GetAll() ([]*models.CoinTicker, error) {
+	coins_ticker, err := models.GetCoinsTicker(ct.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	//var CoinsTickerResp = []*models.CoinTickerResp{}
+	//for _, val := range coins_ticker {
+	//	tmp := &models.CoinTickerResp{}
+	//	tmp.CoinId = val.CoinInfo.ID
+	//	tmp.Name = val.CoinInfo.Name
+	//	tmp.Ticker = val.Ticker
+	//
+	//	CoinsTickerResp = append(CoinsTickerResp, tmp)
+	//}
+
+	return coins_ticker, nil
+}
+
+func (t *CoinTicker) Add() error {
+	coinTicker := map[string]interface{}{
+		"coin_id":     t.CoinId,
+		"coin_name":   t.CoinName,
+		"ticker":      t.Ticker,
+		"platform_id": t.PlatformId,
+	}
+
+	if err := models.AddCoinTicker(coinTicker); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (t *CoinTicker) Edit() error {
+	return models.EditCoinTicker(t.getMaps(), map[string]interface{}{
+		"ticker": t.Ticker,
+	})
+}
+
+func (t *CoinTicker) Exist() (bool, error) {
+	return models.ExistCoin(t.CoinId, t.PlatformId)
+}
+
+func (t *CoinTicker) Delete() error {
+	return models.DeleteCoinTicker(t.CoinId, t.PlatformId)
+}
+
+func (c *CoinTicker) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	if c.CoinId != 0 {
+		maps["coin_id"] = c.CoinId
+	}
+
+	if c.PlatformId != 0 {
+		maps["platform_id"] = c.PlatformId
+	}
+	return maps
+}

service/supported_chain_service/supported_chain.go

 package supported_chain_service
 
-import "bwallet/models"
+import (
+	"bwallet/models"
+)
 
 type SupportedChain struct {
 	ID         int
@@ -11,6 +13,12 @@ type SupportedChain struct {
 	PageSize int
 }
 
+type SupportedChainResp struct {
+	ID     int    `json:"id"`
+	Name   string `json:"name"`
+	CoinId int    `json:"coin_id"`
+}
+
 func (c *SupportedChain) Get() (*models.SupportedChain, error) {
 	chain, err := models.GetSupportedChain(c.ID)
 	if err != nil {
@@ -20,15 +28,22 @@ func (c *SupportedChain) Get() (*models.SupportedChain, error) {
 	return chain, nil
 }
 
-func (c *SupportedChain) GetAll() ([]*models.SupportedChain, error) {
-	var chains []*models.SupportedChain
-
+func (c *SupportedChain) GetAll() ([]*SupportedChainResp, error) {
 	chains, err := models.GetSupportedChains(c.PageNum, c.PageSize, c.getMaps())
 	if err != nil {
 		return nil, err
 	}
 
-	return chains, nil
+	var coinsResp = []*SupportedChainResp{}
+	for _, val := range chains {
+		tmp := &SupportedChainResp{}
+		tmp.ID = val.ID
+		tmp.Name = val.CoinInfo.Name
+		tmp.CoinId = val.CoinId
+		coinsResp = append(coinsResp, tmp)
+	}
+
+	return coinsResp, nil
 }
 
 func (c *SupportedChain) Add() error {

validate_service/coin_ticker.go

+package validate_service
+
+type CoinTicker struct {
+	CoinId   int     `json:"coin_id" validate:"required"`
+	CoinName string  `json:"coin_name" validate:"required"`
+	Ticker   float32 `json:"ticker" validate:"required"`
+}