fix

models/platform_chain.go

-package models
-
-import (
-	"bwallet/pkg/setting"
-	"github.com/jinzhu/gorm"
-)
-
-type PlatformChain struct {
-	Model
-
-	Id         int `json:"primary_key,omitempty"`
-	ChainId    int `json:"chain_id"`
-	PlatformId int `json:"platform_id"`
-
-	Chain    Chain  `json:"Chain"`
-	Platform Wallet `json:"Platform"`
-}
-
-func (c PlatformChain) TableName() string {
-	return setting.DatabaseSetting.Name_Sources + ".wallet_platform_chain"
-}
-
-func GetPlatformChain(id int) (*PlatformChain, error) {
-	var platformChain PlatformChain
-	err := db.Where("id = ?", id).First(&platformChain).Error
-	if err != nil && err != gorm.ErrRecordNotFound {
-		return nil, err
-	}
-	err = db.Model(&platformChain).Error
-	if err != nil && err != gorm.ErrRecordNotFound {
-		return nil, err
-	}
-
-	return &platformChain, nil
-}
-
-func ExistPlatformChainById(id int) (bool, error) {
-	var platformChain PlatformChain
-	err := db.Select("id").Where("id = ?", id).First(&platformChain).Error
-	if err != nil && err != gorm.ErrRecordNotFound {
-		return false, err
-	}
-
-	if platformChain.ID > 0 {
-		return true, nil
-	}
-
-	return false, nil
-}
-
-func GetPlatformChainTotal(maps interface{}) (int, error) {
-	var count int
-	if err := db.Model(&PlatformChain{}).Where(maps).Count(&count).Error; err != nil {
-		return 0, err
-	}
-
-	return count, nil
-}
-
-func GetPlatformChains(pageNum, pageSize int, maps interface{}) ([]*PlatformChain, error) {
-	var platformChain []*PlatformChain
-	err := db.Preload("Chain").Preload("Platform").Where(maps).Offset(pageNum).Limit(pageSize).Find(&platformChain).Error
-	if err != nil && err != gorm.ErrRecordNotFound {
-		return nil, err
-	}
-
-	return platformChain, nil
-}
-
-func AddPlatformChain(data map[string]interface{}) (error) {
-	platformChain := PlatformChain{
-		PlatformId: data["platform_id"].(int),
-		ChainId:    data["chain_id"].(int),
-	}
-	if err := db.Create(&platformChain).Error; err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func DeletePlatformChain(id int) error {
-	if err := db.Where("id = ?", id).Delete(PlatformChain{}).Error; err != nil {
-		return err
-	}
-
-	return nil
-}

models/supported_chain.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+)
+
+type SupportedChain struct {
+	Model
+
+	Id         int `json:"primary_key,omitempty"`
+	PlatformId int `json:"platform_id"` //钱包ID
+	CoinId     int `json:"coin_id"`     //币种ID
+
+	Coin *Coin `gorm:"ForeignKey:Id"`
+}
+
+func (c SupportedChain) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".coin_supported_chain"
+}
+
+/**
+ * 通过id检查记录是否存在
+ * @param id
+ * @return
+ */
+func ExistSupportedChainById(id int) (bool, error) {
+	var chain SupportedChain
+	err := db.Select("id").Where("id = ?", id).First(&chain).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return false, err
+	}
+
+	if chain.ID > 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+/**
+ * 获取符合条件的信息总数
+ * @param id
+ * @return
+ */
+func GetSupportedChainTotal(maps interface{}) (int, error) {
+	var count int
+	if err := db.Model(&SupportedChain{}).Where(maps).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+/**
+ * 获取符合条件的信息
+ * @param id
+ * @return
+ */
+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
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return chains, nil
+}
+
+/**
+ * 通过id获取指定id信息
+ * @param id
+ * @return
+ */
+func GetSupportedChain(id int) (*SupportedChain, error) {
+	var chain SupportedChain
+	err := db.Where("id = ?", id).First(&chain).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	err = db.Model(&chain).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return &chain, nil
+}
+
+/**
+ * 添加支持主链
+ * @param
+ * @return
+ */
+func AddSupportedChain(data map[string]interface{}) (error) {
+	chain := SupportedChain{
+		PlatformId: data["platform_id"].(int),
+		CoinId:     data["coin_id"].(int),
+	}
+	if err := db.Create(&chain).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+/**
+ * 删除支持主链信息
+ * @param
+ * @return
+ */
+func DeleteSupportedChain(id int) error {
+	if err := db.Where("id = ?", id).Delete(SupportedChain{}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

models/wallet_coin_relation.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+)
+
+type WalletCoinRelation struct {
+	Model
+	Id         int `json:"id,omitempty"`
+	PlatformId int `json:"platform_id"` //钱包ID
+	CoinId     int `json:"coin_id"`     //币种ID
+
+	Coin *Coin `gorm:"ForeignKey:CoinId"`
+}
+
+func (c WalletCoinRelation) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".wallet_coin_relation"
+}
+
+/**
+ * 获取符合条件的信息总数
+ * @param id
+ * @return
+ */
+func GetWalletCoinRelationTotal(maps interface{}) (int, error) {
+	var count int
+	if err := db.Model(&WalletCoinRelation{}).Where(maps).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+/**
+ * 获取符合条件的信息
+ * @param id
+ * @return
+ */
+func GetWalletCoinRelations(pageNum, pageSize int, maps interface{}) ([]*WalletCoinRelation, error) {
+	var coins []*WalletCoinRelation
+
+	err := db.Preload("Coin").Where(maps).Offset(pageNum).Limit(pageSize).Find(&coins).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return coins, nil
+}
+
+/**
+ * 删除钱包币关系
+ * @param
+ * @return
+ */
+func DeleteWalletCoinRelation(platform_id, coin_id int) error {
+	if err := db.Where("platform_id = ? and coin_id = ?", platform_id, coin_id).Delete(WalletCoinRelation{}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/errno/errno.go

@@ -104,12 +104,12 @@ var (
 	ErrExistSupportedCurrency    = &Errno{Code: 20103, Message: "The supported currency already exists."}
 
 	// wallet supported chain errors
-	ErrWalletSupportedChainNotFound = &Errno{Code: 20101, Message: "The wallet supported chain was not found."}
-	ErrCountWalletSupportedChain    = &Errno{Code: 20102, Message: "The wallet supported chain statistic error."}
-	ErrAddWalletSupportedChain      = &Errno{Code: 20101, Message: "The wallet supported chain add error."}
-	ErrUpdateWalletSupportedChain   = &Errno{Code: 20102, Message: "The wallet supported chain update error."}
-	ErrDeleteWalletSupportedChain   = &Errno{Code: 20102, Message: "The wallet supported chain delete error."}
-	ErrExistWalletSupportedChain    = &Errno{Code: 20103, Message: "The wallet supported chain already exists."}
+	ErrSupportedChainNotFound = &Errno{Code: 20101, Message: "The wallet supported chain was not found."}
+	ErrCountSupportedChain    = &Errno{Code: 20102, Message: "The wallet supported chain statistic error."}
+	ErrAddSupportedChain      = &Errno{Code: 20101, Message: "The wallet supported chain add error."}
+	ErrDeleteSupportedChain   = &Errno{Code: 20102, Message: "The wallet supported chain delete error."}
+	ErrExistSupportedChain    = &Errno{Code: 20103, Message: "The wallet supported chain already exists."}
+
 
 	// user errors
 	ErrUserTokenIncorrect = &Errno{Code: 40001, Message: "The user token was incorrect."}

routers/api/v1/platform_chain.go → routers/api/v1/supported_chain.go

@@ -5,7 +5,7 @@ import (
 	"bwallet/pkg/handler"
 	"bwallet/pkg/util"
 	"bwallet/service/auth_service"
-	"bwallet/service/platform_chain_service"
+	"bwallet/service/supported_chain_service"
 	"bwallet/validate_service"
 	"github.com/Unknwon/com"
 	"github.com/astaxie/beego/validation"
@@ -13,70 +13,74 @@ import (
 	"strings"
 )
 
-func GetPlatformChains(c *gin.Context) {
+func GetSupportedChains(c *gin.Context) {
+	valid := validation.Validation{}
 
 	token := c.Request.Header.Get("Token")
 	authService := auth_service.Auth{Token: token}
 	auth, _ := authService.GetUserInfo()
 	group := auth.Group
-
 	var platform_id int
-	platform_id = auth.PlatformId
 	if ("administrator" == group) {
-		if arg := c.Query("platform_id"); arg != "" {
-			platform_id = com.StrTo(c.Query("platform_id")).MustInt()
-		}
+		platform_id = com.StrTo(c.DefaultQuery("platform_id", "1")).MustInt()
+	} else {
+		platform_id = auth.PlatformId
+	}
+
+	if valid.HasErrors() {
+		handler.SendResponse(c, errno.ErrValidation, nil)
+		return
 	}
 
-	platformChainService := platform_chain_service.PlatformChain{
+	chainService := supported_chain_service.SupportedChain{
 		PlatformId: platform_id,
 		PageNum:    util.GetPage(c),
 		PageSize:   util.GetLimit(c),
 	}
 
-	total, err := platformChainService.Count()
+	total, err := chainService.Count()
 	if err != nil {
-		handler.SendResponse(c, errno.ErrCountWalletSupportedChain, nil)
+		handler.SendResponse(c, errno.ErrCountSupportedChain, nil)
 		return
 	}
 
-	coinRecommends, err := platformChainService.GetAll()
+	chains, err := chainService.GetAll()
 	if err != nil {
 		handler.SendResponse(c, errno.InternalServerError, nil)
 		return
 	}
 
 	data := make(map[string]interface{})
-	data["items"] = coinRecommends
+	data["items"] = chains
 	data["total"] = total
 
 	handler.SendResponse(c, nil, data)
 }
 
-func AddPlatformChain(c *gin.Context) {
-	platform_chain := validate_service.PlatformChain{}
-	c.ShouldBindJSON(&platform_chain)
+func AddSupportedChain(c *gin.Context) {
+	chain := validate_service.SupportedChain{}
+	c.ShouldBindJSON(&chain)
 
 	//方法一
-	if ok, errors := validate_service.ValidateInputs(platform_chain); !ok {
+	if ok, errors := validate_service.ValidateInputs(chain); !ok {
 		for _, err := range errors {
 			handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
 			return
 		}
 	}
-
+	return
 	//自定义验证
-	platformChainValidate := platform_chain_service.PlatformChain{
-		PlatformId: platform_chain.PlatformId,
-		ChainId:    platform_chain.ChainId,
+	supportedCurrencyValidate := supported_chain_service.SupportedChain{
+		PlatformId: chain.PlatformId,
+		CoinId:     11111,
 	}
-	total, err := platformChainValidate.Count()
+	total, err := supportedCurrencyValidate.Count()
 	if err != nil {
-		handler.SendResponse(c, errno.ErrCountWalletSupportedChain, nil)
+		handler.SendResponse(c, errno.ErrCountSupportedChain, nil)
 		return
 	}
 	if (total > 0) {
-		handler.SendResponse(c, errno.ErrExistWalletSupportedChain, nil)
+		handler.SendResponse(c, errno.ErrExistSupportedChain, nil)
 		return
 	}
 
@@ -88,25 +92,26 @@ func AddPlatformChain(c *gin.Context) {
 	var platform_id int
 	platform_id = auth.PlatformId
 	if ("administrator" == group) {
-		if platform_chain.PlatformId != 0 {
-			platform_id = platform_chain.PlatformId
+		if chain.PlatformId != 0 {
+			platform_id = chain.PlatformId
 		}
 	}
 
-	platformChainService := platform_chain_service.PlatformChain{
+	chainService := supported_chain_service.SupportedChain{
 		PlatformId: platform_id,
-		ChainId:    platform_chain.ChainId,
+		CoinId:     11111,
 	}
 
-	if err := platformChainService.Add(); err != nil {
-		handler.SendResponse(c, errno.ErrAddWalletSupportedChain, nil)
+	if err := chainService.Add(); err != nil {
+		handler.SendResponse(c, errno.ErrAddSupportedChain, nil)
 		return
 	}
 
 	handler.SendResponse(c, nil, nil)
 }
 
-func DeletePlatformChain(c *gin.Context) {
+func DeleteSupportedChain(c *gin.Context) {
+
 	valid := validation.Validation{}
 	id := com.StrTo(c.Param("id")).MustInt()
 	valid.Min(id, 1, "id").Message("ID必须大于0")
@@ -116,15 +121,15 @@ func DeletePlatformChain(c *gin.Context) {
 		return
 	}
 
-	platformChainService := platform_chain_service.PlatformChain{Id: id}
-	exists, err := platformChainService.ExistById()
+	chainService := supported_chain_service.SupportedChain{ID: id}
+	exists, err := chainService.ExistById()
 	if err != nil {
-		handler.SendResponse(c, errno.ErrWalletSupportedChainNotFound, nil)
+		handler.SendResponse(c, errno.ErrValidation, nil)
 		return
 	}
 
 	if !exists {
-		handler.SendResponse(c, errno.ErrWalletSupportedChainNotFound, nil)
+		handler.SendResponse(c, errno.ErrValidation, nil)
 		return
 	}
 
@@ -133,15 +138,16 @@ func DeletePlatformChain(c *gin.Context) {
 	auth, _ := authService.GetUserInfo()
 	group := auth.Group
 	if ("administrator" != group) {
-		platform_chain, _ := platformChainService.Get()
-		if platform_chain.PlatformId != auth.PlatformId {
+		chain, _ := chainService.Get()
+		if chain.PlatformId != auth.PlatformId {
 			handler.SendResponse(c, errno.ErrUserAuthIncorrect, nil)
 			return
 		}
 	}
-	err = platformChainService.Delete()
+
+	err = chainService.Delete()
 	if err != nil {
-		handler.SendResponse(c, errno.ErrDeleteWalletSupportedChain, nil)
+		handler.SendResponse(c, errno.ErrDeleteSupportedChain, nil)
 		return
 	}
 

routers/api/v1/wallet_coin_relation.go

+package v1
+
+import (
+	"bwallet/pkg/errno"
+	"bwallet/pkg/handler"
+	"bwallet/pkg/util"
+	"bwallet/service/auth_service"
+	"bwallet/service/wallet_coin_relation_service"
+	"github.com/gin-gonic/gin"
+)
+
+func GetWalletCoinRelationCoinRelations(c *gin.Context) {
+
+	token := c.Request.Header.Get("Token")
+	authService := auth_service.Auth{Token: token}
+	auth, _ := authService.GetUserInfo()
+	var platform_id int
+	platform_id = auth.PlatformId
+
+	walletCoinRelateionService := wallet_coin_relation_service.WalletCoinRelation{}
+
+	walletCoinRelateionService = wallet_coin_relation_service.WalletCoinRelation{
+		PlatformId: platform_id,
+		PageNum:    util.GetPage(c),
+		PageSize:   util.GetLimit(c),
+	}
+
+	total, err := walletCoinRelateionService.Count()
+	if err != nil {
+		//handler.SendResponse(c, errno.ErrCountWalletCoinRelation, nil)
+		return
+	}
+
+	coins, err := walletCoinRelateionService.GetAll()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	data := make(map[string]interface{})
+	data["items"] = coins
+	data["total"] = total
+
+	handler.SendResponse(c, nil, data)
+}

routers/router.go

@@ -29,7 +29,7 @@ func InitRouter() *gin.Engine {
 	{
 		//api.POST("/upload",v1.Upload)
 
-		api.GET("/coins", v1.GetCoins)
+		api.GET("/coins", v1.GetWalletCoinRelationCoinRelations)
 		api.POST("/coin", v1.AddCoin)
 		api.GET("/coin/:id", v1.GetCoin)
 		api.PUT("/coin", v1.EditCoin)
@@ -62,9 +62,9 @@ func InitRouter() *gin.Engine {
 		api.DELETE("/supported-currency/:id", v1.DeleteSupportedCurrency)
 		api.GET("/currencies", v1.GetCurrencies)
 
-		api.GET("/platform-chains", v1.GetPlatformChains)
-		api.POST("/platform-chain", v1.AddPlatformChain)
-		api.DELETE("/platform-chain/:id", v1.DeletePlatformChain)
+		api.GET("/supported-chains", v1.GetSupportedChains)
+		api.POST("/supported-chain", v1.AddSupportedChain)
+		api.DELETE("/supported-chain/:id", v1.DeleteSupportedChain)
 	}
 
 	return r

service/platform_chain_service/platform_chain.go → service/supported_chain_service/supported_chain.go

-package platform_chain_service
+package supported_chain_service
 
-import (
-	"bwallet/models"
-)
+import "bwallet/models"
 
-type PlatformChain struct {
-	Id         int
-	ChainId    int
+type SupportedChain struct {
+	ID         int
 	PlatformId int
+	CoinId     int
 
 	PageNum  int
 	PageSize int
 }
 
-func (c *PlatformChain) Get() (*models.PlatformChain, error) {
-
-	platformChain, err := models.GetPlatformChain(c.Id)
+func (c *SupportedChain) Get() (*models.SupportedChain, error) {
+	chain, err := models.GetSupportedChain(c.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	return platformChain, nil
+	return chain, nil
 }
 
-func (c *PlatformChain) GetAll() ([]*models.PlatformChain, error) {
-	var coinsRecommend []*models.PlatformChain
+func (c *SupportedChain) GetAll() ([]*models.SupportedChain, error) {
+	var chains []*models.SupportedChain
 
-	coinsRecommend, err := models.GetPlatformChains(c.PageNum, c.PageSize, c.getMaps())
+	chains, err := models.GetSupportedChains(c.PageNum, c.PageSize, c.getMaps())
 	if err != nil {
 		return nil, err
 	}
 
-	return coinsRecommend, nil
+	return chains, nil
 }
 
-func (c *PlatformChain) Add() error {
-	platformChain := map[string]interface{}{
+func (c *SupportedChain) Add() error {
+	chain := map[string]interface{}{
 		"platform_id": c.PlatformId,
-		"chain_id":    c.ChainId,
+		"coin_id":     c.CoinId,
 	}
 
-	if err := models.AddPlatformChain(platformChain); err != nil {
+	if err := models.AddSupportedChain(chain); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (c *PlatformChain) ExistById() (bool, error) {
-	return models.ExistPlatformChainById(c.Id)
+func (c *SupportedChain) ExistById() (bool, error) {
+	return models.ExistSupportedChainById(c.ID)
 }
 
-func (c *PlatformChain) Count() (int, error) {
-	return models.GetPlatformChainTotal(c.getMaps())
+func (c *SupportedChain) Count() (int, error) {
+	return models.GetSupportedChainTotal(c.getMaps())
 }
 
-func (c *PlatformChain) Delete() error {
-	return models.DeletePlatformChain(c.Id)
+func (c *SupportedChain) Delete() error {
+	return models.DeleteSupportedChain(c.ID)
 }
 
-func (c *PlatformChain) getMaps() (map[string]interface{}) {
+func (c *SupportedChain) getMaps() (map[string]interface{}) {
 	maps := make(map[string]interface{})
 
-	if c.PlatformId != 0 {
-		maps["platform_id"] = c.PlatformId
+	if c.ID != 0 {
+		maps["id"] = c.ID
 	}
 
-	if c.ChainId != 0 {
-		maps["chain_id"] = c.ChainId
+	if c.PlatformId != 0 {
+		maps["platform_id"] = c.PlatformId
 	}
-
 	return maps
 }

service/wallet_coin_relation_service/wallet_coin_relation.go

+package wallet_coin_relation_service
+
+import (
+	"bwallet/models"
+)
+
+type WalletCoinRelation struct {
+	PlatformId int
+	CoinId     int
+
+	PageNum  int
+	PageSize int
+}
+
+func (w *WalletCoinRelation) GetAll() ([]*models.WalletCoinRelation, error) {
+	var coins []*models.WalletCoinRelation
+
+	coins, err := models.GetWalletCoinRelations(w.PageNum, w.PageSize, w.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	return coins, nil
+}
+
+func (w *WalletCoinRelation) Count() (int, error) {
+	return models.GetWalletCoinRelationTotal(w.getMaps())
+}
+
+func (c *WalletCoinRelation) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	//if c.PlatformId != 0 {
+	//	maps["platform_id"] = c.PlatformId
+	//}
+
+	if c.CoinId != 0 {
+		maps["coin_id"] = c.CoinId
+	}
+
+	return maps
+}

validate_service/supported_chain.go

+package validate_service
+
+type SupportedChain struct {
+	PlatformId int    `json:"platform_id" validate:"required"`
+	CoinName   string `json:"coin_name" validate:"required"`
+}