add white list

cachedata/cache.go

@@ -19,6 +19,7 @@ type CacheData struct {
 	userRepo        model.UserRepository
 	userLevel       model.UserLevelRepository
 	userAndTaskRepo model.UserLevelTaskTypeRepository
+	whiteList       model.WhiteListRepository
 }
 
 type RedisConnParam struct {
@@ -46,6 +47,7 @@ func NewCacheData(ctx context.Context, options RedisConnParam, mysqlConfig model
 		userRepo:        model.NewUserRepository(),
 		userLevel:       model.NewUserLevelRepository(),
 		userAndTaskRepo: model.NewUserLevelTaskTypeRepository(),
+		whiteList:       model.NewWhiteListRepository(),
 	}
 	cache.ctx, cache.cancel = context.WithCancel(ctx)
 	for i := 0; i < cache.maxRoutine; i++ {

cachedata/whitelist.go

+package cachedata
+
+import (
+	"encoding/json"
+	"github.com/odysseus/cache/model"
+	"strings"
+)
+
+func (c *CacheData) getWhFromRedis(whKey string) (*model.Whitelist, error) {
+	if data, err := c.rdb.Get(c.ctx, whKey).Result(); err == nil {
+		var wh = new(model.Whitelist)
+		if err = json.Unmarshal([]byte(data), wh); err == nil {
+			return wh, nil
+		}
+		return nil, err
+	} else {
+		return nil, err
+	}
+}
+
+func (c *CacheData) getWhFromDbByAddr(addr string) (*model.Whitelist, error) {
+	return c.whiteList.GetByCharacter(addr)
+}
+
+func (c *CacheData) GetWhWithAddr(addr string) (*model.Whitelist, error) {
+	whKey := "wh-a-" + strings.ToLower(addr)
+	// get wh from redis by key.
+	if wh, err := c.getWhFromRedis(whKey); err == nil {
+		return wh, nil
+	}
+	// get task from db by id and then set task to redis.
+	if wh, err := c.getWhFromDbByAddr(addr); err == nil {
+		// set task to redis
+		if data, err := json.Marshal(wh); err == nil {
+			if err = c.rdb.Set(c.ctx, whKey, string(data), 0).Err(); err == nil {
+				return wh, nil
+			} else {
+				return nil, err
+			}
+		} else {
+			return nil, err
+		}
+	} else {
+		return nil, err
+	}
+}
+
+func (c *CacheData) SetWhiteListToRedis(wh *model.Whitelist) error {
+	whKey := "wh-a-" + strings.ToLower(wh.Character)
+	if data, err := json.Marshal(wh); err == nil {
+		if err = c.rdb.Set(c.ctx, whKey, string(data), 0).Err(); err == nil {
+			return nil
+		}
+		return err
+	} else {
+		return err
+	}
+}

model/whiteList.go

+package model
+
+import (
+	"github.com/astaxie/beego/orm"
+	"time"
+)
+
+type Whitelist struct {
+	ID          int64     `orm:"column(id)" db:"id" json:"id" form:"id"`
+	Character   string    `orm:"column(character)" db:"character" json:"character" form:"character"`
+	NodeNum     int64     `orm:"column(node_num)" db:"node_num" json:"node_num" form:"node_num"`
+	CreatedTime time.Time `orm:"column(created_time)" db:"created_time" json:"created_time" form:"created_time"`
+	UpdatedTime time.Time `orm:"column(updated_time)" db:"updated_time" json:"updated_time" form:"updated_time"`
+	Deleted     int64     `orm:"column(deleted)" db:"deleted" json:"deleted" form:"deleted"`
+}
+
+func (Whitelist) TableName() string {
+	return "whitelist"
+}
+
+type WhiteListRepository interface {
+	Create(wh *Whitelist) error
+	GetByCharacter(addr string) (*Whitelist, error)
+	GetListByFilter(filters ...interface{}) []*Whitelist
+	Update(wh *Whitelist) error
+	Delete(wh *Whitelist) error
+}
+
+type whiteListRepositoryImpl struct {
+	o orm.Ormer
+}
+
+func NewWhiteListRepository() WhiteListRepository {
+	o := orm.NewOrm()
+	return &whiteListRepositoryImpl{o}
+}
+
+func (repo *whiteListRepositoryImpl) Create(wh *Whitelist) error {
+	_, err := repo.o.Insert(wh)
+	return err
+}
+
+func (repo *whiteListRepositoryImpl) GetListByFilter(filters ...interface{}) []*Whitelist {
+	list := make([]*Whitelist, 0)
+	query := orm.NewOrm().QueryTable(new(Whitelist).TableName())
+	if len(filters) > 0 {
+		l := len(filters)
+		for k := 0; k < l; k += 2 {
+			query = query.Filter(filters[k].(string), filters[k+1])
+		}
+	}
+	query.OrderBy("-id").All(&list)
+	return list
+}
+
+//// return balance, charge, credits and error.
+//func (repo *userRepositoryImpl) GetPayInfoById(uid int64) (int64, int64, int64, error) {
+//
+//}
+
+func (repo *whiteListRepositoryImpl) GetByCharacter(addr string) (*Whitelist, error) {
+	wh := Whitelist{Character: addr}
+	err := repo.o.Read(&wh, "character")
+	if err != nil {
+		return nil, err
+	}
+	return &wh, nil
+}
+
+func (repo *whiteListRepositoryImpl) Update(wh *Whitelist) error {
+	_, err := repo.o.Update(wh)
+	return err
+}
+
+func (repo *whiteListRepositoryImpl) Delete(wh *Whitelist) error {
+	_, err := repo.o.Delete(wh)
+	return err
+}