Merge branch 'feature/bonus' into 'develop'

.gitignore

@@ -10,3 +10,7 @@ conf/app.ini
 
 # output
 *.out
+*.yaml
+
+# module
+/vendor

go.mod

@@ -4,55 +4,33 @@ go 1.16
 
 require (
 	github.com/BurntSushi/toml v0.3.1 // indirect
-	github.com/Knetic/govaluate v3.0.0+incompatible // indirect
-	github.com/alicebob/gopher-json v0.0.0-20180125190556-5a6b3ba71ee6 // indirect
-	github.com/alicebob/miniredis v2.5.0+incompatible // indirect
-	github.com/astaxie/beego v1.10.1
-	github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd // indirect
-	github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542 // indirect
-	github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737 // indirect
-	github.com/casbin/casbin v1.7.0 // indirect
-	github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58 // indirect
-	github.com/couchbase/go-couchbase v0.0.0-20200519150804-63f3cdb75e0d // indirect
-	github.com/couchbase/gomemcached v0.0.0-20200526233749-ec430f949808 // indirect
-	github.com/couchbase/goutils v0.0.0-20180530154633-e865a1461c8a // indirect
-	github.com/cupcake/rdb v0.0.0-20161107195141-43ba34106c76 // indirect
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
-	github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 // indirect
-	github.com/elastic/go-elasticsearch/v6 v6.8.5 // indirect
-	github.com/elazarl/go-bindata-assetfs v1.0.0 // indirect
 	github.com/gin-gonic/gin v1.7.7
-	github.com/glendc/gopher-json v0.0.0-20170414221815-dc4743023d0c // indirect
 	github.com/go-ini/ini v1.66.4
-	github.com/go-redis/redis v6.14.2+incompatible // indirect
+	github.com/go-playground/validator/v10 v10.10.1 // indirect
 	github.com/go-sql-driver/mysql v1.6.0
-	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/gomodule/redigo v1.8.8
 	github.com/hashicorp/golang-lru v0.5.4 // indirect
 	github.com/jinzhu/gorm v1.9.16
-	github.com/koding/logging v0.0.0-20160720134017-8b5a689ed69b // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/koding/logging v0.0.0-20160720134017-8b5a689ed69b
+	github.com/mattn/go-isatty v0.0.14 // indirect
 	github.com/mattn/go-sqlite3 v2.0.3+incompatible // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/onsi/ginkgo v1.12.0 // indirect
-	github.com/pelletier/go-toml v1.2.0 // indirect
-	github.com/peterh/liner v1.0.1-0.20171122030339-3681c2a91233 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/prometheus/client_golang v1.7.0 // indirect
 	github.com/robfig/cron v1.2.0
 	github.com/shiena/ansicolor v0.0.0-20151119151921-a422bbe96644 // indirect
-	github.com/siddontang/go v0.0.0-20170517070808-cb568a3e5cc0 // indirect
-	github.com/siddontang/goredis v0.0.0-20150324035039-760763f78400 // indirect
-	github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d // indirect
-	github.com/ssdb/gossdb v0.0.0-20180723034631-88f6b59b84ec // indirect
-	github.com/streadway/amqp v1.0.0 // indirect
+	github.com/shopspring/decimal v1.3.1
+	github.com/streadway/amqp v1.0.0
 	github.com/stretchr/testify v1.7.0 // indirect
-	github.com/syndtr/goleveldb v0.0.0-20181127023241-353a9fca669c // indirect
-	github.com/wendal/errors v0.0.0-20130201093226-f66c77a7882b // indirect
+	github.com/ugorji/go v1.2.7 // indirect
 	github.com/xinliangnote/go-util v0.0.0-20210703052933-7f9f6d961276
-	github.com/yuin/gopher-lua v0.0.0-20171031051903-609c9cd26973 // indirect
 	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
-	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	golang.org/x/sys v0.0.0-20220422013727-9388b58f7150 // indirect
+	google.golang.org/protobuf v1.28.0 // indirect
 	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
 	gopkg.in/go-playground/validator.v9 v9.31.0
-	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 // indirect
+	gopkg.in/yaml.v2 v2.4.0
 )

main.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"slg/models"
-	"slg/pkg/cron"
 	"slg/pkg/gredis"
 	"slg/pkg/setting"
 	"slg/pkg/util"
@@ -20,7 +19,7 @@ func init() {
 	models.Setup()
 	gredis.Setup()
 	util.Setup()
-	cron.Setup()
+	//cron.Setup()
 	rabbitmq.Setup()
 }
 

middleware/auth/auth.go

-package auth
-
-import (
-	"slg/pkg/errno"
-	"slg/pkg/handler"
-	"slg/pkg/util"
-	"github.com/gin-gonic/gin"
-	"strings"
-)
-
-func AUTH() gin.HandlerFunc {
-	return func(ctx *gin.Context) {
-
-		token := ctx.Request.Header.Get("Token")
-		user, _ := util.ParseToken(token)
-		if !strings.Contains(strings.ToLower(user.UserInfo.Username), "kefu") {
-			return
-		}
-
-		handlerName := strings.Split(ctx.HandlerName(), ".")[1]
-		handleAlowed := []string{"GetCoinChains", "GetUserChains", "AddOperationLog"}
-		_, handle := util.Contains(handleAlowed, handlerName)
-
-		if !handle {
-			handler.SendResponse(ctx, errno.PermissionDenied, nil)
-			ctx.Abort()
-			return
-		}
-
-		ctx.Next()
-	}
-}

middleware/jwt/jwt.go

 package jwt
 
 import (
-	"slg/pkg/e"
-	"slg/pkg/util"
 	"github.com/dgrijalva/jwt-go"
 	"github.com/gin-gonic/gin"
 	"net/http"
+	"slg/pkg/e"
+	"slg/pkg/util"
 )
 
 func JWT() gin.HandlerFunc {

middleware/log/log.go

-package log
-
-import (
-	"slg/pkg/util"
-	"slg/service/operation_log_service"
-
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"strconv"
-	"strings"
-)
-
-func LogMiddleware(handlerTableName map[string]string) gin.HandlerFunc {
-	return func(ctx *gin.Context) {
-		var operation string
-
-		// 获取当前用户信息
-		token := ctx.Request.Header.Get("Token")
-		user, err := util.ParseToken(token)
-		if err != nil {
-			ctx.Abort()
-			return
-		}
-		user_id := user.UserInfo.Uid
-		user_name := user.UserInfo.Username
-		platform_id := user.UserInfo.PlatformId
-
-		// 获取表名 这里会把前面 "加载的包名.HandlerName"
-		handlerName := strings.Split(ctx.HandlerName(), ".")[1]
-		if _, ok := handlerTableName[handlerName]; !ok {
-			ctx.Next()
-		}
-
-		tableDesc := strings.Split(handlerTableName[handlerName], ",")
-		if len(tableDesc) != 2 {
-			return // 存在映射，但是不完全则返回
-		}
-		tableName := tableDesc[0] // 0表名
-		desc := tableDesc[1]      // 1业务描述
-
-		switch ctx.Request.Method {
-		case "POST":
-			operation = "增加"
-		case "GET":
-			operation = "查询"
-		case "PUT":
-			operation = "更新"
-		case "DELETE":
-			operation = "删除"
-		default:
-			operation = "未知"
-		}
-
-		operationLogService := operation_log_service.OperationLog{
-			UserId:     user_id,
-			UserName:   user_name,
-			PlatformId: platform_id,
-			Ip:         ctx.ClientIP(),
-			Operation:  operation,
-			Business:   desc,
-			Table:      tableName,
-		}
-
-		if err := operationLogService.Add(); err != nil {
-			ctx.Abort()
-			return
-		}
-
-		return
-	}
-}
-
-func FirstMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		fmt.Println(c.Request.Method, c.ClientIP(), c.Request.Header.Get("Token"))
-		fmt.Println("first middleware before next()")
-		isAbort := c.Query("isAbort")
-		bAbort, err := strconv.ParseBool(isAbort)
-		if err != nil {
-			fmt.Printf("is abort value err, value %s\n", isAbort)
-			c.Next() // (2)
-		}
-		if bAbort {
-			fmt.Println("first middleware abort") //(3)
-			c.Abort()
-			//c.AbortWithStatusJSON(http.StatusOK, "abort is true")
-			return
-		} else {
-			fmt.Println("first middleware doesnot abort") //(4)
-			return
-		}
-
-		fmt.Println("first middleware after next()")
-	}
-}
-
-func SecondMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		fmt.Println("current inside of second middleware")
-	}
-}

middleware/sign/aes/aes.go

 package aes
 
 import (
-	config "slg/conf"
-	"slg/pkg/errno"
-	"slg/pkg/handler"
-	"slg/pkg/util"
 	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/xinliangnote/go-util/aes"
 	"net/url"
+	config "slg/conf"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
 	"sort"
 	"strconv"
 	"strings"

middleware/sign/md5/md5.go

 package md5
 
 import (
-	config "slg/conf"
-	"slg/pkg/handler"
-	"slg/pkg/util"
 	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
 	"net/url"
+	config "slg/conf"
+	"slg/pkg/handler"
+	"slg/pkg/util"
 	"sort"
 	"strconv"
 	"strings"

middleware/sign/rsa/rsa.go

 package rsa
 
 import (
-	config "slg/conf"
-	"slg/pkg/errno"
-	"slg/pkg/handler"
-	"slg/pkg/util"
 	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/xinliangnote/go-util/rsa"
 	"net/url"
+	config "slg/conf"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
 	"sort"
 	"strconv"
 	"strings"

models/bonus.go

+package models
+
+import (
+	"github.com/jinzhu/gorm"
+	"time"
+)
+
+type Bonus struct {
+	Model
+
+	Oid                 string `json:"oid"`
+	MerchantId          string `json:"merchant_id"`
+	MerchantBonusAmount string `json:"merchant_bonus_amount"`
+	AuthorUid           string `json:"author_uid"`
+	AuthorBonusAmount   string `json:"author_bonus_amount"`
+	InviteUid           string `json:"invite_uid"`
+	InviteBonusAmount   string `json:"invite_bonus_amount"`
+	ShareUid            string `json:"share_uid"`
+	ShareBonusAmount    string `json:"share_bonus_amount"`
+	PlatformUid         string `json:"platform_uid"`
+	PlatformBonusAmount string `json:"platform_bonus_amount"`
+	CreateTime          int64  `json:"create_time"`
+	UpdateTime          int64  `json:"update_time"`
+}
+
+/**
+ * 通过oid获取订单信息
+ * @oid id
+ * @return
+ */
+func Exist(oid string) (*Bonus, error) {
+	var bonus Bonus
+	err := db.Where("oid = ?", oid).First(&bonus).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return &bonus, nil
+}
+
+/**
+ * 添加收益记录
+ * @return
+ */
+func AddBonus(data map[string]interface{}) error {
+	bonus := Bonus{
+		Oid:                 data["oid"].(string),
+		MerchantId:          data["merchant_id"].(string),
+		MerchantBonusAmount: data["merchant_bonus_amount"].(string),
+		AuthorUid:           data["author_uid"].(string),
+		AuthorBonusAmount:   data["author_bonus_amount"].(string),
+		InviteUid:           data["invite_uid"].(string),
+		InviteBonusAmount:   data["invite_bonus_amount"].(string),
+		ShareUid:            data["share_uid"].(string),
+		ShareBonusAmount:    data["share_bonus_amount"].(string),
+		PlatformUid:         data["platform_uid"].(string),
+		PlatformBonusAmount: data["platform_bonus_amount"].(string),
+		CreateTime:          time.Now().UTC().Unix(),
+		UpdateTime:          time.Now().UTC().Unix(),
+	}
+
+	tx := db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if err := tx.Error; err != nil {
+		return err
+	}
+
+	if err := tx.Debug().Create(&bonus).Error; err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	if data["invite_uid"] != "" {
+		bonusDetail := BonusDetail{
+			Uid:         data["invite_uid"].(string),
+			BonusAmount: data["invite_bonus_amount"].(string),
+			BonusType:   Invite,
+			CreateTime:  time.Now().UTC().Unix(),
+			UpdateTime:  time.Now().UTC().Unix(),
+		}
+		if err := tx.Debug().Table("bonus_detail").Create(&bonusDetail).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+
+		bonusStatistics, err := GetBonusStatistics(data["invite_uid"].(string))
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+
+		if len(bonusStatistics.Uid) < 1 {
+			bonusStatistics := BonusStatistics{
+				Uid:               data["invite_uid"].(string),
+				InviteBonusAmount: data["invite_bonus_amount"].(string),
+				ShareBonusAmount:  data["share_bonus_amount"].(string),
+				CreateTime:        time.Now().UTC().Unix(),
+				UpdateTime:        time.Now().UTC().Unix(),
+			}
+			if err := tx.Debug().Table("bonus_statistics").Create(&bonusStatistics).Error; err != nil {
+				tx.Rollback()
+				return err
+			}
+		} else {
+			statistics := map[string]interface{}{
+				"invite_bonus_amount": gorm.Expr("invite_bonus_amount + ?", data["invite_bonus_amount"]),
+			}
+			if err := tx.Table("bonus_statistics").Where("uid = ?", data["invite_uid"].(string)).UpdateColumns(statistics).Error; err != nil {
+				tx.Rollback()
+				return err
+			}
+		}
+	}
+
+	if data["share_uid"] != "" {
+		bonusDetail := BonusDetail{
+			Uid:         data["share_uid"].(string),
+			BonusAmount: data["share_bonus_amount"].(string),
+			BonusType:   Share,
+			CreateTime:  time.Now().UTC().Unix(),
+			UpdateTime:  time.Now().UTC().Unix(),
+		}
+		if err := tx.Debug().Table("bonus_detail").Create(&bonusDetail).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+
+		bonusStatistics, err := GetBonusStatistics(data["share_uid"].(string))
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+
+		if len(bonusStatistics.Uid) < 1 {
+			bonusStatistics := BonusStatistics{
+				Uid:               data["share_uid"].(string),
+				InviteBonusAmount: data["invite_bonus_amount"].(string),
+				ShareBonusAmount:  data["share_bonus_amount"].(string),
+				CreateTime:        time.Now().UTC().Unix(),
+				UpdateTime:        time.Now().UTC().Unix(),
+			}
+			if err := tx.Debug().Table("bonus_statistics").Create(&bonusStatistics).Error; err != nil {
+				tx.Rollback()
+				return err
+			}
+		} else {
+			statistics := map[string]interface{}{
+				"share_bonus_amount": gorm.Expr("share_bonus_amount + ?", data["share_bonus_amount"]),
+			}
+			if err := tx.Table("bonus_statistics").Where("uid = ?", data["share_uid"].(string)).UpdateColumns(statistics).Error; err != nil {
+				tx.Rollback()
+				return err
+			}
+		}
+	}
+
+	if err := tx.Commit().Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetCount(conditions interface{}) (int, error) {
+	var count int
+	if err := db.Model(&Bonus{}).Where(conditions).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func GetBonus(pageNum, pageSize int, conditions interface{}) ([]*Bonus, error) {
+	var bonus []*Bonus
+	err := db.Debug().Where(conditions).Offset(pageNum).Limit(pageSize).Find(&bonus).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return bonus, nil
+}

models/bonus_detail.go

+package models
+
+import "github.com/jinzhu/gorm"
+
+const Invite = 1 //邀请
+const Share = 2 //分享
+const Redraw = 3 //提取
+
+type BonusDetail struct {
+	Model
+
+	Uid         string `json:"uid"`
+	BonusAmount string `json:"bonus_amount"`
+	BonusType   uint8  `json:"bonus_type"`
+	CreateTime  int64  `json:"create_time"`
+	UpdateTime  int64  `json:"update_time"`
+}
+
+type BonusDetailResp struct {
+	BonusAmount string `json:"bonus_amount"`
+	BonusType   uint8  `json:"bonus_type"`
+	CreateTime  string  `json:"create_time"`
+}
+
+func GetBonusDetailCount(conditions interface{}) (int, error) {
+	var count int
+	if err := db.Model(&BonusDetail{}).Where(conditions).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func GetBonusDetailList(pageNum, pageSize int, conditions interface{}) ([]*BonusDetail, error) {
+	var bonusDetail []*BonusDetail
+	err := db.Debug().Where(conditions).Offset(pageNum).Limit(pageSize).Find(&bonusDetail).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return bonusDetail, nil
+}

models/bonus_statistics.go

+package models
+
+import "github.com/jinzhu/gorm"
+
+type BonusStatistics struct {
+	Model
+
+	Uid               string `json:"uid"`
+	InviteBonusAmount string `json:"invite_bonus_amount"`
+	ShareBonusAmount  string `json:"share_bonus_amount"`
+	CreateTime        int64  `json:"create_time"`
+	UpdateTime        int64  `json:"update_time"`
+}
+
+type BonusStatisticsResp struct {
+	BonusAmount       string `json:"bonus_amount"`
+	InviteBonusAmount string `json:"invite_bonus_amount"`
+	ShareBonusAmount  string `json:"share_bonus_amount"`
+}
+
+func GetBonusStatistics(uid string) (*BonusStatistics, error) {
+	var bonusStatistics BonusStatistics
+	err := db.Debug().Where("uid = ?", uid).First(&bonusStatistics).Error
+	if err != nil && err != gorm.ErrRecordNotFound{
+		return nil, err
+	}
+
+	return &bonusStatistics, nil
+}

models/models.go

@@ -14,7 +14,7 @@ import (
 var db *gorm.DB
 
 type Model struct {
-	ID         int `gorm:"primary_key" json:"id"`
+	ID int `gorm:"primary_key" json:"id"`
 	//CreatedOn  int `json:"created_on"`
 	//ModifiedOn int `json:"modified_on"`
 	//DeletedOn  int `json:"deleted_on"`

models/order_info.go

+package models
+
+type OrderInfo struct {
+	Model
+
+	Id                   uint64 `json:"primary_key,omitempty"`
+	Oid                  string `json:"oid"`
+	Uid                  string `json:"uid"`
+	PayId                string `json:"pay_id"`
+	MerchantId           string `json:"merchant_id"`
+	PostFee              string `json:"post_fee"`
+	Total                string `json:"total"`
+	AcceptDigital        uint8  `json:"accept_digital"`
+	PayType              uint8  `json:"pay_type"`
+	OrderType            uint8  `json:"order_type"`
+	OrderState           uint8  `json:"order_state"`
+	Delivery             uint8  `json:"delivery"`
+	Uname                string `json:"uname"`
+	Phone                string `json:"phone"`
+	Address              string `json:"address"`
+	IsDelete             uint8  `json:"is_delete"`
+	VNote                string `json:"v_note"`
+	ConsultDiscounAmount string `json:"consult_discoun"`
+	ConsultDiscountType  uint8  `json:"consult_discount_type"`
+	DiscountAmount       string `json:"discount_amount"`
+	Amount               string `json:"amount"`
+	CreateTime           uint64 `json:"create_time"`
+	UpdateTime           uint64 `json:"update_time"`
+	CommentTotal         uint64 `json:"comment_total"`
+	CommentAlready       uint64 `json:"comment_already"`
+	Coin                 string `json:"coin"`
+	IntegralDeduction    string `json:"integral_deduction"`
+	IntegralPrice        string `json:"integral_price"`
+	OrderIdent           uint8  `json:"order_ident"`
+}
+
+/**
+ * 通过oid获取订单信息
+ * @oid id
+ * @return
+ */
+func GetOrderInfo(oid string) (*OrderInfo, error) {
+	var orderInfo OrderInfo
+	err := db.Debug().Where("oid = ?", oid).First(&orderInfo).Error
+	if err != nil {
+		return nil, err
+	}
+
+	return &orderInfo, nil
+}

models/order_share_relation.go

+package models
+
+import (
+	"encoding/json"
+	"github.com/jinzhu/gorm"
+	"strconv"
+)
+
+type OrderShareRelation struct {
+	Model
+
+	Id         int             `json:"primary_key, id,omitempty"`
+	ShareUid   string          `json:"share_uid"`
+	InvitedUid string          `json:"invited_uid"`
+	Oids       json.RawMessage `json:"oids"`
+}
+
+/**
+ * 通过oid获取推广分销信息
+ * @oid id
+ * @return
+ */
+func GetOrderShareRelation(oid string) (*OrderShareRelation, error) {
+	var orderShareRelation OrderShareRelation
+	err := db.Where("JSON_CONTAINS(oids, ?)", strconv.Quote(oid)).First(&orderShareRelation).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return &orderShareRelation, nil
+}

models/user.go

+package models
+
+import "github.com/jinzhu/gorm"
+
+type User struct {
+	Model
+
+	Id           uint64 `json:"primary_key,omitempty"`
+	Uid          string `json:"uid"`
+	InviteCode   string `json:"invite_code"`
+	RegisterCode string `json:"register_code"`
+}
+
+/**
+ * 通过单条件获取用户信息
+ * @condition interface{}
+ * @return
+ */
+func GetUserInfo(condition interface{}) (*User, error) {
+	var user User
+	err := db.Where(condition).First(&user).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+/**
+ * 通过多条件获取用户信息
+ * @conditions interface{}
+ * @return
+ */
+func GetUserInfos(conditions interface{}) ([]*User, error) {
+	var users []*User
+	err := db.Where(conditions).Find(&users).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return users, nil
+}

module/yaml.go

+package module
+
+type Level struct {
+	Merchant float64 `yaml:merchant`
+	Author   float64 `yaml:author`
+	Invite   float64 `yaml:invite`
+	Share    float64 `yaml:share`
+	Platform float64 `yaml:platform`
+}
+
+type Bonus struct {
+	PlatformUid string            `yaml:"platform_uid"`
+	AuthorUid   string            `yaml:"author_uid"`
+	Levels      map[string]*Level `yaml:"levels"`
+}
+
+type BonusConfig struct {
+	Bonus *Bonus `json:"bonus"`
+}

pkg/cron/cron.go

@@ -2,6 +2,7 @@ package cron
 
 import (
 	"github.com/robfig/cron"
+	"slg/service/rabbitmq_service"
 )
 
 var c *cron.Cron
@@ -9,7 +10,12 @@ var c *cron.Cron
 func Setup() {
 	c = cron.New()
 
-	c.AddFunc("* * * * * *", func() {
+	c.AddFunc("*/5 * * * * *", func() {
+		amqpService := rabbitmq_service.AmqpConsumer{
+			ExchangeName: "mall-order-finish-fanout-exchange",
+			QueueName:    "mall-cr-order-finish-queue",
+		}
+		amqpService.Consumer()
 
 	})
 

pkg/encrypt/encrypt.go

 package encrypt
 
 import (
-	config "slg/conf"
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
 	"encoding/base64"
 	"golang.org/x/crypto/bcrypt"
+	config "slg/conf"
 )
 
 // 加密 aes_128_cbc

pkg/errno/errno.go

@@ -66,9 +66,10 @@ var (
 
 	PermissionDenied = &Errno{Code: 403, Message: "Permission Denied"}
 
-	// bank errors
-	ErrBankNotFound       = &Errno{Code: 20101, Message: "银行账号绑定未找到."}
-	ErrAddBank           = &Errno{Code: 20102, Message: "银行账号绑定失败."}
-	ErrUpdateBank         = &Errno{Code: 20103, Message: "银行账号更新失败."}
-	ErrDeleteBank         = &Errno{Code: 20104, Message: "银行账号删除失败."}
+	//Bonus errors
+	ErrBonusNotFound = &Errno{Code: 20101, Message: "佣金记录未找到."}
+	ErrAddBonus      = &Errno{Code: 20102, Message: "佣金添加失败."}
+	ErrUpdateBonus   = &Errno{Code: 20103, Message: "佣金更新失败."}
+	ErrDeleteBonus   = &Errno{Code: 20104, Message: "佣金删除失败."}
+	ErrCountBonus    = &Errno{Code: 20105, Message: "佣金统计失败."}
 )

pkg/file/file.go

-package file
-
-import (
-	"fmt"
-	"io/ioutil"
-	"mime/multipart"
-	"os"
-	"path"
-)
-
-// GetSize get the file size
-func GetSize(f multipart.File) (int, error) {
-	content, err := ioutil.ReadAll(f)
-
-	return len(content), err
-}
-
-// GetExt get the file ext
-func GetExt(fileName string) string {
-	return path.Ext(fileName)
-}
-
-// CheckNotExist check if the file exists
-func CheckNotExist(src string) bool {
-	_, err := os.Stat(src)
-
-	return os.IsNotExist(err)
-}
-
-// CheckPermission check if the file has permission
-func CheckPermission(src string) bool {
-	_, err := os.Stat(src)
-
-	return os.IsPermission(err)
-}
-
-// IsNotExistMkDir create a directory if it does not exist
-func IsNotExistMkDir(src string) error {
-	if notExist := CheckNotExist(src); notExist == true {
-		if err := MkDir(src); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// MkDir create a directory
-func MkDir(src string) error {
-	err := os.MkdirAll(src, os.ModePerm)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Open a file according to a specific mode
-func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
-	f, err := os.OpenFile(name, flag, perm)
-	if err != nil {
-		return nil, err
-	}
-
-	return f, nil
-}
-
-// MustOpen maximize trying to open the file
-func MustOpen(fileName, filePath string) (*os.File, error) {
-	dir, err := os.Getwd()
-	if err != nil {
-		return nil, fmt.Errorf("os.Getwd err: %v", err)
-	}
-
-	src := dir + "/" + filePath
-	perm := CheckPermission(src)
-	if perm == true {
-		return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
-	}
-
-	err = IsNotExistMkDir(src)
-	if err != nil {
-		return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
-	}
-
-	f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
-	if err != nil {
-		return nil, fmt.Errorf("Fail to OpenFile :%v", err)
-	}
-
-	return f, nil
-}
+package file
+
+import (
+	"fmt"
+	"io/ioutil"
+	"mime/multipart"
+	"os"
+	"path"
+)
+
+// GetSize get the file size
+func GetSize(f multipart.File) (int, error) {
+	content, err := ioutil.ReadAll(f)
+
+	return len(content), err
+}
+
+// GetExt get the file ext
+func GetExt(fileName string) string {
+	return path.Ext(fileName)
+}
+
+// CheckNotExist check if the file exists
+func CheckNotExist(src string) bool {
+	_, err := os.Stat(src)
+
+	return os.IsNotExist(err)
+}
+
+// CheckPermission check if the file has permission
+func CheckPermission(src string) bool {
+	_, err := os.Stat(src)
+
+	return os.IsPermission(err)
+}
+
+// IsNotExistMkDir create a directory if it does not exist
+func IsNotExistMkDir(src string) error {
+	if notExist := CheckNotExist(src); notExist == true {
+		if err := MkDir(src); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// MkDir create a directory
+func MkDir(src string) error {
+	err := os.MkdirAll(src, os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Open a file according to a specific mode
+func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
+	f, err := os.OpenFile(name, flag, perm)
+	if err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+// MustOpen maximize trying to open the file
+func MustOpen(fileName, filePath string) (*os.File, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("os.Getwd err: %v", err)
+	}
+
+	src := dir + "/" + filePath
+	perm := CheckPermission(src)
+	if perm == true {
+		return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
+	}
+
+	err = IsNotExistMkDir(src)
+	if err != nil {
+		return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
+	}
+
+	f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("Fail to OpenFile :%v", err)
+	}
+
+	return f, nil
+}

pkg/gredis/cache.go

 package gredis
 
 import (
-	"slg/pkg/util"
 	"github.com/gomodule/redigo/redis"
+	"slg/pkg/util"
 	"time"
 )
 

pkg/gredis/redis.go

 package gredis
 
 import (
-	"slg/pkg/setting"
 	"encoding/json"
 	"github.com/gomodule/redigo/redis"
+	"slg/pkg/setting"
 	"time"
 )
 

pkg/rabbitmq/rabbitmq.go

@@ -23,14 +23,14 @@ var AMQP *RabbitMQ
 
 func Setup() error {
 	AMQP = &RabbitMQ{
-		config:&Config{
+		config: &Config{
 			Host:     "139.9.150.174",
 			Port:     5672,
 			Username: "guest",
 			Password: "guest",
 			Vhost:    "/",
 		},
-		log:    logging.NewLogger("producer"),
+		log: logging.NewLogger("producer"),
 	}
 
 	return nil

pkg/setting/setting.go

@@ -47,12 +47,12 @@ type Server struct {
 var ServerSetting = &Server{}
 
 type Database struct {
-	Type         string
-	User         string
-	Password     string
-	Host         string
-	Name string
-	TablePrefix  string
+	Type        string
+	User        string
+	Password    string
+	Host        string
+	Name        string
+	TablePrefix string
 }
 
 var DatabaseSetting = &Database{}
@@ -86,7 +86,7 @@ func Setup() {
 		log.Fatalf("setting.Setup, fail to parse 'conf/h5.ini': %v", err)
 	}
 
-	mapTo("h5", AppSetting)
+	mapTo("app", AppSetting)
 	mapTo("server", ServerSetting)
 	mapTo("database", DatabaseSetting)
 	mapTo("redis", RedisSetting)

pkg/util/jwt.go

 package util
 
 import (
-	"slg/pkg/setting"
 	"github.com/dgrijalva/jwt-go"
+	"slg/pkg/setting"
 	"time"
 )
 
@@ -14,8 +14,8 @@ type Claims struct {
 }
 
 type UserInfo struct {
-	Uid        int    `json:"uid"`
-	Username   string `json:"username"`
+	Uid      int    `json:"uid"`
+	Username string `json:"username"`
 }
 
 func GenerateToken(username, password string) (string, error) {

pkg/util/md5.go

@@ -5,9 +5,9 @@ import (
 	"encoding/hex"
 )
 
-func EncodeMD5(value string) string{
-	m:= md5.New()
+func EncodeMD5(value string) string {
+	m := md5.New()
 	m.Write([]byte(value))
 
 	return hex.EncodeToString(m.Sum(nil))
-}
+}
\ No newline at end of file

routers/api/backend/bonus.go

+package backend
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
+	"slg/service/bonus_service"
+)
+
+func GetBonus(c *gin.Context) {
+	var oid string
+	if arg := c.Query("oid"); arg != "" {
+		oid = c.Query("oid")
+	}
+
+	var merchant_id string
+	if arg := c.Query("merchant_id"); arg != "" {
+		merchant_id = c.Query("merchant_id")
+	}
+
+	var status uint8
+	if arg := c.Query("status"); arg != "" {
+		status = uint8(util.ToUint32(c.Query("status")))
+	}
+	fmt.Println(merchant_id)
+	bonusService := bonus_service.BonusService{
+		Oid:        oid,
+		MerchantId: merchant_id,
+		Status:     status,
+		PageNum:    util.GetPage(c),
+		PageSize:   util.GetLimit(c),
+	}
+
+	count, err := bonusService.Count()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrCountBonus, nil)
+		return
+	}
+
+	bonus, err := bonusService.GetAll()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	data := make(map[string]interface{})
+	data["items"] = bonus
+	data["total"] = count
+
+	handler.SendResponse(c, nil, data)
+	return
+}

routers/h5/bonus.go

+package h5
+
+import (
+	"github.com/gin-gonic/gin"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
+	"slg/service/bonus_detail_service"
+	"slg/service/bonus_statistics_service"
+)
+
+func GetBonusStatistics(c *gin.Context) {
+	bonusStatisticsService := bonus_statistics_service.BonusStatisticsService{
+		Uid: "c420fb06d76b4fd09050579ab175cff0",
+	}
+
+	bonusStatistics, err := bonusStatisticsService.GetBonusStatistics()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, bonusStatistics)
+	return
+}
+
+func GetBonusDetailList(c *gin.Context) {
+	var uid = "c420fb06d76b4fd09050579ab175cff0"
+	var bonus_type = 1
+	bonusDetailService := bonus_detail_service.BonusDetailService{
+		Uid:       uid,
+		BonusType: uint8(bonus_type),
+
+		PageNum:  util.GetPage(c),
+		PageSize: util.GetLimit(c),
+	}
+
+	count, err := bonusDetailService.Count()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrCountBonus, nil)
+		return
+	}
+
+	bonusDetailList, err := bonusDetailService.GetBonusDetailList()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	data := make(map[string]interface{})
+	data["items"] = bonusDetailList
+	data["total"] = count
+
+	handler.SendResponse(c, nil, data)
+	return
+}

routers/router.go

@@ -2,8 +2,8 @@ package routers
 
 import (
 	"github.com/gin-gonic/gin"
-	"slg/middleware/jwt"
-	"slg/routers/api/h5"
+	"slg/routers/api/backend"
+	"slg/routers/h5"
 )
 
 func InitRouter() *gin.Engine {
@@ -12,16 +12,10 @@ func InitRouter() *gin.Engine {
 	r.Use(gin.Recovery())
 
 	client := r.Group("/h5")
-	client.GET("/banks", h5.GetBank)
-	client.POST("/add-bank", h5.AddBank)
-	client.PUT("/update-bank", h5.UpdateBank)
-	client.DELETE("/delete-bank", h5.DeleteBank)
+	client.GET("/bonus-statistics", h5.GetBonusStatistics)
+	client.GET("/bonus-detail-list", h5.GetBonusDetailList)
 
 	api := r.Group("/api")
-	api.Use(jwt.JWT())
-	{
-
-	}
-
+	api.GET("/bonus-list", backend.GetBonus)
 	return r
 }

service/bonus_detail_service/bonus_service.go

+package bonus_detail_service
+
+import (
+	"slg/models"
+	"slg/pkg/util"
+)
+
+type BonusDetailService struct {
+	Uid         string `json:"uid"`
+	BonusAmount string `json:"bonus_amount"`
+	BonusType   uint8  `json:"bonus_type"`
+	CreateTime  int64  `json:"create_time"`
+	UpdateTime  int64  `json:"update_time"`
+
+	PageNum  int
+	PageSize int
+}
+
+/**
+ * 获取符合条件的信息总数
+ * @params
+ * @return
+ */
+func (b *BonusDetailService) Count() (int, error) {
+	return models.GetBonusDetailCount(b.getBonusDetailCondition())
+}
+
+/**
+ * 获取符合条件的信息
+ * @param
+ * @return
+ */
+func (b *BonusDetailService) GetBonusDetailList() ([]*models.BonusDetailResp, error) {
+	var bonusDetailList []*models.BonusDetail
+
+	bonusDetailList, err := models.GetBonusDetailList(b.PageNum, b.PageSize, b.getBonusDetailCondition())
+	if err != nil {
+		return nil, err
+	}
+
+	var records = []*models.BonusDetailResp{}
+
+	for _, value := range bonusDetailList {
+		record := &models.BonusDetailResp{}
+		record.BonusAmount = value.BonusAmount
+		record.BonusType = value.BonusType
+		record.CreateTime = util.FormatUnix(value.CreateTime)
+
+		records = append(records, record)
+	}
+
+	return records, nil
+}
+
+func (b *BonusDetailService) getBonusDetailCondition() map[string]interface{} {
+	conditions := make(map[string]interface{})
+
+	if b.Uid != "" {
+		conditions["uid"] = b.Uid
+	}
+
+	return conditions
+}

service/bonus_service/bonus_service.go

+package bonus_service
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/shopspring/decimal"
+	"gopkg.in/yaml.v2"
+	"io/ioutil"
+	"log"
+	"slg/models"
+	"slg/module"
+	"slg/pkg/util"
+	"slg/service/order_info_service"
+	"slg/service/order_share_relation_service"
+	"slg/service/user_service"
+	"time"
+)
+
+type BonusService struct {
+	Oid                 string `json:"oid"`
+	MerchantId          string `json:"merchant_id"`
+	MerchantBonusAmount string `json:"merchant_bonus_amount"`
+	AuthorUid           string `json:"author_uid"`
+	AuthorBonusAmount   string `json:"author_bonus_amount"`
+	InviteUid           string `json:"invite_uid"`
+	InviteBonusAmount   string `json:"invite_bonus_amount"`
+	ShareUid            string `json:"share_uid"`
+	ShareBonusAmount    string `json:"share_bonus_amount"`
+	PlatformUid         string `json:"platform_uid"`
+	PlatformBonusAmount string `json:"platform_bonus_amount"`
+	Status              uint8  `json:"status"`
+	CreateTime          int64  `json:"create_time"`
+	UpdateTime          int64  `json:"update_time"`
+
+	PageNum  int
+	PageSize int
+}
+
+/**
+ * 获取符合条件的信息总数
+ * @params
+ * @return
+ */
+func (b *BonusService) Count() (int, error) {
+	return models.GetCount(b.getCondition())
+}
+
+/**
+ * 获取符合条件的信息
+ * @param
+ * @return
+ */
+func (b *BonusService) GetAll() ([]*models.Bonus, error) {
+	var bonus []*models.Bonus
+
+	bonus, err := models.GetBonus(b.PageNum, b.PageSize, b.getCondition())
+	if err != nil {
+		return nil, err
+	}
+
+	return bonus, nil
+}
+
+func (b *BonusService) getCondition() map[string]interface{} {
+	conditions := make(map[string]interface{})
+
+	if b.Status != 0 {
+		conditions["status"] = b.Status
+	}
+
+	if b.Oid != "" {
+		conditions["oid"] = b.Oid
+	}
+
+	if b.MerchantId != "" {
+		conditions["merchant_id"] = b.MerchantId
+	}
+
+	return conditions
+}
+
+/**
+ * 消费订单
+ * @return
+ */
+func (b *BonusService) SettlementBonus() error {
+	yamlFile, err := ioutil.ReadFile("conf/bonus.yaml")
+	if err != nil {
+		log.Printf("yamlFile.Get err #%v ", err)
+	}
+	conf := new(module.BonusConfig)
+	err = yaml.Unmarshal(yamlFile, conf)
+	if err != nil {
+		log.Fatalf("Unmarshal: %v", err)
+	}
+	_, err = json.Marshal(conf)
+	merchant := conf.Bonus.Levels["one"].Merchant
+	author := conf.Bonus.Levels["one"].Author
+	invite := conf.Bonus.Levels["one"].Invite
+	share := conf.Bonus.Levels["one"].Share
+	platform := conf.Bonus.Levels["one"].Platform
+
+	bonus_info, err := models.Exist(b.Oid)
+	if err != nil {
+		//消费失败 ack false
+		return nil
+	}
+	if len(bonus_info.Oid) > 0 {
+		//ack true
+		fmt.Println("订单已存在，ack true")
+		return err
+	}
+
+	orderInfoService := order_info_service.OrderInfoService{
+		Oid: b.Oid,
+	}
+
+	//获取订单总价、承兑商uid、用户uid
+	order_info, err := orderInfoService.GetOrderInfo()
+	if err != nil {
+		//消费失败 ack false
+		return err
+	}
+
+	//如果支付总金额小于1毛钱则不进行分成计划
+	if util.ToFloat64(order_info.Total) < 1 {
+		//ack true
+		return nil
+	}
+	total, _ := decimal.NewFromString(order_info.Total)
+
+	merchant_bonus_amount := total.Mul(decimal.NewFromFloat(merchant)).Round(2).String()
+	author_bonus_amount := total.Mul(decimal.NewFromFloat(author)).Round(2).String()
+	invite_bonus_amount := total.Mul(decimal.NewFromFloat(invite)).Round(2).String()
+	share_bonus_amount := total.Mul(decimal.NewFromFloat(share)).Round(2).String()
+	platform_bonus_amount := total.Mul(decimal.NewFromFloat(platform)).Round(2).String()
+
+	var merchant_uid, author_uid, invite_uid, share_uid, platform_uid string
+	merchant_uid = order_info.MerchantId
+	author_uid = conf.Bonus.AuthorUid
+	platform_uid = conf.Bonus.PlatformUid
+
+	//如果不存在作者，累加到商家收益
+	if author_uid == "" {
+		merchant_bonus_amount_tmp, _ := decimal.NewFromString(merchant_bonus_amount)
+		author_bonus_amount_tmp, _ := decimal.NewFromString(author_bonus_amount)
+		merchant_bonus_amount = merchant_bonus_amount_tmp.Add(author_bonus_amount_tmp).Round(2).String()
+		author_bonus_amount = "0.00"
+	}
+
+	//通过用户uid获取用户注册码 => 通过用户注册码获取邀请人
+	userInfoService := user_service.UserService{}
+	userInfoService = user_service.UserService{
+		Uid: order_info.Uid,
+	}
+	user_info, err := userInfoService.GetUserInfo()
+	if err != nil {
+		//消费失败 ack false
+		return nil
+	}
+
+	if len(user_info.RegisterCode) > 1 {
+		userInfoService = user_service.UserService{
+			InviteCode: user_info.RegisterCode,
+		}
+		invite_user_info, err := userInfoService.GetUserInfo()
+		if err != nil {
+			return nil
+		}
+		invite_uid = invite_user_info.Uid
+	}
+
+	//如果不存在邀请注册，累加到平台佣金
+	if invite_uid == "" {
+		platform_bonus_amount_tmp, _ := decimal.NewFromString(platform_bonus_amount)
+		invite_bonus_amount_tmp, _ := decimal.NewFromString(invite_bonus_amount)
+		platform_bonus_amount = platform_bonus_amount_tmp.Add(invite_bonus_amount_tmp).Round(2).String()
+		invite_bonus_amount = "0.00"
+	}
+
+	//通过订单id获取推广分销信息 => 或者推广分销用户
+	orderShareRelationService := order_share_relation_service.OrderShareRelationService{
+		Oid: b.Oid,
+	}
+	order_share_realtion, err := orderShareRelationService.GetOrderShareRelation()
+	if err != nil {
+		return nil
+	}
+	if len(order_share_realtion.ShareUid) > 1 {
+		userInfoService = user_service.UserService{
+			Uid: order_share_realtion.ShareUid,
+		}
+		share_user_info, err := userInfoService.GetUserInfo()
+		if err != nil {
+			return nil
+		}
+		share_uid = share_user_info.Uid
+	}
+
+	//如果不存在推广分销，累加到平台佣金
+	if share_uid == "" {
+		platform_bonus_amount_tmp, _ := decimal.NewFromString(platform_bonus_amount)
+		share_bonus_amount_tmp, _ := decimal.NewFromString(share_bonus_amount)
+		platform_bonus_amount = platform_bonus_amount_tmp.Add(share_bonus_amount_tmp).Round(2).String()
+		share_bonus_amount = "0.00"
+	}
+
+	//构建分成记录
+	bonus := map[string]interface{}{
+		"oid":                   b.Oid,
+		"create_time":           time.Now().UTC().Unix(),
+		"update_time":           time.Now().UTC().Unix(),
+		"merchant_id":           merchant_uid,
+		"merchant_bonus_amount": merchant_bonus_amount,
+		"author_uid":            author_uid,
+		"author_bonus_amount":   author_bonus_amount,
+		"invite_uid":            invite_uid,
+		"invite_bonus_amount":   invite_bonus_amount,
+		"share_uid":             share_uid,
+		"share_bonus_amount":    share_bonus_amount,
+		"platform_uid":          platform_uid,
+		"platform_bonus_amount": platform_bonus_amount,
+	}
+
+	tmp, _ := json.Marshal(bonus)
+	fmt.Println(string(tmp))
+
+	if err := models.AddBonus(bonus); err != nil {
+		return err
+	}
+
+	return nil
+}

service/bonus_statistics_service/bonus_service.go

+package bonus_statistics_service
+
+import (
+	"github.com/jinzhu/gorm"
+	"github.com/shopspring/decimal"
+	"slg/models"
+)
+
+type BonusStatisticsService struct {
+	Uid               string `json:"uid"`
+	InviteBonusAmount string `json:"invite_bonus_amount"`
+	ShareBonusAmount  string `json:"share_bonus_amount"`
+	CreateTime        int64  `json:"create_time"`
+	UpdateTime        int64  `json:"update_time"`
+}
+
+func (b *BonusStatisticsService) GetBonusStatistics() (*models.BonusStatisticsResp, error) {
+	bonusStatistics, err := models.GetBonusStatistics(b.Uid)
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	var record = models.BonusStatisticsResp{}
+	record.InviteBonusAmount = bonusStatistics.InviteBonusAmount
+	record.ShareBonusAmount = bonusStatistics.ShareBonusAmount
+
+	invite_bonus_amount_tmp, _ := decimal.NewFromString(bonusStatistics.InviteBonusAmount)
+	share_bonus_amount_tmp, _ := decimal.NewFromString(bonusStatistics.ShareBonusAmount)
+	record.BonusAmount = invite_bonus_amount_tmp.Add(share_bonus_amount_tmp).Round(2).String()
+
+	return &record, nil
+}

service/order_info_service/order_info_service.go

+package order_info_service
+
+import (
+	"github.com/jinzhu/gorm"
+	"slg/models"
+)
+
+type OrderInfoService struct {
+	Id                   uint64
+	Oid                  string
+	Uid                  string
+	PayId                uint8
+	MerchantId           string
+	PostFee              string
+	Total                string
+	AcceptDigital        uint8
+	PayType              uint8
+	OrderType            uint8
+	OrderState           uint8
+	Delivery             uint8
+	Uname                string
+	Phone                string
+	Address              string
+	IsDelete             uint8
+	VNote                string
+	ConsultDiscounAmount string
+	ConsultDiscountType  uint8
+	DiscountAmount       string
+	Amount               string
+	CreateTime           uint64
+	UpdateTime           uint64
+	CommentTotal         uint64
+	CommentAlready       uint64
+	Coin                 string
+	IntegralDeduction    string
+	IntegralPrice        string
+	OrderIdent           uint8
+}
+
+func (o *OrderInfoService) GetOrderInfo() (*models.OrderInfo, error) {
+	orderInfo, err := models.GetOrderInfo(o.Oid)
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return orderInfo, nil
+}

service/order_share_relation_service/order_share_relation_service.go

+package order_share_relation_service
+
+import (
+	"encoding/json"
+	"slg/models"
+)
+
+type OrderShareRelationService struct {
+	Id         int
+	ShareUid   string
+	InvitedUid string
+	Oid        string
+	Oids       json.RawMessage
+}
+
+func (o *OrderShareRelationService) GetOrderShareRelation() (*models.OrderShareRelation, error) {
+	orderShareRelationInfo, err := models.GetOrderShareRelation(o.Oid)
+	if err != nil {
+		return nil, err
+	}
+
+	return orderShareRelationInfo, nil
+}

service/rabbitmq_service/rabbitmq_service.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"github.com/streadway/amqp"
 	"slg/pkg/rabbitmq"
+	"slg/service/bonus_service"
 )
 
 type AmqpConsumer struct {
@@ -32,7 +33,6 @@ func (a AmqpConsumer) Consumer() {
 		Tag: a.Tag,
 	}
 
-
 	consumer, err := rabbitmq.AMQP.NewConsumer(exchange, queue, binding, consumerOptions)
 	if err != nil {
 		return
@@ -51,5 +51,12 @@ var handler = func(delivery amqp.Delivery) {
 	message := string(delivery.Body)
 	fmt.Println("消费------------------------：", message)
 
+	bonusService := bonus_service.BonusService{
+		Oid: message,
+	}
+	err := bonusService.SettlementBonus()
+	if err != nil {
+		delivery.Ack(false)
+	}
 	delivery.Ack(true)
 }

service/user_service/user_service.go

+package user_service
+
+import (
+	"slg/models"
+)
+
+type UserService struct {
+	Id           uint64 `json:"id"`
+	Uid          string `json:"uid"`
+	InviteCode   string `json:"invite_code"`
+	RegisterCode string `json:"register_code"`
+}
+
+func (u UserService) GetUserInfo() (*models.User, error) {
+	var user *models.User
+
+	user, err := models.GetUserInfo(u.getCondition())
+	if err != nil {
+		return nil, err
+	}
+
+	return user, nil
+}
+
+func (u *UserService) getCondition() map[string]interface{} {
+	conditions := make(map[string]interface{})
+
+	if u.Id != 0 {
+		conditions["id"] = u.Id
+	}
+
+	if u.Uid != "" {
+		conditions["uid"] = u.Uid
+	}
+
+	if u.InviteCode != "" {
+		conditions["invite_code"] = u.InviteCode
+	}
+
+	if u.RegisterCode != "" {
+		conditions["register_code"] = u.RegisterCode
+	}
+	return conditions
+}

validate_service/bank.go

 package validate_service
 
 type Bank struct {
-	BankName      string `json:"name" validate:"required"`
+	BankName string `json:"name" validate:"required"`
 }

validate_service/validate.go

@@ -56,4 +56,3 @@ func ValidateInputs(dataSet interface{}) (bool, map[string][]string) {
 	}
 	return true, nil
 }
-