Create & Init Project...

app/admin/main/creative/service/BUILD

@@ -0,0 +1,76 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "service_test.go",
+        "upbfs_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/creative/conf:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "academy.go",
+        "log.go",
+        "material.go",
+        "music.go",
+        "service.go",
+        "task.go",
+        "upbfs.go",
+        "whitelist.go",
+    ],
+    importpath = "go-common/app/admin/main/creative/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/creative/conf:go_default_library",
+        "//app/admin/main/creative/dao:go_default_library",
+        "//app/admin/main/creative/model/academy:go_default_library",
+        "//app/admin/main/creative/model/bfs:go_default_library",
+        "//app/admin/main/creative/model/logcli:go_default_library",
+        "//app/admin/main/creative/model/material:go_default_library",
+        "//app/admin/main/creative/model/music:go_default_library",
+        "//app/admin/main/creative/model/task:go_default_library",
+        "//app/admin/main/creative/model/whitelist:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/conf/env:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/queue/databus/report:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/golang.org/x/sync/errgroup:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/creative/service/academy.go

@@ -0,0 +1,292 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/creative/model/academy"
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/app/service/main/archive/api"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+//Archive get one archive by rpc
+func (s *Service) Archive(c context.Context, aid int64) (res *api.Arc, err error) {
+	if res, err = s.dao.Archive(c, aid); err != nil {
+		log.Error("s.dao.Archive aid(%d)|err(%+v)", aid, err)
+	}
+	return
+}
+
+//Archives get archives by rpc
+func (s *Service) Archives(c context.Context, aids []int64) (res map[int64]*api.Arc, err error) {
+	if res, err = s.dao.Archives(c, aids); err != nil {
+		log.Error("s.dao.Archives aids(%d)|err(%+v)", aids, err)
+	}
+	return
+}
+
+//Articles get articles by rpc
+func (s *Service) Articles(c context.Context, aids []int64) (res map[int64]*model.Meta, err error) {
+	if res, err = s.dao.ArticleMetas(c, aids); err != nil {
+		log.Error("s.dao.ArticleMetas aids(%+v)|err(%+v)", aids, err)
+	}
+	return
+}
+
+//ArchivesWithES for es search
+func (s *Service) ArchivesWithES(c context.Context, aca *academy.EsParam) (res *academy.SearchResult, err error) {
+	if res, err = s.dao.ArchivesWithES(c, aca); err != nil {
+		log.Error("s.dao.ArchivesWithES aca(%+v)|err(%+v)", aca, err)
+	}
+	return
+}
+
+// Stats get archives stat.
+func (s *Service) Stats(c context.Context, aids []int64, ip string) (res map[int64]*api.Stat, err error) {
+	if res, err = s.dao.Stats(c, aids, ip); err != nil {
+		log.Error("s.dao.Archives aids(%d)|ip(%s)|err(%+v)", aids, ip, err)
+	}
+	return
+}
+
+//SearchKeywords for list search keywords.
+func (s *Service) SearchKeywords() (res []interface{}, err error) {
+	var sks []*academy.SearchKeywords
+	if err = s.DB.Where("state=0").Order("rank ASC").Find(&sks).Error; err != nil {
+		log.Error("SearchKeywords error(%v)", err)
+		return
+	}
+	if len(sks) == 0 {
+		return
+	}
+
+	res = s.trees(sks, "ID", "ParentID", "Children")
+	return
+}
+
+//trees for generate tree data set
+// data - orm result set
+// idFieldStr - primary key in table map to struct
+// pidFieldStr - top parent id in table map to struct
+// chFieldStr - struct child nodes
+
+func (s *Service) trees(data interface{}, idFieldStr, pidFieldStr, chFieldStr string) (res []interface{}) {
+	if reflect.TypeOf(data).Kind() != reflect.Slice {
+		return
+	}
+
+	sli := reflect.ValueOf(data)
+	top := make(map[int64]interface{})
+	res = make([]interface{}, 0, sli.Len())
+	for i := 0; i < sli.Len(); i++ {
+		v := sli.Index(i).Interface()
+		if reflect.TypeOf(v).Kind() != reflect.Ptr {
+			continue
+		}
+
+		if reflect.ValueOf(v).IsNil() {
+			continue
+		}
+
+		getValue := reflect.ValueOf(v).Elem()
+		getType := reflect.TypeOf(v).Elem()
+		pid := getValue.FieldByName(pidFieldStr).Interface().(int64)
+		if _, ok := getType.FieldByName(pidFieldStr); ok && pid == 0 {
+			id := getValue.FieldByName(idFieldStr).Interface().(int64)
+			top[id] = v
+			res = append(res, v)
+		}
+	}
+
+	for i := 0; i < sli.Len(); i++ {
+		v := sli.Index(i).Interface()
+		if reflect.TypeOf(v).Kind() != reflect.Ptr {
+			continue
+		}
+
+		if reflect.ValueOf(v).IsNil() {
+			continue
+		}
+
+		pid := reflect.ValueOf(v).Elem().FieldByName(pidFieldStr).Interface().(int64)
+		if pid == 0 {
+			continue
+		}
+
+		if p, ok := top[pid]; ok {
+			ch := reflect.ValueOf(p).Elem().FieldByName(chFieldStr)
+			ch.Set(reflect.Append(ch, reflect.ValueOf(v)))
+		}
+	}
+	return
+}
+
+//SubSearchKeywords for add search keywords.
+func (s *Service) SubSearchKeywords(vs []*academy.SearchKeywords) (err error) {
+	if len(vs) == 0 {
+		return
+	}
+
+	origins := []*academy.SearchKeywords{}
+	if err = s.DB.Model(&academy.SearchKeywords{}).Find(&origins).Error; err != nil {
+		log.Error("SubSearchKeywords Find error(%v)", err)
+		return
+	}
+
+	originMap := make(map[int64]*academy.SearchKeywords)
+	for _, v := range origins {
+		originMap[v.ID] = v
+	}
+
+	newParents := make([]*academy.SearchKeywords, 0)
+	oldParents := make([]*academy.SearchKeywords, 0)
+	children := make([]*academy.SearchKeywords, 0)
+	newChildren := make([]*academy.SearchKeywords, 0)
+	oldChildren := make([]*academy.SearchKeywords, 0)
+	now := time.Now().Format("2006-01-02 15:04:05")
+	for _, v := range vs {
+		if v == nil {
+			continue
+		}
+		v.Name = strings.TrimSpace(v.Name)              //删除字符串前后空格
+		if vv, ok := originMap[v.ID]; ok && vv != nil { //父节点为老的
+			v.CTime = vv.CTime
+			v.MTime = now
+			oldParents = append(oldParents, v)
+			if len(v.Children) > 0 {
+				for _, vvv := range v.Children {
+					vvv.ParentID = vv.ID //追加父节点ID
+					vvv.CTime = now
+					vvv.MTime = now
+					children = append(children, vvv) //新老子节点同时存在
+				}
+			}
+		} else {
+			v.CTime = now
+			v.MTime = now
+			newParents = append(newParents, v)
+		}
+	}
+	oldParents = append(oldParents, newParents...)
+
+	tx := s.DB
+	if len(oldParents) > 0 {
+		if err = s.insertKeyWords(tx, oldParents); err != nil {
+			return
+		}
+	}
+
+	newParentsNames := make([]string, 0)
+	for _, v := range newParents {
+		newParentsNames = append(newParentsNames, v.Name)
+	}
+
+	var pidMap map[string]*academy.SearchKeywords
+	if len(newParentsNames) > 0 {
+		if pidMap, err = s.upRanks(tx, newParentsNames); err != nil {
+			return
+		}
+	}
+
+	newChildrenNames := make([]string, 0)
+	for _, v := range newParents { //父节点为新的
+		if v == nil {
+			continue
+		}
+		if vv, ok := pidMap[v.Name]; ok && vv != nil {
+			if len(v.Children) > 0 {
+				for _, vvv := range v.Children {
+					vvv.ParentID = vv.ID //追加父节点ID
+					vvv.CTime = now
+					vvv.MTime = now
+					newChildren = append(newChildren, vvv)
+					newChildrenNames = append(newChildrenNames, vvv.Name)
+				}
+			}
+		}
+	}
+
+	for _, v := range children {
+		if v == nil {
+			continue
+		}
+		if vv, ok := originMap[v.ID]; ok && vv != nil {
+			v.CTime = vv.CTime
+			v.MTime = now
+			oldChildren = append(oldChildren, v)
+		} else {
+			v.CTime = now
+			v.MTime = now
+			newChildren = append(newChildren, v)
+			newChildrenNames = append(newChildrenNames, v.Name)
+		}
+	}
+	oldChildren = append(oldChildren, newChildren...)
+
+	if len(oldChildren) > 0 {
+		if err = s.insertKeyWords(tx, oldChildren); err != nil {
+			return
+		}
+	}
+
+	if len(newChildrenNames) > 0 {
+		if _, err = s.upRanks(tx, newChildrenNames); err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (s *Service) insertKeyWords(tx *gorm.DB, vs []*academy.SearchKeywords) (err error) {
+	if len(vs) == 0 {
+		return
+	}
+	valSearks := make([]string, 0, len(vs))
+	valSearksArgs := make([]interface{}, 0)
+	for _, v := range vs {
+		valSearks = append(valSearks, "(?, ?, ?, ?, ?, ?, ?, ?)")
+		valSearksArgs = append(valSearksArgs, v.ID, v.Rank, v.ParentID, v.State, v.Name, v.Comment, v.CTime, v.MTime)
+	}
+	sqlStr := fmt.Sprintf("INSERT INTO academy_search_keywords (id, rank, parent_id, state, name, comment, ctime, mtime) VALUES %s "+
+		"ON DUPLICATE KEY UPDATE id=VALUES(id), rank=VALUES(rank), parent_id=VALUES(parent_id), state=VALUES(state), name=VALUES(name), comment=VALUES(comment), ctime=VALUES(ctime), mtime=VALUES(mtime)", strings.Join(valSearks, ","))
+	if err = tx.Exec(sqlStr, valSearksArgs...).Error; err != nil {
+		log.Error("insertKeyWords error(%v)", err)
+	}
+	return
+}
+
+func (s *Service) upRanks(tx *gorm.DB, names []string) (pidMap map[string]*academy.SearchKeywords, err error) {
+	if len(names) == 0 {
+		return
+	}
+
+	setRanks := []*academy.SearchKeywords{}
+	if err = s.DB.Model(&academy.SearchKeywords{}).Where("name IN(?)", names).Find(&setRanks).Error; err != nil {
+		log.Error("upRanks Find error(%v)", err)
+		return
+	}
+
+	upRankSQL := "UPDATE academy_search_keywords SET rank = CASE id "
+	ids := make([]int64, 0)
+	pidMap = make(map[string]*academy.SearchKeywords)
+	for _, v := range setRanks {
+		upRankSQL += fmt.Sprintf("WHEN %d THEN %d ", v.ID, v.ID)
+		ids = append(ids, v.ID)
+		pidMap[v.Name] = v
+	}
+
+	if len(ids) == 0 {
+		return
+	}
+	upRankSQL += "END WHERE id IN (?)"
+	if err = tx.Exec(upRankSQL, ids).Error; err != nil {
+		log.Error("upRanks update rank ids(%+v) error(%v)", ids, err)
+	}
+	return
+}

app/admin/main/creative/service/log.go

@@ -0,0 +1,80 @@
+package service
+
+import (
+	"time"
+
+	"go-common/app/admin/main/creative/model/academy"
+	"go-common/app/admin/main/creative/model/logcli"
+	"go-common/app/admin/main/creative/model/music"
+	"go-common/app/admin/main/creative/model/task"
+	"go-common/library/conf/env"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/queue/databus/report"
+)
+
+// SendAcademyLog academy log to manager.
+func (s *Service) SendAcademyLog(c *bm.Context, lp *academy.LogParam) (err error) {
+	if env.DeployEnv == env.DeployEnvDev {
+		return
+	}
+	logData := &report.ManagerInfo{
+		Business: academy.LogClientAcademy,
+		Type:     0,
+		Uname:    lp.UName,
+		UID:      lp.UID,
+		Oid:      lp.TID,
+		Action:   lp.Action,
+		Ctime:    time.Now(),
+		Index:    []interface{}{lp.TID},
+		Content: map[string]interface{}{
+			"academy_manager": lp,
+		},
+	}
+	log.Info("s.SendAcademyLog logData(%+v) log param(%+v)", logData, lp)
+	report.Manager(logData)
+	return
+}
+
+// SendMusicLog send to log archive music
+func (s *Service) SendMusicLog(c *bm.Context, clientType int, ap *music.LogParam) (err error) {
+	logData := &report.ManagerInfo{
+		Uname:    ap.UName,
+		UID:      ap.UID,
+		Business: logcli.LogClientArchiveMusic,
+		Type:     clientType,
+		Oid:      ap.ID,
+		Action:   ap.Action,
+		Ctime:    time.Now(),
+		Index:    []interface{}{ap.ID},
+		Content: map[string]interface{}{
+			"object": ap,
+		},
+	}
+	log.Info("sendMusicLog logData(%+v) ap(%+v)", logData, ap)
+	report.Manager(logData)
+	return
+}
+
+// SendTaskLog task log to manager.
+func (s *Service) SendTaskLog(c *bm.Context, lp *task.LogParam) (err error) {
+	if env.DeployEnv == env.DeployEnvDev {
+		return
+	}
+	logData := &report.ManagerInfo{
+		Business: task.LogClientTask,
+		Type:     0,
+		Uname:    lp.UName,
+		UID:      lp.UID,
+		Oid:      lp.OID,
+		Action:   lp.Action,
+		Ctime:    time.Now(),
+		Index:    []interface{}{lp.OID},
+		Content: map[string]interface{}{
+			"params": lp.Content,
+		},
+	}
+	log.Info("s.SendTaskLog logData(%+v) log param(%+v)", logData, lp)
+	report.Manager(logData)
+	return
+}

app/admin/main/creative/service/material.go

@@ -0,0 +1,16 @@
+package service
+
+import (
+	"context"
+	"go-common/app/admin/main/creative/model/material"
+)
+
+// CategoryByID .
+func (s *Service) CategoryByID(c context.Context, id int64) (cate *material.Category, err error) {
+	return s.dao.CategoryByID(c, id)
+}
+
+// BindWithCategory .
+func (s *Service) BindWithCategory(c context.Context, MaterialID, CategoryID, index int64) (id int64, err error) {
+	return s.dao.BindWithCategory(c, MaterialID, CategoryID, index)
+}

app/admin/main/creative/service/music.go

@@ -0,0 +1,67 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/admin/main/creative/model/logcli"
+	"go-common/app/admin/main/creative/model/music"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+//SendNotify .
+func (s *Service) SendNotify(c *bm.Context, sendIds []int64, data map[int64]*music.SidNotify) (err error) {
+	var (
+		//mid首次收录
+		content = "您的音频稿件（au:%d）已被手机投稿BGM库收录，快加入素材激励计划(#{APP申请入口}{\"https://member.bilibili.com/studio/up-allowance-h5#\"},#{WEB申请入口}{\"https://member.bilibili.com/v/#/allowance\"})获取收益吧！被收录稿件名：《%s》"
+		//sid首次收录
+		content2 = "您的音频稿件【《%s》（au:%d）】已被手机投稿BGM库收录，期待您创作更多优秀的新作品哦"
+		title    = "创作激励计划素材收录通知"
+	)
+	for _, sid := range sendIds {
+		if _, ok := data[sid]; !ok {
+			continue
+		}
+		sendConfig := data[sid]
+		log.Info("svc.SendNotify param sendConfig(%+v) ", sendConfig)
+		var (
+			mids        []int64
+			first, send bool
+			sendContent string
+		)
+		//check exists
+		exists := music.Music{}
+		if err = s.DBArchive.Model(&music.Music{}).Where("sid=?", sid).First(&exists).Error; err != nil {
+			continue
+		}
+		//每个mid 第一次收录 优先级最高
+		if sendConfig.MidFirst {
+			first = true
+			send = true
+		}
+		if !sendConfig.MidFirst && sendConfig.SidFirst {
+			first = false
+			send = true
+		}
+		if !first {
+			content = content2
+			sendContent = fmt.Sprintf(content, exists.Name, exists.Sid)
+		} else {
+			sendContent = fmt.Sprintf(content, exists.Sid, exists.Name)
+		}
+		if !send {
+			return
+		}
+		mids = []int64{exists.Mid}
+
+		s.addAsyn(func() {
+			if err = s.dao.MutliSendSysMsg(context.TODO(), mids, title, sendContent); err != nil {
+				log.Error("s.d.MutliSendSysMsg(%s,%s,%s) error(%+v)", xstr.JoinInts(mids), title, sendContent, err)
+				return
+			}
+		})
+		s.SendMusicLog(c, logcli.LogClientArchiveMusicTypeCategoryRelation, &music.LogParam{ID: sid, UID: 0, UName: fmt.Sprintf("mid(%d)", exists.Mid), Action: "SendNotify", Name: sendContent})
+	}
+	return
+}

app/admin/main/creative/service/service.go

@@ -0,0 +1,73 @@
+package service
+
+import (
+	"context"
+	"sync"
+
+	"go-common/app/admin/main/creative/conf"
+	"go-common/app/admin/main/creative/dao"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Service str
+type Service struct {
+	conf      *conf.Config
+	dao       *dao.Dao
+	DB        *gorm.DB
+	DBArchive *gorm.DB
+	wg        sync.WaitGroup
+	asynch    chan func()
+	closed    bool
+}
+
+// New fn
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		conf:   c,
+		dao:    dao.New(c),
+		asynch: make(chan func(), 10240),
+	}
+
+	s.DB = s.dao.DB
+	s.DBArchive = s.dao.DBArchive
+	s.wg.Add(1)
+	go s.asynproc()
+	return
+}
+
+// Ping fn
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+func (s *Service) addAsyn(f func()) {
+	select {
+	case s.asynch <- f:
+	default:
+		log.Warn("asynproc chan full")
+	}
+}
+
+// cacheproc is a routine for executing closure.
+func (s *Service) asynproc() {
+	defer s.wg.Done()
+	for {
+		if s.closed {
+			return
+		}
+		f, ok := <-s.asynch
+		if !ok {
+			return
+		}
+		f()
+	}
+}
+
+// Close dao
+func (s *Service) Close() {
+	s.dao.Close()
+	s.closed = true
+	s.wg.Wait()
+}

app/admin/main/creative/service/service_test.go

@@ -0,0 +1,53 @@
+package service
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/creative/conf"
+	accapi "go-common/app/service/main/account/api"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/creative-admin.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	s = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		Reset(func() {})
+		f(s)
+	}
+}
+
+func Test_Profile(t *testing.T) {
+	mid := int64(27515256)
+	Convey("Profile", t, WithService(func(s *Service) {
+		var (
+			pfl *accapi.ProfileStatReply
+			err error
+		)
+		pfl, err = s.ProfileStat(context.TODO(), mid)
+		time.Sleep(time.Millisecond * 100)
+		So(err, ShouldBeNil)
+		So(pfl, ShouldNotBeNil)
+	}))
+}
+
+func Test_SearchKeywords(t *testing.T) {
+	Convey("SearchKeywords", t, WithService(func(s *Service) {
+		s.SearchKeywords()
+	}))
+}

app/admin/main/creative/service/task.go

@@ -0,0 +1,924 @@
+package service
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/creative/model/task"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+//TaskGroupRewards for task group & rewards.
+func (s *Service) TaskGroupRewards(ids []int64) (res map[int64][]*task.TaskGroupReward, err error) {
+	tgrs := []*task.TaskGroupReward{}
+	if err = s.DB.Model(&task.TaskGroupReward{}).Where("task_group_id IN (?)", ids).Where("state>=0").Find(&tgrs).Error; err != nil {
+		log.Error("s.TaskGroupRewards ids(%+v) error(%v)", ids, err)
+	}
+	if len(tgrs) == 0 {
+		return
+	}
+
+	res = make(map[int64][]*task.TaskGroupReward)
+	for _, v := range tgrs {
+		if v != nil {
+			res[v.TaskGroupID] = append(res[v.TaskGroupID], v)
+		}
+	}
+	return
+}
+
+func (s *Service) getRewards(rids []int64) (res []*task.RewardResult) {
+	_, rewardMap := s.loadRewards()
+	if len(rids) == 0 || len(rewardMap) == 0 {
+		return
+	}
+
+	sort.Slice(rids, func(i, j int) bool {
+		return rids[i] < rids[j]
+	})
+	res = make([]*task.RewardResult, 0, len(rids))
+	for _, rid := range rids {
+		if v, ok := rewardMap[rid]; ok {
+			res = append(res, &task.RewardResult{
+				RewardID:   v.ID,
+				RewardName: v.Name,
+			})
+		}
+	}
+	return
+}
+
+//AddTaskGroup for add task group.
+func (s *Service) AddTaskGroup(v *task.TaskGroup, rewardsIDs []int64) (id int64, err error) {
+	now := time.Now().Format("2006-01-02 15:04:05")
+	v.CTime = now
+	tx := s.DB.Begin()
+	v.State = task.StateHide
+	if err = tx.Create(v).Error; err != nil {
+		log.Error("addGroup error(%v)", err)
+		tx.Rollback()
+		return
+	}
+
+	if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.ID).Updates(map[string]interface{}{
+		"rank": v.ID,
+	}).Error; err != nil {
+		log.Error("addGroup error(%v)", err)
+		tx.Rollback()
+		return
+	}
+
+	if len(rewardsIDs) > 0 {
+		valReward := make([]string, 0, len(rewardsIDs))
+		valRewardArgs := make([]interface{}, 0)
+		for _, rid := range rewardsIDs {
+			valReward = append(valReward, "(?, ?, ?, ?, ?, ?)")
+			valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now)
+		}
+		sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_grouptask_reward (task_group_id, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ","))
+		if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil {
+			log.Error("addGroup link reward error(%v)", err)
+			tx.Rollback()
+			return
+		}
+	}
+	tx.Commit()
+	return v.ID, nil
+}
+
+//EditTaskGroup for edit task group.
+func (s *Service) EditTaskGroup(v *task.TaskGroup, rewardsIDs []int64) (id int64, err error) {
+	now := time.Now().Format("2006-01-02 15:04:05")
+	tg := &task.TaskGroup{}
+	if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", v.ID).Find(tg).Error; err != nil {
+		log.Error("EditTaskGroup link reward error(%v)", err)
+		return
+	}
+	if tg == nil {
+		return
+	}
+
+	tx := s.DB.Begin()
+	if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.ID).Updates(map[string]interface{}{
+		"root_type": v.RootType,
+		"type":      v.Type,
+	}).Error; err != nil {
+		log.Error("editGroup error(%v)", err)
+		tx.Rollback()
+		return
+	}
+
+	if len(rewardsIDs) > 0 {
+		var tgr task.TaskGroupReward
+		if err = tx.Where("task_group_id =?", v.ID).Delete(&tgr).Error; err != nil {
+			log.Error("editGroup delete old group id(%d)|error(%v)", v.ID, err)
+			tx.Rollback()
+			return
+		}
+
+		valReward := make([]string, 0, len(rewardsIDs))
+		valRewardArgs := make([]interface{}, 0)
+		for _, rid := range rewardsIDs {
+			valReward = append(valReward, "(?, ?, ?, ?, ?, ?)")
+			valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now)
+		}
+		sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_grouptask_reward (task_group_id, reward_id, state, comment, ctime, mtime) VALUES %s ON DUPLICATE KEY UPDATE task_group_id=VALUES(task_group_id), reward_id=VALUES(reward_id)", strings.Join(valReward, ","))
+		if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil {
+			log.Error("editGroup link reward error(%v)", err)
+			tx.Rollback()
+			return
+		}
+	}
+	tx.Commit()
+	return v.ID, nil
+}
+
+//OrderTaskGroup for order task group.
+func (s *Service) OrderTaskGroup(v *task.OrderTask) (err error) {
+	tg := &task.TaskGroup{}
+	if err = s.DB.Find(tg, v.ID).Error; err != nil {
+		log.Error("orderGroup error(%v)", err)
+		return
+	}
+	stg := &task.TaskGroup{}
+	if err = s.DB.Find(stg, v.SwitchID).Error; err != nil {
+		log.Error("orderGroup error(%v)", err)
+		return
+	}
+
+	tx := s.DB.Begin()
+	if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.ID).Updates(
+		map[string]interface{}{
+			"rank": v.SwitchRank,
+		},
+	).Error; err != nil {
+		log.Error("orderGroup error(%v)", err)
+		tx.Rollback()
+		return
+	}
+	if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.SwitchID).Updates(
+		map[string]interface{}{
+			"rank": v.Rank,
+		},
+	).Error; err != nil {
+		log.Error("orderGroup error(%v)", err)
+		tx.Rollback()
+		return
+	}
+	tx.Commit()
+	return
+}
+
+//UpStateGroup for update task group.
+func (s *Service) UpStateGroup(id int64, state int8) (err error) {
+	tg := &task.TaskGroup{}
+	if err = s.DB.Find(tg, id).Error; err != nil {
+		log.Error("UpStateGroup id(%d) error(%v)", id, err)
+		return
+	}
+	if tg.ID == 0 {
+		err = ecode.NothingFound
+		return
+	}
+
+	if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", id).Updates(map[string]interface{}{
+		"state": state,
+	}).Error; err != nil {
+		log.Error("UpStateGroup id(%d) state(%d) error(%v)", id, state, err)
+		return
+	}
+	return
+}
+
+//TaskGroup for task group.
+func (s *Service) TaskGroup(id int64) (res *task.TaskGroup, err error) {
+	var tg task.TaskGroup
+	if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", id).Find(&tg).Error; err != nil {
+		log.Error("s.TaskGroup id (%d) error(%v)", id, err)
+		return
+	}
+	if tg.ID == 0 {
+		return
+	}
+
+	tgrsMap, _ := s.TaskGroupRewards([]int64{id})
+	if rs, ok := tgrsMap[id]; ok {
+		rids := make([]int64, 0, len(rs))
+		for _, r := range rs {
+			if r != nil {
+				rids = append(rids, r.RewardID)
+			}
+		}
+		tg.Reward = s.getRewards(rids)
+	}
+
+	res = &tg
+	return
+}
+
+//AddSubtask for add sub task.
+func (s *Service) AddSubtask(v *task.Task, rewardsIDs []int64) (id int64, err error) {
+	now := time.Now().Format("2006-01-02 15:04:05")
+	v.CTime = now
+	v.MTime = now
+	v.State = task.StateHide
+	tx := s.DB.Begin()
+	if err = tx.Create(v).Error; err != nil {
+		log.Error("AddSubtask error(%v)", err)
+		tx.Rollback()
+		return
+	}
+	if v.ID == 0 {
+		log.Error("AddSubtask v.ID(%d)", v.ID)
+		tx.Rollback()
+		return
+	}
+
+	if err = tx.Model(&task.Task{}).Where("id=?", v.ID).Updates(map[string]interface{}{
+		"rank": v.ID,
+	}).Error; err != nil {
+		log.Error("AddSubtask error(%v)", err)
+		tx.Rollback()
+		return
+	}
+
+	if len(rewardsIDs) > 0 {
+		valReward := make([]string, 0, len(rewardsIDs))
+		valRewardArgs := make([]interface{}, 0)
+		for _, rid := range rewardsIDs {
+			valReward = append(valReward, "(?, ?, ?, ?, ?, ?)")
+			valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now)
+		}
+		sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_task_reward (task_id, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ","))
+		if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil {
+			log.Error("AddSubtask link reward error(%v)", err)
+			tx.Rollback()
+			return
+		}
+	}
+	tx.Commit()
+	return v.ID, nil
+}
+
+//EditSubtask for edit sub task.
+func (s *Service) EditSubtask(v *task.Task, rewardsIDs []int64) (id int64, err error) {
+	tk := &task.Task{}
+	if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", v.ID).Find(tk).Error; err != nil {
+		return
+	}
+	if tk == nil {
+		err = ecode.NothingFound
+		return
+	}
+
+	now := time.Now().Format("2006-01-02 15:04:05")
+	v.CTime = tk.CTime
+	v.MTime = now
+	v.State = tk.State //编辑不更新状态
+	tx := s.DB.Begin()
+	if err = tx.Save(v).Error; err != nil { //Save将包括执行更新SQL时的所有字段，即使它没有更改
+		log.Error("editSubtask error(%v)", err)
+		tx.Rollback()
+		return
+	}
+
+	if len(rewardsIDs) > 0 {
+		var tr task.TaskReward
+		if err = tx.Where("task_id =?", v.ID).Delete(&tr).Error; err != nil {
+			log.Error("editSubtask delete old task id(%d)|error(%v)", v.ID, err)
+			tx.Rollback()
+			return
+		}
+
+		valReward := make([]string, 0, len(rewardsIDs))
+		valRewardArgs := make([]interface{}, 0)
+		for _, rid := range rewardsIDs {
+			valReward = append(valReward, "(?, ?, ?, ?, ?, ?)")
+			valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now)
+		}
+		sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_task_reward (task_id, reward_id, state, comment, ctime, mtime) VALUES %s ON DUPLICATE KEY UPDATE task_id=VALUES(task_id), reward_id=VALUES(reward_id)", strings.Join(valReward, ","))
+		if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil {
+			log.Error("editSubtask link reward error(%v)", err)
+			tx.Rollback()
+			return
+		}
+	}
+	tx.Commit()
+	return v.ID, nil
+}
+
+//OrderSubTask for order sub task.
+func (s *Service) OrderSubTask(v *task.OrderTask) (err error) {
+	tg := &task.Task{}
+	if err = s.DB.Find(tg, v.ID).Error; err != nil {
+		log.Error("OrderSubTask error(%v)", err)
+		return
+	}
+	stg := &task.Task{}
+	if err = s.DB.Find(stg, v.SwitchID).Error; err != nil {
+		log.Error("OrderSubTask error(%v)", err)
+		return
+	}
+
+	tx := s.DB.Begin()
+	if err = tx.Model(&task.Task{}).Where("id=?", v.ID).Updates(
+		map[string]interface{}{
+			"rank": v.SwitchRank,
+		},
+	).Error; err != nil {
+		log.Error("OrderSubTask error(%v)", err)
+		tx.Rollback()
+		return
+	}
+	if err = tx.Model(&task.Task{}).Where("id=?", v.SwitchID).Updates(
+		map[string]interface{}{
+			"rank": v.Rank,
+		},
+	).Error; err != nil {
+		log.Error("OrderSubTask error(%v)", err)
+		tx.Rollback()
+		return
+	}
+	tx.Commit()
+	return
+}
+
+//UpStateSubTask for update sub task state.
+func (s *Service) UpStateSubTask(id int64, state int8) (err error) {
+	tg := &task.Task{}
+	if err = s.DB.Find(tg, id).Error; err != nil {
+		return
+	}
+	if tg.ID == 0 {
+		err = ecode.NothingFound
+		return
+	}
+
+	if err = s.DB.Model(&task.Task{}).Where("id=?", id).Updates(map[string]interface{}{
+		"state": state,
+	}).Error; err != nil {
+		log.Error("UpStateSubTask id(%d) state(%d) error(%v)", id, state, err)
+		return
+	}
+	return
+}
+
+//TransferSubtask for transfer one sub task from some one group to another one.
+func (s *Service) TransferSubtask(id, gid int64) (err error) {
+	tg := &task.TaskGroup{}
+	if err = s.DB.Find(tg, gid).Error; err != nil {
+		return
+	}
+	if tg.ID == 0 {
+		err = ecode.CreativeNewcomerGroupIDErr
+		return
+	}
+
+	tk := &task.Task{}
+	if err = s.DB.Find(tk, id).Error; err != nil {
+		return
+	}
+	if tk.ID == 0 {
+		err = ecode.NothingFound
+		return
+	}
+
+	if err = s.DB.Model(&task.Task{}).Where("id=?", id).Updates(map[string]interface{}{
+		"group_id": gid,
+	}).Error; err != nil {
+		log.Error("transferSubtask id(%+v) gid(%d) error(%v)", id, gid, err)
+		return
+	}
+	return
+}
+
+//Task for task.
+func (s *Service) Task(id int64) (res *task.Task, err error) {
+	var t task.Task
+	if err = s.DB.Model(&task.Task{}).Where("id=?", id).Find(&t).Error; err != nil {
+		log.Error("s.Task id (%d) error(%v)", id, err)
+		return
+	}
+	if t.ID == 0 {
+		return
+	}
+
+	trsMap, _ := s.TaskRewards([]int64{id})
+	if rs, ok := trsMap[id]; ok {
+		rids := make([]int64, 0, len(rs))
+		for _, r := range rs {
+			if r != nil {
+				rids = append(rids, r.RewardID)
+			}
+		}
+		t.Reward = s.getRewards(rids)
+	}
+	res = &t
+	return
+}
+
+//TaskRewards for task & rewards.
+func (s *Service) TaskRewards(ids []int64) (res map[int64][]*task.TaskReward, err error) {
+	trs := []*task.TaskReward{}
+	if err = s.DB.Model(&task.TaskReward{}).Where("state>=0 AND task_id IN (?)", ids).Find(&trs).Error; err != nil {
+		log.Error("s.TaskRewards ids(%+v) error(%v)", ids, err)
+		return
+	}
+	if len(trs) == 0 {
+		return
+	}
+
+	res = make(map[int64][]*task.TaskReward)
+	for _, v := range trs {
+		if v != nil {
+			res[v.TaskID] = append(res[v.TaskID], v)
+		}
+	}
+	return
+}
+
+//TasksByGroupIDsMap for task map
+func (s *Service) TasksByGroupIDsMap(gids []int64) (res map[int64][]*task.Task, err error) {
+	tks := []*task.Task{}
+	if err = s.DB.Model(&task.Task{}).Where("state>=0 AND type>0 AND group_id IN (?)", gids).Find(&tks).Error; err != nil {
+		log.Error("s.TasksByGroupIDsMap id (%+v) error(%v)", gids, err)
+		return
+	}
+	if len(tks) == 0 {
+		return
+	}
+
+	tkMap := make(map[int64]*task.Task)
+	tgMap := make(map[int64][]*task.Task)
+	ids := make([]int64, 0, len(tks))
+	for _, v := range tks {
+		if v == nil {
+			continue
+		}
+		if v.Rank == 0 {
+			v.Rank = v.ID
+		}
+		ids = append(ids, v.ID)
+		tkMap[v.ID] = v
+		tgMap[v.GroupID] = append(tgMap[v.GroupID], v)
+	}
+
+	trsMap, _ := s.TaskRewards(ids)
+	for _, id := range ids {
+		rs, ok := trsMap[id]
+		if !ok || len(rs) == 0 {
+			continue
+		}
+		rids := make([]int64, 0, len(rs))
+		for _, r := range rs {
+			if r != nil {
+				rids = append(rids, r.RewardID)
+			}
+		}
+		tkMap[id].Reward = s.getRewards(rids)
+	}
+
+	res = make(map[int64][]*task.Task)
+	for _, gid := range gids {
+		tks, ok := tgMap[gid]
+		if !ok || len(tks) == 0 {
+			continue
+		}
+		for _, tk := range tks {
+			if v, ok := tkMap[tk.ID]; ok {
+				res[gid] = append(res[gid], v)
+			}
+		}
+	}
+	for _, v := range res {
+		sort.Slice(v, func(i, j int) bool {
+			return v[i].Rank < v[j].Rank
+		})
+	}
+	return
+}
+
+//TaskList for task list
+func (s *Service) TaskList(ty int8) (res []*task.TaskGroup, err error) {
+	tgs := []*task.TaskGroup{}
+	db := s.DB.Model(&task.TaskGroup{}).Where("state>=0 AND root_type>0 AND type>0")
+	if ty > 0 {
+		db = db.Where("type=?", ty)
+	}
+
+	if err = db.Find(&tgs).Error; err != nil {
+		log.Error("TaskList %v\n", err)
+		return
+	}
+	if len(tgs) == 0 {
+		return
+	}
+
+	gids := make([]int64, 0, len(tgs))
+	tgMap := make(map[int64]*task.TaskGroup)
+	for _, v := range tgs {
+		if v == nil {
+			continue
+		}
+		gids = append(gids, v.ID)
+		tgMap[v.ID] = v
+	}
+
+	tgrsMap, _ := s.TaskGroupRewards(gids)
+	for _, id := range gids {
+		if rs, ok := tgrsMap[id]; ok {
+			if len(rs) == 0 {
+				continue
+			}
+			rids := make([]int64, 0, len(rs))
+			for _, r := range rs {
+				if r != nil {
+					rids = append(rids, r.RewardID)
+				}
+			}
+			tgMap[id].Reward = s.getRewards(rids)
+		}
+	}
+
+	tkMap, _ := s.TasksByGroupIDsMap(gids)
+	res = tgs
+	for _, v := range res {
+		if v == nil {
+			continue
+		}
+		if g, ok := tgMap[v.ID]; ok {
+			v.Reward = g.Reward
+		}
+		if tks, ok := tkMap[v.ID]; ok {
+			v.Tasks = tks
+		}
+	}
+
+	sort.Slice(res, func(i, j int) bool {
+		return res[i].Rank < res[j].Rank
+	})
+	return
+}
+
+//loadRewards for task reward.
+func (s *Service) loadRewards() (res []*task.Reward, rwMap map[int64]*task.Reward) {
+	var (
+		rds = []*task.Reward{}
+		err error
+	)
+
+	if err = s.DB.Order("id ASC").Find(&rds).Error; err != nil {
+		log.Error("loadRewards error(%v)", err)
+		return
+	}
+
+	res = make([]*task.Reward, 0, len(rds))
+	rwMap = make(map[int64]*task.Reward)
+	top := make(map[int64]*task.Reward)
+	for _, v := range rds {
+		if v == nil {
+			continue
+		}
+		rwMap[v.ID] = v
+
+		if v.ParentID == 0 {
+			top[v.ID] = v        //映射一级对象
+			res = append(res, v) //追加一级对象
+		}
+	}
+
+	for _, ch := range rds {
+		if ch == nil {
+			continue
+		}
+		if p, ok := top[ch.ParentID]; ok && p != nil && p.Type == ch.Type { //为一级对象增加子对象，注:要append满足条件的ch，若append p 则会造成递归导致stack overflow
+			p.Children = append(p.Children, ch)
+		}
+	}
+	return
+}
+
+//RewardTree for reward tree.
+func (s *Service) RewardTree() (res []*task.Reward) {
+	res, _ = s.loadRewards()
+	return
+}
+
+//ViewReward for view one reward.
+func (s *Service) ViewReward(id int64) (res *task.Reward, err error) {
+	rd := task.Reward{}
+	if err = s.DB.Model(&task.Reward{}).Where("id=?", id).Find(&rd).Error; err != nil {
+		return
+	}
+	res = &rd
+	return
+}
+
+//AddReward for add one reward.
+func (s *Service) AddReward(v *task.Reward) (id int64, err error) {
+	now := time.Now().Format("2006-01-02 15:04:05")
+	v.CTime = now
+	v.MTime = now
+	if err = s.DB.Create(v).Error; err != nil {
+		log.Error("AddReward v(%+v) error(%v)", v, err)
+		return
+	}
+	return v.ID, nil
+}
+
+//EditReward for edit one reward.
+func (s *Service) EditReward(v *task.Reward) (id int64, err error) {
+	rd := &task.Reward{}
+	if err = s.DB.Model(&task.Reward{}).Where("id=?", v.ID).Find(rd).Error; err != nil {
+		return
+	}
+	if rd == nil {
+		err = ecode.NothingFound
+		return
+	}
+
+	v.CTime = rd.CTime
+	v.MTime = time.Now().Format("2006-01-02 15:04:05")
+	v.State = rd.State //编辑不更新状态
+	if err = s.DB.Save(v).Error; err != nil {
+		log.Error("EditReward v(%+v) error(%v)", v, err)
+		return
+	}
+	return v.ID, nil
+}
+
+//UpStateReward for update reward state.
+func (s *Service) UpStateReward(id int64, state int8) (err error) {
+	rd := &task.Reward{}
+	if err = s.DB.Find(rd, id).Error; err != nil {
+		return
+	}
+	if rd.ID == 0 {
+		err = ecode.NothingFound
+		return
+	}
+
+	if rd.ParentID != 0 { //如果是子分类直接更新并返回
+		if err = s.DB.Model(&task.Reward{}).Where("id=?", id).Updates(map[string]interface{}{
+			"state": state,
+		}).Error; err != nil {
+			log.Error("UpStateReward parent id(%d) state(%d) error(%v)", id, state, err)
+		}
+		return
+	}
+
+	rds := []*task.Reward{}
+	if err = s.DB.Model(&task.Reward{}).Where("parent_id=?", id).Find(&rds).Error; err != nil {
+		log.Error("UpStateReward get childen by parent id(%d) error(%v)", rd.ParentID, err)
+		return
+	}
+	ids := make([]int64, 0, len(rds)+1)
+	for _, v := range rds {
+		if v != nil {
+			ids = append(ids, v.ID) //追加子分类id
+		}
+	}
+
+	ids = append(ids, id) //追加父分类id
+	if err = s.DB.Model(&task.Reward{}).Where("id IN (?)", ids).Updates(map[string]interface{}{
+		"state": state,
+	}).Error; err != nil {
+		log.Error("UpStateReward childen ids(%+v) error(%v)", ids, err)
+	}
+	return
+}
+
+//ViewGiftReward for view gift.
+func (s *Service) ViewGiftReward(v *task.GiftReward) (res *task.GiftReward, err error) {
+	var gfs []*task.GiftReward
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Find(&gfs).Error; err != nil {
+		log.Error("ViewGiftReward v(%+v) error(%v)", v, err)
+		return
+	}
+	if len(gfs) == 0 {
+		return
+	}
+
+	res = &task.GiftReward{
+		RootType: v.RootType,
+		TaskType: v.TaskType,
+	}
+	var (
+		state   int8
+		comment string
+	)
+	rids := make([]int64, 0, len(gfs))
+	for _, gf := range gfs {
+		if gf != nil {
+			state = gf.State
+			comment = gf.Comment
+			rids = append(rids, gf.RewardID)
+		}
+	}
+	res.State = state
+	res.Comment = comment
+	res.Reward = s.getRewards(rids)
+	return
+}
+
+//ListGiftReward for get gift list.
+func (s *Service) ListGiftReward() (res []*task.GiftReward, err error) {
+	gfs := []*task.GiftReward{}
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type>0 AND task_type>0").Find(&gfs).Error; err != nil {
+		log.Error("ListGiftReward error(%v)", err)
+		return
+	}
+	if len(gfs) == 0 {
+		return
+	}
+
+	gfMap := make(map[int64][]*task.GiftReward)
+	for _, v := range gfs {
+		if v != nil {
+			gfMap[v.TaskType] = append(gfMap[v.TaskType], v)
+		}
+	}
+
+	tys := make([]int64, 0, len(gfMap))
+	for k := range gfMap {
+		tys = append(tys, k)
+	}
+	sort.Slice(tys, func(i, j int) bool {
+		return tys[i] < tys[j]
+	})
+
+	res = make([]*task.GiftReward, 0, len(tys))
+	for _, ty := range tys {
+		gfs, ok := gfMap[ty]
+		if !ok && len(gfs) == 0 {
+			continue
+		}
+		var rt uint8
+		if task.CheckRootType(uint8(ty)) {
+			rt = task.TaskManagement
+		} else {
+			rt = task.AchievementManagement
+		}
+		re := &task.GiftReward{
+			RootType: rt,
+			TaskType: ty,
+		}
+
+		var (
+			state   int8
+			comment string
+		)
+		rids := make([]int64, 0, len(gfs))
+		for _, gf := range gfs {
+			if gf != nil {
+				state = gf.State
+				comment = gf.Comment
+				rids = append(rids, gf.RewardID)
+			}
+		}
+		re.State = state
+		re.Comment = comment
+		re.Reward = s.getRewards(rids)
+		res = append(res, re)
+	}
+	return
+}
+
+//AddGiftReward for add gift rewards.
+func (s *Service) AddGiftReward(v *task.GiftReward, rewardsIDs []int64) (rows int64, err error) {
+	var gfs []*task.GiftReward
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=? AND reward_id IN (?)", v.RootType, v.TaskType, rewardsIDs).Find(&gfs).Error; err != nil {
+		log.Error("UpGiftReward v(%+v) error(%v)", v, err)
+		return
+	}
+	if len(gfs) != 0 {
+		hitMap := make(map[int64]struct{})
+		for _, gf := range gfs {
+			hitMap[gf.RewardID] = struct{}{}
+		}
+		for _, rid := range rewardsIDs {
+			if _, ok := hitMap[rid]; ok {
+				err = ecode.CreativeNewcomerDuplicateGiftRewardIDErr
+				log.Error("AddGiftReward rid(%d) error(%v)", rid, err)
+				return
+			}
+		}
+	}
+
+	valReward := make([]string, 0, len(rewardsIDs))
+	valRewardArgs := make([]interface{}, 0)
+	now := time.Now().Format("2006-01-02 15:04:05")
+	for _, rid := range rewardsIDs {
+		valReward = append(valReward, "(?, ?, ?, ?, ?, ?, ?)")
+		valRewardArgs = append(valRewardArgs, v.RootType, v.TaskType, rid, task.StateNormal, v.Comment, now, now)
+	}
+	sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_gift_reward (root_type, task_type, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ","))
+	if err = s.DB.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil {
+		log.Error("AddGiftReward error(%v)", err)
+		return
+	}
+	return s.DB.RowsAffected, nil
+}
+
+//EditGiftReward for edit gift rewards.
+func (s *Service) EditGiftReward(v *task.GiftReward, rewardsIDs []int64) (rows int64, err error) {
+	var (
+		gfs   []*task.GiftReward
+		state int8
+	)
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Find(&gfs).Error; err != nil {
+		log.Error("EditGiftReward v(%+v) error(%v)", v, err)
+		return
+	}
+	if len(gfs) == 0 {
+		err = ecode.NothingFound
+		return
+	}
+	for _, gf := range gfs { //获取原来的状态
+		state = gf.State
+		break
+	}
+
+	var gf task.GiftReward
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type =?", v.RootType).Where("task_type =?", v.TaskType).Delete(&gf).Error; err != nil {
+		log.Error("EditGiftReward delete old id(%d)|error(%v)", v.ID, err)
+		return
+	}
+
+	valReward := make([]string, 0, len(rewardsIDs))
+	valRewardArgs := make([]interface{}, 0)
+	now := time.Now().Format("2006-01-02 15:04:05")
+	for _, rid := range rewardsIDs {
+		valReward = append(valReward, "(?, ?, ?, ?, ?, ?, ?)")
+		valRewardArgs = append(valRewardArgs, v.RootType, v.TaskType, rid, state, v.Comment, now, now)
+	}
+	sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_gift_reward (root_type, task_type, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ","))
+	if err = s.DB.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil {
+		log.Error("EditGiftReward error(%v)", err)
+		return
+	}
+	return s.DB.RowsAffected, nil
+}
+
+//UpGiftReward for update gift reward.
+func (s *Service) UpGiftReward(v *task.GiftReward) (rows int64, err error) {
+	var gfs []*task.GiftReward
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Find(&gfs).Error; err != nil {
+		log.Error("UpGiftReward v(%+v) error(%v)", v, err)
+		return
+	}
+	if len(gfs) == 0 {
+		return
+	}
+
+	if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Updates(map[string]interface{}{
+		"state": v.State,
+	}).Error; err != nil {
+		log.Error("UpGiftReward v(%+v) error(%v)", v, err)
+		return
+	}
+	return s.DB.RowsAffected, nil
+}
+
+//BatchOnline for subtask & grouptask with state,rank and so on.
+func (s *Service) BatchOnline(tgs []*task.TaskGroup) (err error) {
+	tasks := make([]*task.Task, 0)
+	groups := make([]*task.TaskGroup, 0, len(tgs))
+	for _, v := range tgs {
+		groups = append(groups, &task.TaskGroup{
+			ID:       v.ID,
+			Rank:     v.Rank,
+			State:    v.State,
+			RootType: v.RootType,
+			Type:     v.Type,
+		})
+		tasks = append(tasks, v.Tasks...)
+	}
+
+	valGroups := make([]string, 0, len(groups))
+	valGroupArgs := make([]interface{}, 0)
+	for _, v := range groups {
+		valGroups = append(valGroups, "(?, ?, ?)")
+		valGroupArgs = append(valGroupArgs, v.ID, v.State, v.Rank)
+	}
+	sqlGroupStr := fmt.Sprintf("INSERT INTO newcomers_task_group (id, state, rank) VALUES %s ON DUPLICATE KEY UPDATE state=VALUES(state), rank=VALUES(rank)", strings.Join(valGroups, ","))
+	if err = s.DB.Exec(sqlGroupStr, valGroupArgs...).Error; err != nil {
+		log.Error("BatchOnline update groups error(%v)", err)
+		return
+	}
+
+	valTasks := make([]string, 0, len(tasks))
+	valTaskArgs := make([]interface{}, 0)
+	for _, v := range tasks {
+		valTasks = append(valTasks, "(?, ?, ?, ?)")
+		valTaskArgs = append(valTaskArgs, v.ID, v.State, v.Rank, v.GroupID)
+	}
+	sqlTaskStr := fmt.Sprintf("INSERT INTO newcomers_task (id, state, rank, group_id) VALUES %s ON DUPLICATE KEY UPDATE state=VALUES(state), rank=VALUES(rank), group_id=VALUES(group_id)", strings.Join(valTasks, ","))
+	if err = s.DB.Exec(sqlTaskStr, valTaskArgs...).Error; err != nil {
+		log.Error("BatchOnline update tasks error(%v)", err)
+	}
+	return
+}

app/admin/main/creative/service/upbfs.go

@@ -0,0 +1,49 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"io"
+	"net/http"
+
+	"go-common/app/admin/main/creative/model/bfs"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// Upload to bfs
+func (s *Service) Upload(c context.Context, fileName string, fileType string, timing int64, body []byte) (location string, err error) {
+	if len(body) == 0 {
+		err = ecode.FileNotExists
+		return
+	}
+	if len(body) > s.conf.Bfs.MaxFileSize {
+		err = ecode.FileTooLarge
+		return
+	}
+	if location, err = s.dao.Upload(c, fileName, fileType, timing, body, s.conf.Bfs); err != nil {
+		log.Error("s.upload.Upload() error(%v)", err)
+	}
+	return
+}
+
+// ParseFile analyses file info
+func (s *Service) ParseFile(c context.Context, content []byte) (file *bfs.FileInfo, err error) {
+	fType := http.DetectContentType(content)
+	// file md5
+	md5hash := md5.New()
+	if _, err = io.Copy(md5hash, bytes.NewReader(content)); err != nil {
+		log.Error("resource uploadFile.Copy error(%v)", err)
+		return
+	}
+	md5 := md5hash.Sum(nil)
+	fMd5 := hex.EncodeToString(md5[:])
+	file = &bfs.FileInfo{
+		Md5:  fMd5,
+		Type: fType,
+		Size: int64(len(content)),
+	}
+	return
+}

app/admin/main/creative/service/upbfs_test.go

@@ -0,0 +1,44 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	c   = context.TODO()
+	now = time.Now().Unix()
+)
+
+func TestService_Upload(t *testing.T) {
+	Convey("Upload should return without err", t, WithService(func(svf *Service) {
+		// simulate file content
+		str2 := "Testing File Content"
+		data2 := []byte(str2)
+		// upload to bfs
+		location, err := svf.Upload(c, "tName", "image/png", now, data2)
+		// testing
+		So(err, ShouldBeNil)
+		So(location, ShouldNotBeNil)
+		fmt.Println(location)
+	}))
+}
+
+func TestService_ParseFile(t *testing.T) {
+	Convey("ParseFile can get file info", t, WithService(func(svf *Service) {
+		// simulate file content
+		str2 := "Testing File Content"
+		data2 := []byte(str2)
+		// upload to bfs
+		fInfo, err := svf.ParseFile(c, data2)
+		// testing
+		So(err, ShouldBeNil)
+		So(fInfo.Size, ShouldBeGreaterThan, 0)
+		So(fInfo.Type, ShouldNotBeBlank)
+		So(fInfo.Md5, ShouldNotBeBlank)
+	}))
+}

app/admin/main/creative/service/whitelist.go

@@ -0,0 +1,71 @@
+package service
+
+import (
+	"context"
+	"sort"
+
+	"go-common/app/admin/main/creative/model/whitelist"
+	accapi "go-common/app/service/main/account/api"
+	"go-common/library/log"
+
+	"golang.org/x/sync/errgroup"
+)
+
+// Cards fn
+func (s *Service) Cards(c context.Context, wls []*whitelist.Whitelist) (wlsWithAcc []*whitelist.Whitelist, err error) {
+	wlsWithAcc = []*whitelist.Whitelist{}
+	var (
+		g errgroup.Group
+	)
+	ch := make(chan *whitelist.Whitelist, len(wls))
+	for _, wl := range wls {
+		id := wl.ID
+		mid := wl.MID
+		adminMid := wl.AdminMID
+		comment := wl.Comment
+		state := wl.State
+		tp := wl.Type
+		ctime := wl.Ctime
+		mtime := wl.Mtime
+		g.Go(func() (err error) {
+			pfl, err := s.dao.ProfileStat(c, mid)
+			if err != nil {
+				log.Error("s.dao.Card mid(%+v)|err(%+v)", mid, err)
+				return
+			}
+			var name string
+			if pfl.Profile != nil {
+				name = pfl.Profile.Name
+			}
+			ch <- &whitelist.Whitelist{
+				ID:           id,
+				MID:          mid,
+				AdminMID:     adminMid,
+				Comment:      comment,
+				State:        state,
+				Type:         tp,
+				Fans:         pfl.Follower,
+				CurrentLevel: pfl.LevelInfo.Cur,
+				Name:         name,
+				Ctime:        ctime,
+				Mtime:        mtime,
+			}
+			return
+		})
+	}
+	g.Wait()
+	close(ch)
+	for c := range ch {
+		wlsWithAcc = append(wlsWithAcc, c)
+	}
+	sort.Slice(wlsWithAcc, func(i, j int) bool { return wlsWithAcc[i].Ctime > wlsWithAcc[j].Ctime })
+	return
+}
+
+// ProfileStat fn
+func (s *Service) ProfileStat(c context.Context, mid int64) (pfl *accapi.ProfileStatReply, err error) {
+	if pfl, err = s.dao.ProfileStat(c, mid); err != nil {
+		log.Error("s.dao.Profile mid(%+v)|err(%+v)", mid, err)
+	}
+	return
+}