添加币时可选链

models/chain.go

@@ -19,7 +19,9 @@ type Chain struct {
 }
 
 type UserChain struct {
-	Id       int    `json:"id"`
+	Model
+
+	Id       int    `json:"primary_key,omitempty"`
 	Platform string `json:"platform"` //平行链名称
 }
 
@@ -27,6 +29,10 @@ func (c Chain) TableName() string {
 	return setting.DatabaseSetting.Name_Sources + ".wallet_chain"
 }
 
+func (c UserChain) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".wallet_chain"
+}
+
 /**
  * 通过id检查链是否存在
  * @param id

models/platform_chain.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+)
+
+type PlatformChain struct {
+	Model
+
+	Id         int `json:"primary_key,omitempty"`
+	PlatformId int `json:"platform_id"`
+	ChainId    int `json:"chain_id"`
+
+	ChainInfo *UserChain `gorm:"foreignkey:ChainId" json:"chain"`
+}
+
+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 coinRecommend PlatformChain
+	err := db.Select("id").Where("id = ?", id).First(&coinRecommend).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return false, err
+	}
+
+	if coinRecommend.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(maps interface{}) ([]*PlatformChain, error) {
+	var platformChain []*PlatformChain
+	err := db.Preload("ChainInfo").Where(maps).Find(&platformChain).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return platformChain, nil
+}
+
+func DeleteByPlatformIdChainId(maps interface{}) error {
+	if err := db.Where(maps).Delete(PlatformChain{}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

routers/api/v1/chain.go

 package v1
 
 import (
+	"bwallet/models"
 	"bwallet/pkg/errno"
 	"bwallet/pkg/handler"
 	"bwallet/pkg/util"
 	"bwallet/service/auth_service"
 	"bwallet/service/chain_service"
+	"bwallet/service/platform_chain_service"
 	"bwallet/validate_service"
 	"github.com/Unknwon/com"
 	"github.com/astaxie/beego/validation"
@@ -100,37 +102,30 @@ func GetChains(c *gin.Context) {
 }
 
 func GetUserChains(c *gin.Context) {
-	valid := validation.Validation{}
-
-	platform := ""
-	if arg := c.Query("platform"); arg != "" {
-		platform = c.Query("platform")
-	}
-
-	if valid.HasErrors() {
-		handler.SendResponse(c, errno.ErrValidation, nil)
-		return
-	}
-
-	chainService := chain_service.Chain{
-		Platform: platform,
-	}
-
-	total, err := chainService.Count()
-	if err != nil {
-		handler.SendResponse(c, errno.ErrCountChain, nil)
-		return
+	token := c.Request.Header.Get("Token")
+	authService := auth_service.Auth{Token: token}
+	auth, _ := authService.GetUserInfo()
+	platform_id := auth.PlatformId
+	platformChainService := platform_chain_service.PlatformChain{
+		PlatformId: platform_id,
 	}
-
-	chains, err := chainService.GetUserChain()
+	platform_chain, err := platformChainService.GetAll()
 	if err != nil {
 		handler.SendResponse(c, errno.InternalServerError, nil)
 		return
 	}
 
 	data := make(map[string]interface{})
+
+	var chains []*models.UserChain
+	for _, val := range platform_chain {
+		if nil != val.ChainInfo{
+			chains = append(chains, val.ChainInfo)
+		}
+	}
+
 	data["items"] = chains
-	data["total"] = total
+	data["total"] = len(platform_chain)
 
 	handler.SendResponse(c, nil, data)
 }

service/platform_chain_service/platform_chain.go

+package platform_chain_service
+
+import (
+	"bwallet/models"
+)
+
+type PlatformChain struct {
+	Id         int
+	PlatformId int
+	ChainId    int
+}
+
+func (c *PlatformChain) Get() (*models.PlatformChain, error) {
+
+	platformChain, err := models.GetPlatformChain(c.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return platformChain, nil
+}
+
+func (c *PlatformChain) GetAll() ([]*models.PlatformChain, error) {
+	var platformChain []*models.PlatformChain
+
+	platformChain, err := models.GetPlatformChains(c.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	return platformChain, nil
+}
+
+func (c *PlatformChain) ExistById() (bool, error) {
+	return models.ExistPlatformChainById(c.Id)
+}
+
+func (c *PlatformChain) Count() (int, error) {
+	return models.GetPlatformChainTotal(c.getMaps())
+}
+
+func (c *PlatformChain) DeleteByCondition() error {
+	return models.DeleteByPlatformIdChainId(c.getMaps())
+}
+
+func (c *PlatformChain) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	if c.PlatformId != 0 {
+		maps["platform_id"] = c.PlatformId
+	}
+
+	if c.ChainId != 0 {
+		maps["chain_id"] = c.ChainId
+	}
+
+	return maps
+}