Create & Init Project...

app/admin/main/esports/service/BUILD

@@ -0,0 +1,74 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive.go",
+        "contest.go",
+        "game.go",
+        "match.go",
+        "match_active.go",
+        "match_detail.go",
+        "season.go",
+        "service.go",
+        "tag.go",
+        "team.go",
+        "tree.go",
+    ],
+    importpath = "go-common/app/admin/main/esports/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/esports/conf:go_default_library",
+        "//app/admin/main/esports/dao:go_default_library",
+        "//app/admin/main/esports/model:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/pkg/errors: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "archive_test.go",
+        "game_test.go",
+        "match_test.go",
+        "service_test.go",
+        "team_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/esports/conf:go_default_library",
+        "//app/admin/main/esports/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/esports/service/archive.go

@@ -0,0 +1,826 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/esports/model"
+	accwarden "go-common/app/service/main/account/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_typeAdd  = "add"
+	_typeEdit = "edit"
+)
+
+var _emptyArcList = make([]*model.ArcResult, 0)
+
+// ArcList archive list.
+func (s *Service) ArcList(c context.Context, arg *model.ArcListParam) (arcs []*model.ArcResult, total int, err error) {
+	var (
+		list                                []*model.SearchArc
+		gids, tids, matchIDs, teamIDs, mids []int64
+		games                               []*model.Game
+		tags                                []*model.Tag
+		matchs                              []*model.Match
+		teams                               []*model.Team
+		gameMap                             map[int64]*model.Game
+		tagMap                              map[int64]*model.Tag
+		matchMap                            map[int64]*model.Match
+		teamMap                             map[int64]*model.Team
+		infosReply                          *accwarden.InfosReply
+		ip                                  = metadata.String(c, metadata.RemoteIP)
+	)
+	if list, total, err = s.dao.SearchArc(c, arg); err != nil {
+		return
+	}
+	if len(list) == 0 {
+		arcs = _emptyArcList
+		return
+	}
+	for _, arc := range list {
+		if len(arc.Gid) > 0 {
+			gids = append(gids, arc.Gid...)
+		}
+		if len(arc.Tags) > 0 {
+			tids = append(tids, arc.Tags...)
+		}
+		if len(arc.Matchs) > 0 {
+			matchIDs = append(matchIDs, arc.Matchs...)
+		}
+		if len(arc.Teams) > 0 {
+			teamIDs = append(teamIDs, arc.Teams...)
+		}
+		if arc.Mid > 0 {
+			mids = append(mids, arc.Mid)
+		}
+	}
+	if len(gids) > 0 {
+		if err = s.dao.DB.Model(&model.Game{}).Where("id IN (?)", unique(gids)).Find(&games).Error; err != nil {
+			log.Error("ArcList Game gids(%+v) error(%v)", gids, err)
+			return
+		}
+		if gl := len(games); gl > 0 {
+			gameMap = make(map[int64]*model.Game, gl)
+			for _, v := range games {
+				gameMap[v.ID] = v
+			}
+		}
+	}
+	if len(tids) > 0 {
+		if err = s.dao.DB.Model(&model.Tag{}).Where("id IN (?)", unique(tids)).Find(&tags).Error; err != nil {
+			log.Error("ArcList Tag tids(%+v) error(%v)", tids, err)
+			return
+		}
+		if tl := len(tags); tl > 0 {
+			tagMap = make(map[int64]*model.Tag, tl)
+			for _, v := range tags {
+				tagMap[v.ID] = v
+			}
+		}
+	}
+	if len(matchIDs) > 0 {
+		if err = s.dao.DB.Model(&model.Match{}).Where("id IN (?)", unique(matchIDs)).Find(&matchs).Error; err != nil {
+			log.Error("ArcList Match ids(%+v) error(%v)", tids, err)
+			return
+		}
+		if tl := len(matchs); tl > 0 {
+			matchMap = make(map[int64]*model.Match, tl)
+			for _, v := range matchs {
+				matchMap[v.ID] = v
+			}
+		}
+	}
+	if len(teamIDs) > 0 {
+		if err = s.dao.DB.Model(&model.Team{}).Where("id IN (?)", unique(teamIDs)).Find(&teams).Error; err != nil {
+			log.Error("ArcList Team ids(%+v) error(%v)", tids, err)
+			return
+		}
+		if tl := len(teams); tl > 0 {
+			teamMap = make(map[int64]*model.Team, tl)
+			for _, v := range teams {
+				teamMap[v.ID] = v
+			}
+		}
+	}
+	if len(mids) > 0 {
+		if infosReply, err = s.accClient.Infos3(c, &accwarden.MidsReq{Mids: unique(mids), RealIp: ip}); err != nil {
+			log.Error("账号Infos3:grpc错误", "s.accClient.Infos3 error(%v)", err)
+			return
+		}
+	}
+	for _, v := range list {
+		arcRes := &model.ArcResult{
+			Aid:    v.Aid,
+			TypeID: v.TypeID,
+			Title:  v.Title,
+			State:  v.State,
+			Mid:    v.Mid,
+			Years:  v.Year,
+		}
+		if infosReply != nil && len(infosReply.Infos) > 0 {
+			if info, ok := infosReply.Infos[v.Mid]; ok && info != nil {
+				arcRes.Uname = info.Name
+			}
+		}
+		if len(gameMap) > 0 {
+			for _, gid := range v.Gid {
+				if game, ok := gameMap[gid]; ok {
+					arcRes.Games = append(arcRes.Games, game)
+				}
+			}
+		}
+		if len(tagMap) > 0 {
+			for _, tid := range v.Tags {
+				if tag, ok := tagMap[tid]; ok {
+					arcRes.Tags = append(arcRes.Tags, tag)
+				}
+			}
+		}
+		if len(matchMap) > 0 {
+			for _, tid := range v.Matchs {
+				if match, ok := matchMap[tid]; ok {
+					arcRes.Matchs = append(arcRes.Matchs, match)
+				}
+			}
+		}
+		if len(teamMap) > 0 {
+			for _, tid := range v.Teams {
+				if team, ok := teamMap[tid]; ok {
+					arcRes.Teams = append(arcRes.Teams, team)
+				}
+			}
+		}
+		if len(arcRes.Games) == 0 {
+			arcRes.Games = _emptyGameList
+		}
+		if len(arcRes.Tags) == 0 {
+			arcRes.Tags = _emptyTagList
+		}
+		if len(arcRes.Matchs) == 0 {
+			arcRes.Matchs = _emptyMatchList
+		}
+		if len(arcRes.Teams) == 0 {
+			arcRes.Teams = _emptyTeamList
+		}
+		arcs = append(arcs, arcRes)
+	}
+	return
+}
+
+// EditArc edit archive.
+func (s *Service) EditArc(c context.Context, arg *model.ArcImportParam) (err error) {
+	var preArc *model.Arc
+	if err = s.dao.DB.Model(&model.Arc{}).Where("aid = ?", arg.Aid).Where("is_deleted=?", _notDeleted).First(&preArc).Error; err != nil {
+		log.Error("EditArc check aid Error (%v)", err)
+		return
+	}
+	var data *model.ArcRelation
+	if data, err = s.arcRelationChanges(c, arg, _typeEdit); err != nil {
+		return
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = upArcRelation(tx, data); err != nil {
+		err = tx.Rollback().Error
+		return
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// BatchAddArc batch add archive.
+func (s *Service) BatchAddArc(c context.Context, param *model.ArcAddParam) (err error) {
+	var (
+		arcs                           []*model.Arc
+		upAddAids, addAids, changeAids []int64
+	)
+	if err = s.dao.DB.Model(&model.Arc{}).Where("aid IN (?)", param.Aids).Find(&arcs).Error; err != nil {
+		log.Error("BatchAddArc check aids Error (%v)", err)
+		return
+	}
+	if len(arcs) > 0 {
+		arcMap := make(map[int64]*model.Arc, len(param.Aids))
+		for _, v := range arcs {
+			arcMap[v.Aid] = v
+		}
+		for _, aid := range param.Aids {
+			if arc, ok := arcMap[aid]; ok {
+				if arc.IsDeleted == _deleted {
+					upAddAids = append(upAddAids, arc.ID)
+					changeAids = append(changeAids, arc.Aid)
+				}
+			} else {
+				addAids = append(addAids, aid)
+				changeAids = append(changeAids, aid)
+			}
+		}
+	} else {
+		addAids = param.Aids
+		changeAids = param.Aids
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if len(addAids) > 0 {
+		if err = tx.Model(&model.Arc{}).Exec(model.ArcBatchAddSQL(addAids)).Error; err != nil {
+			log.Error("BatchAddArc Arc tx.Model Exec(%+v) error(%v)", addAids, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(changeAids) > 0 {
+		arcRelation := new(model.ArcRelation)
+		for _, aid := range changeAids {
+			var data *model.ArcRelation
+			arg := &model.ArcImportParam{
+				Aid:      aid,
+				Gids:     param.Gids,
+				MatchIDs: param.MatchIDs,
+				TagIDs:   param.TagIDs,
+				TeamIDs:  param.TeamIDs,
+				Years:    param.Years,
+			}
+			if data, err = s.arcRelationChanges(c, arg, _typeAdd); err != nil {
+				return
+			}
+			arcRelation.UpAddGids = append(arcRelation.UpAddGids, data.UpAddGids...)
+			arcRelation.UpDelGids = append(arcRelation.UpDelGids, data.UpDelGids...)
+			arcRelation.AddGids = append(arcRelation.AddGids, data.AddGids...)
+			arcRelation.UpAddMatchs = append(arcRelation.UpAddMatchs, data.UpAddMatchs...)
+			arcRelation.UpDelMatchs = append(arcRelation.UpDelMatchs, data.UpDelMatchs...)
+			arcRelation.AddMatchs = append(arcRelation.AddMatchs, data.AddMatchs...)
+			arcRelation.UpAddTags = append(arcRelation.UpAddTags, data.UpAddTags...)
+			arcRelation.UpDelTags = append(arcRelation.UpDelTags, data.UpDelTags...)
+			arcRelation.AddTags = append(arcRelation.AddTags, data.AddTags...)
+			arcRelation.UpAddTeams = append(arcRelation.UpAddTeams, data.UpAddTeams...)
+			arcRelation.UpDelTeams = append(arcRelation.UpDelTeams, data.UpDelTeams...)
+			arcRelation.AddTeams = append(arcRelation.AddTeams, data.AddTeams...)
+			arcRelation.UpAddYears = append(arcRelation.UpAddYears, data.UpAddYears...)
+			arcRelation.UpDelYears = append(arcRelation.UpDelYears, data.UpDelYears...)
+			arcRelation.AddYears = append(arcRelation.AddYears, data.AddYears...)
+		}
+		if err = upArcRelation(tx, arcRelation); err != nil {
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(upAddAids) > 0 {
+		if err = tx.Model(&model.Arc{}).Where("id IN (?)", upAddAids).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("BatchAddArc Save(%+v) error(%v)", upAddAids, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// BatchEditArc batch add arc.
+func (s *Service) BatchEditArc(c context.Context, param *model.ArcAddParam) (err error) {
+	var (
+		arcs       []*model.Arc
+		changeAids []int64
+	)
+	if err = s.dao.DB.Model(&model.Arc{}).Where("aid IN (?)", param.Aids).Find(&arcs).Error; err != nil {
+		log.Error("BatchEditArc check aids Error (%v)", err)
+		return
+	}
+	if len(arcs) > 0 {
+		arcMap := make(map[int64]*model.Arc, len(param.Aids))
+		for _, v := range arcs {
+			arcMap[v.Aid] = v
+		}
+		for _, aid := range param.Aids {
+			if arc, ok := arcMap[aid]; ok {
+				if arc.IsDeleted == _notDeleted {
+					changeAids = append(changeAids, arc.Aid)
+				}
+			}
+		}
+	}
+	if len(changeAids) == 0 {
+		err = ecode.RequestErr
+		return
+	}
+	arcRelation := new(model.ArcRelation)
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	for _, aid := range changeAids {
+		var data *model.ArcRelation
+		arg := &model.ArcImportParam{
+			Aid:      aid,
+			Gids:     param.Gids,
+			MatchIDs: param.MatchIDs,
+			TagIDs:   param.TagIDs,
+			TeamIDs:  param.TeamIDs,
+			Years:    param.Years,
+		}
+		if data, err = s.arcRelationChanges(c, arg, _typeEdit); err != nil {
+			return
+		}
+		arcRelation.UpAddGids = append(arcRelation.UpAddGids, data.UpAddGids...)
+		arcRelation.UpDelGids = append(arcRelation.UpDelGids, data.UpDelGids...)
+		arcRelation.AddGids = append(arcRelation.AddGids, data.AddGids...)
+		arcRelation.UpAddMatchs = append(arcRelation.UpAddMatchs, data.UpAddMatchs...)
+		arcRelation.UpDelMatchs = append(arcRelation.UpDelMatchs, data.UpDelMatchs...)
+		arcRelation.AddMatchs = append(arcRelation.AddMatchs, data.AddMatchs...)
+		arcRelation.UpAddTags = append(arcRelation.UpAddTags, data.UpAddTags...)
+		arcRelation.UpDelTags = append(arcRelation.UpDelTags, data.UpDelTags...)
+		arcRelation.AddTags = append(arcRelation.AddTags, data.AddTags...)
+		arcRelation.UpAddTeams = append(arcRelation.UpAddTeams, data.UpAddTeams...)
+		arcRelation.UpDelTeams = append(arcRelation.UpDelTeams, data.UpDelTeams...)
+		arcRelation.AddTeams = append(arcRelation.AddTeams, data.AddTeams...)
+		arcRelation.UpAddYears = append(arcRelation.UpAddYears, data.UpAddYears...)
+		arcRelation.UpDelYears = append(arcRelation.UpDelYears, data.UpDelYears...)
+		arcRelation.AddYears = append(arcRelation.AddYears, data.AddYears...)
+	}
+	if err = upArcRelation(tx, arcRelation); err != nil {
+		err = tx.Rollback().Error
+		return
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// ArcImportCSV archive import.
+func (s *Service) ArcImportCSV(c context.Context, list []*model.ArcImportParam) (err error) {
+	var (
+		aids, addAids, changeAids, saveAids []int64
+		arcs                                []*model.Arc
+	)
+	listMap := make(map[int64]*model.ArcImportParam, len(aids))
+	for _, v := range list {
+		aids = append(aids, v.Aid)
+		listMap[v.Aid] = v
+	}
+	if err = s.dao.DB.Model(&model.Arc{}).Where("aid IN (?)", aids).Find(&arcs).Error; err != nil {
+		log.Error("arcImport check aids Error (%v)", err)
+		return
+	}
+	if len(arcs) > 0 {
+		arcMap := make(map[int64]*model.Arc, len(aids))
+		for _, v := range arcs {
+			arcMap[v.Aid] = v
+		}
+		for _, aid := range aids {
+			if arc, ok := arcMap[aid]; ok {
+				if arc.IsDeleted == _deleted {
+					saveAids = append(saveAids, arc.ID)
+					changeAids = append(changeAids, arc.Aid)
+				}
+			} else {
+				addAids = append(addAids, aid)
+				changeAids = append(changeAids, aid)
+			}
+		}
+	} else {
+		addAids = aids
+		changeAids = aids
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if len(addAids) > 0 {
+		if err = tx.Model(&model.Arc{}).Exec(model.ArcBatchAddSQL(addAids)).Error; err != nil {
+			log.Error("arcImport Arc tx.Model Exec(%+v) error(%v)", addAids, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(saveAids) > 0 {
+		if err = tx.Model(&model.Arc{}).Where("id IN (?)", saveAids).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("arcImport Save(%+v) error(%v)", saveAids, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(changeAids) > 0 {
+		arcRelation := new(model.ArcRelation)
+		for _, aid := range changeAids {
+			if arc, ok := listMap[aid]; ok {
+				var data *model.ArcRelation
+				arg := &model.ArcImportParam{
+					Aid:      aid,
+					Gids:     arc.Gids,
+					MatchIDs: arc.MatchIDs,
+					TagIDs:   arc.TagIDs,
+					TeamIDs:  arc.TeamIDs,
+					Years:    arc.Years,
+				}
+				if data, err = s.arcRelationChanges(c, arg, _typeAdd); err != nil {
+					return
+				}
+				arcRelation.UpAddGids = append(arcRelation.UpAddGids, data.UpAddGids...)
+				arcRelation.UpDelGids = append(arcRelation.UpDelGids, data.UpDelGids...)
+				arcRelation.AddGids = append(arcRelation.AddGids, data.AddGids...)
+				arcRelation.UpAddMatchs = append(arcRelation.UpAddMatchs, data.UpAddMatchs...)
+				arcRelation.UpDelMatchs = append(arcRelation.UpDelMatchs, data.UpDelMatchs...)
+				arcRelation.AddMatchs = append(arcRelation.AddMatchs, data.AddMatchs...)
+				arcRelation.UpAddTags = append(arcRelation.UpAddTags, data.UpAddTags...)
+				arcRelation.UpDelTags = append(arcRelation.UpDelTags, data.UpDelTags...)
+				arcRelation.AddTags = append(arcRelation.AddTags, data.AddTags...)
+				arcRelation.UpAddTeams = append(arcRelation.UpAddTeams, data.UpAddTeams...)
+				arcRelation.UpDelTeams = append(arcRelation.UpDelTeams, data.UpDelTeams...)
+				arcRelation.AddTeams = append(arcRelation.AddTeams, data.AddTeams...)
+				arcRelation.UpAddYears = append(arcRelation.UpAddYears, data.UpAddYears...)
+				arcRelation.UpDelYears = append(arcRelation.UpDelYears, data.UpDelYears...)
+				arcRelation.AddYears = append(arcRelation.AddYears, data.AddYears...)
+			}
+		}
+		if err = upArcRelation(tx, arcRelation); err != nil {
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+func (s *Service) arcRelationChanges(c context.Context, arg *model.ArcImportParam, typ string) (data *model.ArcRelation, err error) {
+	data = new(model.ArcRelation)
+	// add game map
+	if len(arg.Gids) > 0 {
+		var gidMaps []*model.GIDMap
+		if err = s.dao.DB.Model(&model.GIDMap{}).Where("oid=?", arg.Aid).Where("gid IN (?)", arg.Gids).Where("type=?", model.TypeArc).Find(&gidMaps).Error; err != nil {
+			log.Error("arcRelationChanges GIDMap s.dao.DB.Model MatchMap(%+v) error(%v)", arg.Gids, err)
+			return
+		}
+		if len(gidMaps) > 0 {
+			gidMap := make(map[int64]*model.GIDMap, len(gidMaps))
+			for _, v := range gidMaps {
+				gidMap[v.Gid] = v
+			}
+			for _, gid := range arg.Gids {
+				if gidItem, ok := gidMap[gid]; ok {
+					if gidItem.IsDeleted == _deleted {
+						data.UpAddGids = append(data.UpAddGids, gidItem.ID)
+					}
+				} else {
+					data.AddGids = append(data.AddGids, &model.GIDMap{Type: model.TypeArc, Gid: gid, Oid: arg.Aid})
+				}
+			}
+		} else {
+			for _, gid := range arg.Gids {
+				data.AddGids = append(data.AddGids, &model.GIDMap{Type: model.TypeArc, Gid: gid, Oid: arg.Aid})
+			}
+		}
+	}
+	// add match map
+	if len(arg.MatchIDs) > 0 {
+		var matchs []*model.MatchMap
+		if err = s.dao.DB.Model(&model.MatchMap{}).Where("aid=?", arg.Aid).Where("mid IN (?)", arg.MatchIDs).Find(&matchs).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model MatchMap(%+v) error(%v)", arg.MatchIDs, err)
+			return
+		}
+		if len(matchs) > 0 {
+			matchMap := make(map[int64]*model.MatchMap, len(matchs))
+			for _, v := range matchs {
+				matchMap[v.Mid] = v
+			}
+			for _, mid := range arg.MatchIDs {
+				if match, ok := matchMap[mid]; ok {
+					if match.IsDeleted == _deleted {
+						data.UpAddMatchs = append(data.UpAddMatchs, match.ID)
+					}
+				} else {
+					data.AddMatchs = append(data.AddMatchs, &model.MatchMap{Mid: mid, Aid: arg.Aid})
+				}
+			}
+		} else {
+			for _, mid := range arg.MatchIDs {
+				data.AddMatchs = append(data.AddMatchs, &model.MatchMap{Mid: mid, Aid: arg.Aid})
+			}
+		}
+	}
+	// add tags map
+	if len(arg.TagIDs) > 0 {
+		var tags []*model.TagMap
+		if err = s.dao.DB.Model(&model.TagMap{}).Where("aid=?", arg.Aid).Where("tid IN (?)", arg.TagIDs).Find(&tags).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model TagMap(%+v) error(%v)", arg.TagIDs, err)
+			return
+		}
+		if len(tags) > 0 {
+			tagMap := make(map[int64]*model.TagMap, len(tags))
+			for _, v := range tags {
+				tagMap[v.Tid] = v
+			}
+			for _, tid := range arg.TagIDs {
+				if tag, ok := tagMap[tid]; ok {
+					if tag.IsDeleted == _deleted {
+						data.UpAddTags = append(data.UpAddTags, tag.ID)
+					}
+				} else {
+					data.AddTags = append(data.AddTags, &model.TagMap{Tid: tid, Aid: arg.Aid})
+				}
+			}
+		} else {
+			for _, tid := range arg.TagIDs {
+				data.AddTags = append(data.AddTags, &model.TagMap{Tid: tid, Aid: arg.Aid})
+			}
+		}
+	}
+	// add teams map
+	if len(arg.TeamIDs) > 0 {
+		var teams []*model.TeamMap
+		if err = s.dao.DB.Model(&model.TeamMap{}).Where("aid=?", arg.Aid).Where("tid IN (?)", arg.TeamIDs).Find(&teams).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model TeamMap(%+v) error(%v)", arg.TeamIDs, err)
+			return
+		}
+		if len(teams) > 0 {
+			teamMap := make(map[int64]*model.TeamMap, len(teams))
+			for _, v := range teams {
+				teamMap[v.Tid] = v
+			}
+			for _, teamID := range arg.TeamIDs {
+				if team, ok := teamMap[teamID]; ok {
+					if team.IsDeleted == _deleted {
+						data.UpAddTeams = append(data.UpAddTeams, team.ID)
+					}
+				} else {
+					data.AddTeams = append(data.AddTeams, &model.TeamMap{Tid: teamID, Aid: arg.Aid})
+				}
+			}
+		} else {
+			for _, teamID := range arg.TeamIDs {
+				data.AddTeams = append(data.AddTeams, &model.TeamMap{Tid: teamID, Aid: arg.Aid})
+			}
+		}
+	}
+	// add year map
+	if len(arg.Years) > 0 {
+		var yearMaps []*model.YearMap
+		if err = s.dao.DB.Model(&model.YearMap{}).Where("aid=?", arg.Aid).Where("year IN (?)", arg.Years).Find(&yearMaps).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model YearMap(%+v) error(%v)", arg.Years, err)
+			return
+		}
+		if len(yearMaps) > 0 {
+			yearMap := make(map[int64]*model.YearMap, len(yearMaps))
+			for _, v := range yearMaps {
+				yearMap[v.Year] = v
+			}
+			for _, yearID := range arg.Years {
+				if year, ok := yearMap[yearID]; ok {
+					if year.IsDeleted == _deleted {
+						data.UpAddYears = append(data.UpAddYears, year.ID)
+					}
+				} else {
+					data.AddYears = append(data.AddYears, &model.YearMap{Year: yearID, Aid: arg.Aid})
+				}
+			}
+		} else {
+			for _, yearID := range arg.Years {
+				data.AddYears = append(data.AddYears, &model.YearMap{Year: yearID, Aid: arg.Aid})
+			}
+		}
+	}
+	if typ == _typeEdit {
+		var (
+			gidMaps []*model.GIDMap
+			matchs  []*model.MatchMap
+			tags    []*model.TagMap
+			teams   []*model.TeamMap
+			years   []*model.YearMap
+		)
+		// gid map
+		if err = s.dao.DB.Model(&model.GIDMap{}).Where("oid=?", arg.Aid).Where("type=?", model.TypeArc).Where("is_deleted=?", _notDeleted).Find(&gidMaps).Error; err != nil {
+			log.Error("arcRelationChanges GIDMap s.dao.DB.Model MatchMap(%+v) error(%v)", arg.Gids, err)
+			return
+		}
+		if len(gidMaps) > 0 {
+			if len(arg.Gids) > 0 {
+				gidMap := make(map[int64]int64, len(arg.Gids))
+				for _, gid := range arg.Gids {
+					gidMap[gid] = gid
+				}
+				for _, v := range gidMaps {
+					if _, ok := gidMap[v.Gid]; !ok {
+						data.UpDelGids = append(data.UpDelGids, v.ID)
+					}
+				}
+			} else {
+				for _, v := range gidMaps {
+					data.UpDelGids = append(data.UpDelGids, v.ID)
+				}
+			}
+		}
+		// match
+		if err = s.dao.DB.Model(&model.MatchMap{}).Where("aid=?", arg.Aid).Where("is_deleted=?", _notDeleted).Find(&matchs).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model MatchMap(%+v) error(%v)", arg.MatchIDs, err)
+			return
+		}
+		if len(matchs) > 0 {
+			if len(arg.MatchIDs) > 0 {
+				matchIDMap := make(map[int64]int64, len(arg.MatchIDs))
+				for _, id := range arg.MatchIDs {
+					matchIDMap[id] = id
+				}
+				for _, v := range matchs {
+					if _, ok := matchIDMap[v.Mid]; !ok {
+						data.UpDelMatchs = append(data.UpDelMatchs, v.ID)
+					}
+				}
+			} else {
+				for _, v := range matchs {
+					data.UpDelMatchs = append(data.UpDelMatchs, v.ID)
+				}
+			}
+		}
+		// tag
+		if err = s.dao.DB.Model(&model.TagMap{}).Where("aid=?", arg.Aid).Where("is_deleted=?", _notDeleted).Find(&tags).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model TagMap(%+v) error(%v)", arg.TagIDs, err)
+			return
+		}
+		if len(tags) > 0 {
+			if len(arg.TagIDs) > 0 {
+				tagIDMap := make(map[int64]int64, len(arg.TagIDs))
+				for _, id := range arg.TagIDs {
+					tagIDMap[id] = id
+				}
+				for _, v := range tags {
+					if _, ok := tagIDMap[v.Tid]; !ok {
+						data.UpDelTags = append(data.UpDelTags, v.ID)
+					}
+				}
+			} else {
+				for _, v := range tags {
+					data.UpDelTags = append(data.UpDelTags, v.ID)
+				}
+			}
+		}
+		// team
+		if err = s.dao.DB.Model(&model.TeamMap{}).Where("aid=?", arg.Aid).Where("is_deleted=?", _notDeleted).Find(&teams).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model MatchMap(%+v) error(%v)", arg.MatchIDs, err)
+			return
+		}
+		if len(teams) > 0 {
+			if len(arg.TeamIDs) > 0 {
+				teamIDMap := make(map[int64]int64, len(arg.TeamIDs))
+				for _, id := range arg.TeamIDs {
+					teamIDMap[id] = id
+				}
+				for _, v := range teams {
+					if _, ok := teamIDMap[v.Tid]; !ok {
+						data.UpDelTeams = append(data.UpDelTeams, v.ID)
+					}
+				}
+			} else {
+				for _, v := range teams {
+					data.UpDelTeams = append(data.UpDelTeams, v.ID)
+				}
+			}
+		}
+		// year
+		if err = s.dao.DB.Model(&model.YearMap{}).Where("aid=?", arg.Aid).Where("is_deleted=?", _notDeleted).Find(&years).Error; err != nil {
+			log.Error("arcRelationChanges Arc s.dao.DB.Model MatchMap(%+v) error(%v)", arg.MatchIDs, err)
+			return
+		}
+		if len(years) > 0 {
+			if len(arg.Years) > 0 {
+				yearMap := make(map[int64]int64, len(arg.Years))
+				for _, id := range arg.Years {
+					yearMap[id] = id
+				}
+				for _, v := range years {
+					if _, ok := yearMap[v.Year]; !ok {
+						data.UpDelYears = append(data.UpDelYears, v.ID)
+					}
+				}
+			} else {
+				for _, v := range years {
+					data.UpDelYears = append(data.UpDelYears, v.ID)
+				}
+			}
+		}
+	}
+	return
+}
+
+// BatchDelArc batch del archive.
+func (s *Service) BatchDelArc(c context.Context, aids []int64) (err error) {
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Arc{}).Where("aid IN (?)", aids).Update(map[string]int{"is_deleted": _deleted}).Error; err != nil {
+		log.Error("BatchDelArc Arc s.dao.DB.Model Update(%+v) error(%v)", aids, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if err = tx.Model(&model.GIDMap{}).Where("oid IN (?)", aids).Update(map[string]int{"is_deleted": _deleted}).Error; err != nil {
+		log.Error("BatchDelArc GIDMap s.dao.DB.Model Update(%+v) error(%v)", aids, err)
+		err = tx.Rollback().Error
+		return
+	}
+	err = tx.Commit().Error
+	return
+}
+
+func upArcRelation(tx *gorm.DB, data *model.ArcRelation) (err error) {
+	if len(data.AddGids) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(data.AddGids)).Error; err != nil {
+			log.Error("upArcRelation GIDMap tx.Model Exec(%+v) error(%v)", data.AddGids, err)
+			return
+		}
+	}
+	if len(data.UpAddGids) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", data.UpAddGids).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("upArcRelation Tag tx.Model Updates(%+v) error(%v)", data.UpAddGids, err)
+			return
+		}
+	}
+	if len(data.UpDelGids) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", data.UpDelGids).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("upArcRelation Tag tx.Model Updates(%+v) error(%v)", data.UpDelGids, err)
+			return
+		}
+	}
+	if len(data.AddMatchs) > 0 {
+		if err = tx.Model(&model.MatchMap{}).Exec(model.BatchAddMachMapSQL(data.AddMatchs)).Error; err != nil {
+			log.Error("upArcRelation Match tx.Model Exec(%+v) error(%v)", data.AddMatchs, err)
+			return
+		}
+	}
+	if len(data.UpAddMatchs) > 0 {
+		if err = tx.Model(&model.MatchMap{}).Where("id IN (?)", data.UpAddMatchs).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("upArcRelation Match tx.Model Updates(%+v) error(%v)", data.UpAddMatchs, err)
+			return
+		}
+	}
+	if len(data.UpDelMatchs) > 0 {
+		if err = tx.Model(&model.MatchMap{}).Where("id IN (?)", data.UpDelMatchs).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("upArcRelation Match tx.Model Updates(%+v) error(%v)", data.UpDelMatchs, err)
+			return
+		}
+	}
+	if len(data.AddTags) > 0 {
+		if err = tx.Model(&model.TagMap{}).Exec(model.BatchAddTagMapSQL(data.AddTags)).Error; err != nil {
+			log.Error("upArcRelation Tag tx.Model Exec(%+v) error(%v)", data.AddTags, err)
+			return
+		}
+	}
+	if len(data.UpAddTags) > 0 {
+		if err = tx.Model(&model.TagMap{}).Where("id IN (?)", data.UpAddTags).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("upArcRelation Tag tx.Model Updates(%+v) error(%v)", data.UpAddTags, err)
+			return
+		}
+	}
+	if len(data.UpDelTags) > 0 {
+		if err = tx.Model(&model.TagMap{}).Where("id IN (?)", data.UpDelTags).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("upArcRelation Tag tx.Model Updates(%+v) error(%v)", data.UpDelTags, err)
+			return
+		}
+	}
+	if len(data.AddTeams) > 0 {
+		if err = tx.Model(&model.TeamMap{}).Exec(model.BatchAddTeamMapSQL(data.AddTeams)).Error; err != nil {
+			log.Error("upArcRelation Team tx.Model Exec(%+v) error(%v)", data.AddTeams, err)
+			return
+		}
+	}
+	if len(data.UpAddTeams) > 0 {
+		if err = tx.Model(&model.TeamMap{}).Where("id IN (?)", data.UpAddTeams).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("upArcRelation Team tx.Model Updates(%+v) error(%v)", data.UpAddTags, err)
+			return
+		}
+	}
+	if len(data.UpDelTeams) > 0 {
+		if err = tx.Model(&model.TeamMap{}).Where("id IN (?)", data.UpDelTeams).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("upArcRelation Team tx.Model Updates(%+v) error(%v)", data.UpDelTags, err)
+			return
+		}
+	}
+	if len(data.AddYears) > 0 {
+		if err = tx.Model(&model.YearMap{}).Exec(model.BatchAddYearMapSQL(data.AddYears)).Error; err != nil {
+			log.Error("upArcRelation Year tx.Model Exec(%+v) error(%v)", data.AddYears, err)
+			return
+		}
+	}
+	if len(data.UpAddYears) > 0 {
+		if err = tx.Model(&model.YearMap{}).Where("id IN (?)", data.UpAddYears).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("upArcRelation Year tx.Model Updates(%+v) error(%v)", data.UpAddTags, err)
+			return
+		}
+	}
+	if len(data.UpDelYears) > 0 {
+		if err = tx.Model(&model.YearMap{}).Where("id IN (?)", data.UpDelYears).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("upArcRelation Year tx.Model Updates(%+v) error(%v)", data.UpDelTags, err)
+			return
+		}
+	}
+	return
+}

app/admin/main/esports/service/archive_test.go

@@ -0,0 +1,49 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/esports/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_arcRelationChanges(t *testing.T) {
+	Convey("test arc relation", t, WithService(func(s *Service) {
+		arg := &model.ArcImportParam{
+			Aid:      2147483647,
+			Gids:     []int64{2, 3, 5},
+			MatchIDs: []int64{91},
+			TeamIDs:  []int64{2, 3, 4},
+			TagIDs:   []int64{2, 4},
+			Years:    []int64{1986, 2003},
+		}
+		data, err := s.arcRelationChanges(context.Background(), arg, _typeEdit)
+		So(err, ShouldBeNil)
+		for _, v := range data.AddTeams {
+			Printf("Add %+v \n", v)
+		}
+		for _, v := range data.UpAddTeams {
+			Printf("upAdd %+v \n", v)
+		}
+		for _, v := range data.UpDelTeams {
+			Printf("upDel %+v \n", v)
+		}
+	}))
+}
+
+func TestService_BatchAddArc(t *testing.T) {
+	Convey("test batch add arc", t, WithService(func(s *Service) {
+		arg := &model.ArcAddParam{
+			Aids:     []int64{44444444, 55555555},
+			Gids:     []int64{6},
+			MatchIDs: []int64{31},
+			TeamIDs:  []int64{3, 2},
+			TagIDs:   []int64{3},
+			Years:    []int64{2017, 2018},
+		}
+		err := s.BatchAddArc(context.Background(), arg)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/esports/service/contest.go

@@ -0,0 +1,452 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+var (
+	_emptyContestList = make([]*model.Contest, 0)
+	_emptyContestData = make([]*model.ContestData, 0)
+)
+
+const (
+	_sortDesc         = 1
+	_sortASC          = 2
+	_ReplyTypeContest = "27"
+)
+
+// ContestInfo .
+func (s *Service) ContestInfo(c context.Context, id int64) (data *model.ContestInfo, err error) {
+	var (
+		gameMap map[int64][]*model.Game
+		teamMap map[int64]*model.Team
+		teamIDs []int64
+		hasTeam bool
+	)
+	contest := new(model.Contest)
+	if err = s.dao.DB.Where("id=?", id).First(&contest).Error; err != nil {
+		log.Error("ContestInfo Error (%v)", err)
+		return
+	}
+	if gameMap, err = s.gameList(c, model.TypeContest, []int64{id}); err != nil {
+		return
+	}
+	if contest.HomeID > 0 {
+		teamIDs = append(teamIDs, contest.HomeID)
+	}
+	if contest.AwayID > 0 {
+		teamIDs = append(teamIDs, contest.AwayID)
+	}
+	if ids := unique(teamIDs); len(ids) > 0 {
+		var teams []*model.Team
+		if err = s.dao.DB.Model(&model.Team{}).Where("id IN (?)", ids).Find(&teams).Error; err != nil {
+			log.Error("ContestList team Error (%v)", err)
+			return
+		}
+		if len(teams) > 0 {
+			hasTeam = true
+		}
+		teamMap = make(map[int64]*model.Team, len(teams))
+		for _, v := range teams {
+			teamMap[v.ID] = v
+		}
+	}
+	data = &model.ContestInfo{Contest: contest}
+	if len(gameMap) > 0 {
+		if games, ok := gameMap[id]; ok {
+			data.Games = games
+		}
+	}
+	if len(data.Games) == 0 {
+		data.Games = _emptyGameList
+	}
+	if hasTeam {
+		if team, ok := teamMap[contest.HomeID]; ok {
+			data.HomeName = team.Title
+		}
+		if team, ok := teamMap[contest.AwayID]; ok {
+			data.AwayName = team.Title
+		}
+	}
+	var cDatas []*model.ContestData
+	if err = s.dao.DB.Model(&model.ContestData{}).Where(map[string]interface{}{"is_deleted": _notDeleted}).Where("cid IN (?)", []int64{id}).Find(&cDatas).Error; err != nil {
+		log.Error("ContestInfo Find ContestData Error (%v)", err)
+		return
+	}
+	data.Data = cDatas
+	return
+}
+
+// ContestList .
+func (s *Service) ContestList(c context.Context, mid, sid, pn, ps, srt int64) (list []*model.ContestInfo, count int64, err error) {
+	var contests []*model.Contest
+	source := s.dao.DB.Model(&model.Contest{})
+	if srt == _sortDesc {
+		source = source.Order("stime DESC")
+	} else if srt == _sortASC {
+		source = source.Order("stime ASC")
+	}
+	if mid > 0 {
+		source = source.Where("mid=?", mid)
+	}
+	if sid > 0 {
+		source = source.Where("sid=?", sid)
+	}
+	source.Count(&count)
+	if err = source.Offset((pn - 1) * ps).Limit(ps).Find(&contests).Error; err != nil {
+		log.Error("ContestList Error (%v)", err)
+		return
+	}
+	if len(contests) == 0 {
+		contests = _emptyContestList
+		return
+	}
+	if list, err = s.contestInfos(c, contests, true); err != nil {
+		log.Error("s.contestInfos Error (%v)", err)
+	}
+	return
+}
+
+func (s *Service) contestInfos(c context.Context, contests []*model.Contest, useGame bool) (list []*model.ContestInfo, err error) {
+	var (
+		conIDs, teamIDs            []int64
+		gameMap                    map[int64][]*model.Game
+		teamMap                    map[int64]*model.Team
+		cDataMap                   map[int64][]*model.ContestData
+		hasGame, hasTeam, hasCData bool
+	)
+	for _, v := range contests {
+		conIDs = append(conIDs, v.ID)
+		if v.HomeID > 0 {
+			teamIDs = append(teamIDs, v.HomeID)
+		}
+		if v.AwayID > 0 {
+			teamIDs = append(teamIDs, v.AwayID)
+		}
+		if v.SuccessTeam > 0 {
+			teamIDs = append(teamIDs, v.SuccessTeam)
+		}
+	}
+	if useGame {
+		if gameMap, err = s.gameList(c, model.TypeContest, conIDs); err != nil {
+			return
+		} else if len(gameMap) > 0 {
+			hasGame = true
+		}
+	}
+	if ids := unique(teamIDs); len(ids) > 0 {
+		var teams []*model.Team
+		if err = s.dao.DB.Model(&model.Team{}).Where("id IN (?)", ids).Find(&teams).Error; err != nil {
+			log.Error("ContestList team Error (%v)", err)
+			return
+		}
+		if len(teams) > 0 {
+			hasTeam = true
+		}
+		teamMap = make(map[int64]*model.Team, len(teams))
+		for _, v := range teams {
+			teamMap[v.ID] = v
+		}
+	}
+	if len(conIDs) > 0 {
+		var cDatas []*model.ContestData
+		if err = s.dao.DB.Model(&model.ContestData{}).Where(map[string]interface{}{"is_deleted": _notDeleted}).Where("cid IN (?)", conIDs).Find(&cDatas).Error; err != nil {
+			log.Error("ContestList Find ContestData Error (%v)", err)
+			return
+		}
+		if len(cDatas) > 0 {
+			hasCData = true
+		}
+		cDataMap = make(map[int64][]*model.ContestData, len(cDatas))
+		for _, v := range cDatas {
+			cDataMap[v.CID] = append(cDataMap[v.CID], v)
+		}
+	}
+	for _, v := range contests {
+		contest := &model.ContestInfo{Contest: v}
+		if hasGame {
+			if games, ok := gameMap[v.ID]; ok {
+				contest.Games = games
+			}
+		}
+		if len(contest.Games) == 0 {
+			contest.Games = _emptyGameList
+		}
+		if hasTeam {
+			if team, ok := teamMap[v.HomeID]; ok {
+				contest.HomeName = team.Title
+			}
+			if team, ok := teamMap[v.AwayID]; ok {
+				contest.AwayName = team.Title
+			}
+			if team, ok := teamMap[v.SuccessTeam]; ok {
+				contest.SuccessName = team.Title
+			}
+		}
+		if hasCData {
+			if cData, ok := cDataMap[v.ID]; ok {
+				contest.Data = cData
+			}
+		} else {
+			contest.Data = _emptyContestData
+		}
+		list = append(list, contest)
+	}
+	return
+}
+
+// AddContest .
+func (s *Service) AddContest(c context.Context, param *model.Contest, gids []int64) (err error) {
+	// TODO check name exist
+	// check sid
+	season := new(model.Season)
+	if err = s.dao.DB.Where("id=?", param.Sid).Where("status=?", _statusOn).First(&season).Error; err != nil {
+		log.Error("AddContest s.dao.DB.Where id(%d) error(%d)", param.Sid, err)
+		return
+	}
+	// check mid
+	match := new(model.Match)
+	if err = s.dao.DB.Where("id=?", param.Mid).Where("status=?", _statusOn).First(&match).Error; err != nil {
+		log.Error("AddContest s.dao.DB.Where id(%d) error(%d)", param.Mid, err)
+		return
+	}
+	// check game idsEsportsCDataErr
+	var (
+		games       []*model.Game
+		gidMaps     []*model.GIDMap
+		contestData []*model.ContestData
+	)
+	if param.DataType == 0 {
+		param.Data = ""
+		param.MatchID = 0
+	}
+	if param.Data != "" {
+		if err = json.Unmarshal([]byte(param.Data), &contestData); err != nil {
+			err = ecode.EsportsContestDataErr
+			return
+		}
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("AddContest check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("AddContest games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Model(&model.Contest{}).Create(param).Error; err != nil {
+		log.Error("AddContest tx.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	for _, v := range games {
+		gidMaps = append(gidMaps, &model.GIDMap{Type: model.TypeContest, Oid: param.ID, Gid: v.ID})
+	}
+	if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(gidMaps)).Error; err != nil {
+		log.Error("AddContest tx.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if len(contestData) > 0 {
+		if err = tx.Model(&model.Module{}).Exec(model.BatchAddCDataSQL(param.ID, contestData)).Error; err != nil {
+			log.Error("AddContest Module tx.Model Create(%+v) error(%v)", param, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if err = tx.Commit().Error; err != nil {
+		return
+	}
+	// register reply
+	if err = s.dao.RegReply(c, param.ID, param.Adid, _ReplyTypeContest); err != nil {
+		err = nil
+	}
+	return
+}
+
+// EditContest .
+func (s *Service) EditContest(c context.Context, param *model.Contest, gids []int64) (err error) {
+	var (
+		games                    []*model.Game
+		preGidMaps, addGidMaps   []*model.GIDMap
+		upGidMapAdd, upGidMapDel []int64
+	)
+	// TODO check name exist
+	// check sid
+	season := new(model.Season)
+	if err = s.dao.DB.Where("id=?", param.Sid).Where("status=?", _statusOn).First(&season).Error; err != nil {
+		log.Error("EditContest s.dao.DB.Where id(%d) error(%d)", param.Sid, err)
+		return
+	}
+	// check mid
+	match := new(model.Match)
+	if err = s.dao.DB.Where("id=?", param.Mid).Where("status=?", _statusOn).First(&match).Error; err != nil {
+		log.Error("EditContest s.dao.DB.Where id(%d) error(%d)", param.Mid, err)
+		return
+	}
+	preData := new(model.Contest)
+	if err = s.dao.DB.Where("id=?", param.ID).First(&preData).Error; err != nil {
+		log.Error("EditContest s.dao.DB.Where id(%d) error(%d)", param.ID, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("EditContest check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("EditContest games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	if err = s.dao.DB.Model(&model.GIDMap{}).Where("oid=?", param.ID).Where("type=?", model.TypeContest).Find(&preGidMaps).Error; err != nil {
+		log.Error("EditContest games(%v) not found", gids)
+		return
+	}
+	var (
+		newCData []*model.ContestData
+	)
+	if param.DataType == 0 {
+		param.Data = ""
+		param.MatchID = 0
+	}
+	if param.Data != "" {
+		if err = json.Unmarshal([]byte(param.Data), &newCData); err != nil {
+			err = ecode.EsportsContestDataErr
+			return
+		}
+	}
+	gidsMap := make(map[int64]int64, len(gids))
+	preGidsMap := make(map[int64]int64, len(preGidMaps))
+	for _, v := range gids {
+		gidsMap[v] = v
+	}
+	for _, v := range preGidMaps {
+		preGidsMap[v.Gid] = v.Gid
+		if _, ok := gidsMap[v.Gid]; ok {
+			if v.IsDeleted == 1 {
+				upGidMapAdd = append(upGidMapAdd, v.ID)
+			}
+		} else {
+			upGidMapDel = append(upGidMapDel, v.ID)
+		}
+	}
+	for _, gid := range gids {
+		if _, ok := preGidsMap[gid]; !ok {
+			addGidMaps = append(addGidMaps, &model.GIDMap{Type: model.TypeContest, Oid: param.ID, Gid: gid})
+		}
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Contest{}).Save(param).Error; err != nil {
+		log.Error("EditContest Update(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if len(upGidMapAdd) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapAdd).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("EditContest GIDMap Add(%+v) error(%v)", upGidMapAdd, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(upGidMapDel) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapDel).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("EditContest GIDMap Del(%+v) error(%v)", upGidMapDel, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(addGidMaps) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(addGidMaps)).Error; err != nil {
+			log.Error("EditContest GIDMap Create(%+v) error(%v)", addGidMaps, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	var (
+		mapOldCData, mapNewCData    map[int64]*model.ContestData
+		upCData, addCData, oldCData []*model.ContestData
+		delCData                    []int64
+	)
+	if len(newCData) > 0 {
+		// check module
+		if err = s.dao.DB.Model(&model.ContestData{}).Where("cid=?", param.ID).Where("is_deleted=?", _notDeleted).Find(&oldCData).Error; err != nil {
+			log.Error("EditContest s.dao.DB.Model Find (%+v) error(%v)", param.ID, err)
+			return
+		}
+		mapOldCData = make(map[int64]*model.ContestData, len(oldCData))
+		for _, v := range oldCData {
+			mapOldCData[v.ID] = v
+		}
+		//新数据在老数据中 更新老数据。新的数据不在老数据 添加新数据
+		for _, cData := range newCData {
+			if _, ok := mapOldCData[cData.ID]; ok {
+				upCData = append(upCData, cData)
+			} else {
+				addCData = append(addCData, cData)
+			}
+		}
+		mapNewCData = make(map[int64]*model.ContestData, len(oldCData))
+		for _, v := range newCData {
+			mapNewCData[v.ID] = v
+		}
+		//老数据在新中 上面已经处理。老数据不在新数据中 删除老数据
+		for _, cData := range oldCData {
+			if _, ok := mapNewCData[cData.ID]; !ok {
+				delCData = append(delCData, cData.ID)
+			}
+		}
+		if len(upCData) > 0 {
+			if err = tx.Model(&model.ContestData{}).Exec(model.BatchEditCDataSQL(upCData)).Error; err != nil {
+				log.Error("EditContest s.dao.DB.Model tx.Model Exec(%+v) error(%v)", upCData, err)
+				err = tx.Rollback().Error
+				return
+			}
+		}
+		if len(delCData) > 0 {
+			if err = tx.Model(&model.ContestData{}).Where("id IN (?)", delCData).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+				log.Error("EditContest s.dao.DB.Model Updates(%+v) error(%v)", delCData, err)
+				err = tx.Rollback().Error
+				return
+			}
+		}
+		if len(addCData) > 0 {
+			if err = tx.Model(&model.ContestData{}).Exec(model.BatchAddCDataSQL(param.ID, addCData)).Error; err != nil {
+				log.Error("EditContest s.dao.DB.Model Create(%+v) error(%v)", addCData, err)
+				err = tx.Rollback().Error
+				return
+			}
+		}
+	} else {
+		if err = tx.Model(&model.ContestData{}).Where("cid = ?", param.ID).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("EditContest s.dao.DB.Model Updates(%+v) error(%v)", param.ID, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// ForbidContest .
+func (s *Service) ForbidContest(c context.Context, id int64, state int) (err error) {
+	preContest := new(model.Contest)
+	if err = s.dao.DB.Where("id=?", id).First(&preContest).Error; err != nil {
+		log.Error("ContestForbid s.dao.DB.Where id(%d) error(%d)", id, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Contest{}).Where("id=?", id).Update(map[string]int{"status": state}).Error; err != nil {
+		log.Error("ContestForbid s.dao.DB.Model error(%v)", err)
+	}
+	return
+}

app/admin/main/esports/service/game.go

@@ -0,0 +1,129 @@
+package service
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/log"
+)
+
+var _emptyGameList = make([]*model.Game, 0)
+
+// GameInfo .
+func (s *Service) GameInfo(c context.Context, id int64) (game *model.Game, err error) {
+	game = new(model.Game)
+	if err = s.dao.DB.Where("id=?", id).First(&game).Error; err != nil {
+		log.Error("GameInfo Error (%v)", err)
+	}
+	return
+}
+
+// GameList .
+func (s *Service) GameList(c context.Context, pn, ps int64, title string) (list []*model.Game, count int64, err error) {
+	source := s.dao.DB.Model(&model.Game{})
+	if title != "" {
+		likeStr := fmt.Sprintf("%%%s%%", title)
+		source = source.Where("title like ?", likeStr)
+	}
+	source.Count(&count)
+	if err = source.Offset((pn - 1) * ps).Limit(ps).Find(&list).Error; err != nil {
+		log.Error("GameList Error (%v)", err)
+	}
+	return
+}
+
+// AddGame .
+func (s *Service) AddGame(c context.Context, param *model.Game) (err error) {
+	// TODO check name exist
+	if err = s.dao.DB.Model(&model.Game{}).Create(param).Error; err != nil {
+		log.Error("AddGame s.dao.DB.Model Create(%+v) error(%v)", param, err)
+	}
+	return
+}
+
+// EditGame .
+func (s *Service) EditGame(c context.Context, param *model.Game) (err error) {
+	preGame := new(model.Game)
+	if err = s.dao.DB.Where("id=?", param.ID).First(&preGame).Error; err != nil {
+		log.Error("EditGame s.dao.DB.Where id(%d) error(%d)", param.ID, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Update(param).Error; err != nil {
+		log.Error("EditGame s.dao.DB.Model Update(%+v) error(%v)", param, err)
+	}
+	return
+}
+
+// ForbidGame .
+func (s *Service) ForbidGame(c context.Context, id int64, state int) (err error) {
+	preGame := new(model.Game)
+	if err = s.dao.DB.Where("id=?", id).First(&preGame).Error; err != nil {
+		log.Error("GameForbid s.dao.DB.Where id(%d) error(%d)", id, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("id=?", id).Update(map[string]int{"status": state}).Error; err != nil {
+		log.Error("GameForbid s.dao.DB.Model error(%v)", err)
+	}
+	return
+}
+
+// gameList return game info map with oid key.
+func (s *Service) gameList(c context.Context, typ int, oids []int64) (list map[int64][]*model.Game, err error) {
+	var (
+		gidMaps []*model.GIDMap
+		gids    []int64
+		games   []*model.Game
+	)
+	if len(oids) == 0 {
+		return
+	}
+	if err = s.dao.DB.Model(&model.GIDMap{}).Where("is_deleted=?", _notDeleted).Where("type=?", typ).Where("oid IN(?)", oids).Find(&gidMaps).Error; err != nil {
+		log.Error("gameList gidMap Error (%v)", err)
+		return
+	}
+	if len(gidMaps) == 0 {
+		return
+	}
+	gidMap := make(map[int64]int64, len(gidMaps))
+	oidGidMap := make(map[int64][]int64, len(gidMaps))
+	for _, v := range gidMaps {
+		oidGidMap[v.Oid] = append(oidGidMap[v.Oid], v.Gid)
+		if _, ok := gidMap[v.Gid]; ok {
+			continue
+		}
+		gids = append(gids, v.Gid)
+		gidMap[v.Gid] = v.Gid
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN(?)", gids).Find(&games).Error; err != nil {
+		log.Error("gameList games Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		return
+	}
+	gameMap := make(map[int64]*model.Game, len(games))
+	for _, v := range games {
+		gameMap[v.ID] = v
+	}
+	list = make(map[int64][]*model.Game, len(oids))
+	for _, oid := range oids {
+		if ids, ok := oidGidMap[oid]; ok {
+			for _, id := range ids {
+				if game, ok := gameMap[id]; ok {
+					list[oid] = append(list[oid], game)
+				}
+			}
+		}
+	}
+	return
+}
+
+// Types return data page game types.
+func (s *Service) Types(c context.Context) (list map[int64]string, err error) {
+	list = make(map[int64]string, len(s.c.GameTypes))
+	for _, tp := range s.c.GameTypes {
+		list[tp.ID] = tp.Name
+	}
+	return
+}

app/admin/main/esports/service/game_test.go

@@ -0,0 +1,21 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	"go-common/app/admin/main/esports/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_GameList(t *testing.T) {
+	Convey("test game list", t, WithService(func(s *Service) {
+		oids := []int64{21, 16}
+		data, err := s.gameList(context.Background(), model.TypeTeam, oids)
+		So(err, ShouldBeNil)
+		bs, _ := json.Marshal(data)
+		Printf(string(bs))
+	}))
+}

app/admin/main/esports/service/match.go

@@ -0,0 +1,198 @@
+package service
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+var _emptyMatchList = make([]*model.Match, 0)
+
+// MatchInfo .
+func (s *Service) MatchInfo(c context.Context, id int64) (data *model.MatchInfo, err error) {
+	var gameMap map[int64][]*model.Game
+	match := new(model.Match)
+	if err = s.dao.DB.Where("id=?", id).First(&match).Error; err != nil {
+		log.Error("MatchInfo Error (%v)", err)
+		return
+	}
+	if gameMap, err = s.gameList(c, model.TypeMatch, []int64{id}); err != nil {
+		return
+	}
+	if games, ok := gameMap[id]; ok {
+		data = &model.MatchInfo{Match: match, Games: games}
+	} else {
+		data = &model.MatchInfo{Match: match, Games: _emptyGameList}
+	}
+	return
+}
+
+// MatchList .
+func (s *Service) MatchList(c context.Context, pn, ps int64, title string) (list []*model.MatchInfo, count int64, err error) {
+	var (
+		matchs   []*model.Match
+		matchIDs []int64
+		gameMap  map[int64][]*model.Game
+	)
+	source := s.dao.DB.Model(&model.Match{})
+	if title != "" {
+		likeStr := fmt.Sprintf("%%%s%%", title)
+		source = source.Where("title like ?", likeStr)
+	}
+	source.Count(&count)
+	if err = source.Offset((pn - 1) * ps).Order("rank DESC,id ASC").Limit(ps).Find(&matchs).Error; err != nil {
+		log.Error("MatchList Error (%v)", err)
+		return
+	}
+	if len(matchs) == 0 {
+		return
+	}
+	for _, v := range matchs {
+		matchIDs = append(matchIDs, v.ID)
+	}
+	if gameMap, err = s.gameList(c, model.TypeMatch, matchIDs); err != nil {
+		return
+	}
+	for _, v := range matchs {
+		if games, ok := gameMap[v.ID]; ok {
+			list = append(list, &model.MatchInfo{Match: v, Games: games})
+		} else {
+			list = append(list, &model.MatchInfo{Match: v, Games: _emptyGameList})
+		}
+	}
+	return
+}
+
+// AddMatch .
+func (s *Service) AddMatch(c context.Context, param *model.Match, gids []int64) (err error) {
+	// check game ids
+	var (
+		games   []*model.Game
+		gidMaps []*model.GIDMap
+	)
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("AddMatch check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("AddMatch games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Match{}).Create(param).Error; err != nil {
+		log.Error("AddMatch s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	for _, v := range games {
+		gidMaps = append(gidMaps, &model.GIDMap{Type: model.TypeMatch, Oid: param.ID, Gid: v.ID})
+	}
+	if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(gidMaps)).Error; err != nil {
+		log.Error("AddMatch s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// EditMatch .
+func (s *Service) EditMatch(c context.Context, param *model.Match, gids []int64) (err error) {
+	var (
+		games                    []*model.Game
+		preGidMaps, addGidMaps   []*model.GIDMap
+		upGidMapAdd, upGidMapDel []int64
+	)
+	preData := new(model.Match)
+	if err = s.dao.DB.Where("id=?", param.ID).First(&preData).Error; err != nil {
+		log.Error("EditMatch s.dao.DB.Where id(%d) error(%d)", param.ID, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("AddMatch check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("AddMatch games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	if err = s.dao.DB.Model(&model.GIDMap{}).Where("oid=?", param.ID).Where("type=?", model.TypeMatch).Find(&preGidMaps).Error; err != nil {
+		log.Error("AddMatch games(%v) not found", gids)
+		return
+	}
+	gidsMap := make(map[int64]int64, len(gids))
+	preGidsMap := make(map[int64]int64, len(preGidMaps))
+	for _, v := range gids {
+		gidsMap[v] = v
+	}
+	for _, v := range preGidMaps {
+		preGidsMap[v.Gid] = v.Gid
+		if _, ok := gidsMap[v.Gid]; ok {
+			if v.IsDeleted == 1 {
+				upGidMapAdd = append(upGidMapAdd, v.ID)
+			}
+		} else {
+			upGidMapDel = append(upGidMapDel, v.ID)
+		}
+	}
+	for _, gid := range gids {
+		if _, ok := preGidsMap[gid]; !ok {
+			addGidMaps = append(addGidMaps, &model.GIDMap{Type: model.TypeMatch, Oid: param.ID, Gid: gid})
+		}
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Match{}).Save(param).Error; err != nil {
+		log.Error("EditMatch Match Update(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if len(upGidMapAdd) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapAdd).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("EditMatch GIDMap Add(%+v) error(%v)", upGidMapAdd, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(upGidMapDel) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapDel).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("EditMatch GIDMap Del(%+v) error(%v)", upGidMapDel, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(addGidMaps) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(addGidMaps)).Error; err != nil {
+			log.Error("EditMatch GIDMap Create(%+v) error(%v)", addGidMaps, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// ForbidMatch .
+func (s *Service) ForbidMatch(c context.Context, id int64, state int) (err error) {
+	preMatch := new(model.Match)
+	if err = s.dao.DB.Where("id=?", id).First(&preMatch).Error; err != nil {
+		log.Error("MatchForbid s.dao.DB.Where id(%d) error(%d)", id, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Match{}).Where("id=?", id).Update(map[string]int{"status": state}).Error; err != nil {
+		log.Error("MatchForbid s.dao.DB.Model error(%v)", err)
+	}
+	return
+}

app/admin/main/esports/service/match_active.go

@@ -0,0 +1,345 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"sync"
+
+	"go-common/app/admin/main/esports/model"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_arcsSize     = 50
+	_ReplyTypeAct = "25"
+)
+
+var (
+	_emptyModules = make([]*model.Module, 0)
+	_emptMatchMod = make([]*model.MatchModule, 0)
+	_emptyActive  = make([]*model.MatchModule, 0)
+)
+
+// AddAct .
+func (s *Service) AddAct(c context.Context, param *model.ParamMA) (arcs map[string][]int64, err error) {
+	var ms []*model.Module
+	if param.Modules != "" {
+		if err = json.Unmarshal([]byte(param.Modules), &ms); err != nil {
+			err = ecode.EsportsActModErr
+			return
+		}
+		if arcs, err = s.checkArc(c, ms); err != nil {
+			return
+		}
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Model(&model.MatchActive{}).Create(&param.MatchActive).Error; err != nil {
+		log.Error("AddAct MatchActive tx.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	maID := param.ID
+	if len(ms) > 0 {
+		if err = tx.Model(&model.Module{}).Exec(model.BatchAddModuleSQL(maID, ms)).Error; err != nil {
+			log.Error("AddAct Module tx.Model Create(%+v) error(%v)", param, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if err = tx.Commit().Error; err != nil {
+		return
+	}
+	// register reply
+	if err = s.dao.RegReply(c, maID, param.Adid, _ReplyTypeAct); err != nil {
+		err = nil
+	}
+	return
+}
+
+// EditAct .
+func (s *Service) EditAct(c context.Context, param *model.ParamMA) (arcs map[string][]int64, err error) {
+	var (
+		tmpMs, upM, addM, ms []*model.Module
+		mapMID               map[int64]int64
+		pMID                 map[int64]*model.Module
+		delM                 []int64
+	)
+	if param.Modules != "" {
+		if err = json.Unmarshal([]byte(param.Modules), &ms); err != nil {
+			err = ecode.EsportsActModErr
+			return
+		}
+		if arcs, err = s.checkArc(c, ms); err != nil {
+			return
+		}
+	}
+	// check module
+	if err = s.dao.DB.Model(&model.Module{}).Where("ma_id=?", param.ID).Where("status=?", _notDeleted).Find(&tmpMs).Error; err != nil {
+		log.Error("EditAct s.dao.DB.Model Find (%+v) error(%v)", param.ID, err)
+		return
+	}
+	mapMID = make(map[int64]int64, len(tmpMs))
+	for _, m := range tmpMs {
+		mapMID[m.ID] = m.MaID
+	}
+	pMID = make(map[int64]*model.Module, len(ms))
+	for _, m := range ms {
+		if _, ok := mapMID[m.ID]; m.ID > 0 && !ok {
+			err = ecode.EsportsActModNot
+			return
+		}
+		pMID[m.ID] = m
+		if m.ID == 0 {
+			addM = append(addM, m)
+		}
+	}
+	for _, m := range tmpMs {
+		if mod, ok := pMID[m.ID]; ok {
+			upM = append(upM, mod)
+		} else {
+			delM = append(delM, m.ID)
+		}
+	}
+	// save
+	tx := s.dao.DB.Begin()
+	upFields := map[string]interface{}{"sid": param.Sid, "mid": param.Mid, "background": param.Background,
+		"back_color": param.BackColor, "color_step": param.ColorStep, "live_id": param.LiveID, "intr": param.Intr,
+		"focus": param.Focus, "url": param.URL, "status": param.Status,
+		"h5_background": param.H5Background, "h5_back_color": param.H5BackColor,
+		"h5_focus": param.H5Focus, "h5_url": param.H5URL,
+		"intr_logo": param.IntrLogo, "intr_title": param.IntrTitle, "intr_text": param.IntrText}
+	if err = tx.Model(&model.MatchActive{}).Where("id = ?", param.ID).Update(upFields).Error; err != nil {
+		log.Error("EditAct MatchActive tx.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if len(upM) > 0 {
+		if err = tx.Model(&model.Module{}).Exec(model.BatchEditModuleSQL(upM)).Error; err != nil {
+			log.Error("EditAct Module tx.Model Exec(%+v) error(%v)", upM, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(delM) > 0 {
+		if err = tx.Model(&model.Module{}).Where("id IN (?)", delM).Updates(map[string]interface{}{"status": _deleted}).Error; err != nil {
+			log.Error("EditAct Module tx.Model Updates(%+v) error(%v)", delM, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(addM) > 0 {
+		if err = tx.Model(&model.Module{}).Exec(model.BatchAddModuleSQL(param.ID, addM)).Error; err != nil {
+			log.Error("EditAct Module tx.Model Create(%+v) error(%v)", addM, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+func (s *Service) checkArc(c context.Context, ms []*model.Module) (rsAids map[string][]int64, err error) {
+	var (
+		name       string
+		aids       []int64
+		allAids    []int64
+		tmpMap     map[int64]struct{}
+		repeatAids []int64
+		wrongAids  []int64
+		isWrong    bool
+	)
+	rsAids = make(map[string][]int64, 2)
+	for _, m := range ms {
+		// check name only .
+		if m.Name != "" && name == m.Name {
+			err = ecode.EsportsModNameErr
+			return
+		}
+		name = m.Name
+		if aids, err = xstr.SplitInts(m.Oids); err != nil {
+			err = ecode.RequestErr
+			return
+		}
+		tmpMap = make(map[int64]struct{})
+		for _, aid := range aids {
+			if _, ok := tmpMap[aid]; ok {
+				repeatAids = append(repeatAids, aid)
+				continue
+			}
+			tmpMap[aid] = struct{}{}
+		}
+		allAids = append(allAids, aids...)
+	}
+	// check aids .
+	if wrongAids, err = s.wrongArc(c, allAids); err != nil {
+		err = ecode.EsportsArcServerErr
+		return
+	}
+	if len(repeatAids) > 0 {
+		rsAids["repeat"] = repeatAids
+		isWrong = true
+	}
+	if len(wrongAids) > 0 {
+		rsAids["wrong"] = wrongAids
+		isWrong = true
+	}
+	if isWrong {
+		err = ecode.EsportsModArcErr
+	}
+	return
+}
+
+func (s *Service) wrongArc(c context.Context, aids []int64) (list []int64, err error) {
+	var (
+		arcErr    error
+		arcNormal map[int64]struct{}
+		mutex     = sync.Mutex{}
+	)
+	group, errCtx := errgroup.WithContext(c)
+	aidsLen := len(aids)
+	arcNormal = make(map[int64]struct{}, aidsLen)
+	for i := 0; i < aidsLen; i += _arcsSize {
+		var partAids []int64
+		if i+_arcsSize > aidsLen {
+			partAids = aids[i:]
+		} else {
+			partAids = aids[i : i+_arcsSize]
+		}
+		group.Go(func() (err error) {
+			var tmpRes *arcmdl.ArcsReply
+			if tmpRes, arcErr = s.arcClient.Arcs(errCtx, &arcmdl.ArcsRequest{Aids: partAids}); arcErr != nil {
+				log.Error("wrongArc s.arcClient.Arcs(%v) error %v", partAids, err)
+				return arcErr
+			}
+			if tmpRes != nil {
+				for _, arc := range tmpRes.Arcs {
+					if arc != nil && arc.IsNormal() {
+						mutex.Lock()
+						arcNormal[arc.Aid] = struct{}{}
+						mutex.Unlock()
+					}
+				}
+			}
+			return nil
+		})
+	}
+	if err = group.Wait(); err != nil {
+		return
+	}
+	for _, aid := range aids {
+		if _, ok := arcNormal[aid]; !ok {
+			list = append(list, aid)
+		}
+	}
+	return
+}
+
+// ForbidAct .
+func (s *Service) ForbidAct(c context.Context, id int64, state int) (err error) {
+	if err = s.dao.DB.Model(&model.MatchActive{}).Where("id=?", id).Updates(map[string]interface{}{"status": state}).Error; err != nil {
+		log.Error("ForbidAct MatchActive s.dao.DB.Model Updates(%d) error(%v)", id, err)
+	}
+	return
+}
+
+// ListAct .
+func (s *Service) ListAct(c context.Context, mid, pn, ps int64) (rs []*model.MatchModule, count int64, err error) {
+	var (
+		mas                                          []*model.MatchActive
+		maIDs, matchIDs, seasonIDs                   []int64
+		mapMs                                        map[int64][]*model.Module
+		mapMatch                                     map[int64]*model.Match
+		mapSeaon                                     map[int64]*model.Season
+		matchTitle, matchSub, seasonTitle, seasonSub string
+	)
+	maDB := s.dao.DB.Model(&model.MatchActive{})
+	if mid > 0 {
+		maDB = maDB.Where("mid=?", mid)
+	}
+	maDB.Count(&count)
+	if count == 0 {
+		rs = _emptyActive
+	}
+	if err = maDB.Offset((pn - 1) * ps).Order("id ASC").Limit(ps).Find(&mas).Error; err != nil {
+		log.Error("ListAct MatchActive s.dao.DB.Model Find error(%v)", err)
+		return
+	}
+	if len(mas) == 0 {
+		rs = _emptMatchMod
+		return
+	}
+	for _, ma := range mas {
+		maIDs = append(maIDs, ma.ID)
+		matchIDs = append(matchIDs, ma.Mid)
+		seasonIDs = append(seasonIDs, ma.Sid)
+	}
+	if ids := unique(matchIDs); len(ids) > 0 {
+		var matchs []*model.Match
+		if err = s.dao.DB.Model(&model.Match{}).Where("id IN (?)", ids).Find(&matchs).Error; err != nil {
+			log.Error("ListAct match Error (%v)", err)
+			return
+		}
+		mapMatch = make(map[int64]*model.Match, len(matchs))
+		for _, v := range matchs {
+			mapMatch[v.ID] = v
+		}
+	}
+	if ids := unique(seasonIDs); len(ids) > 0 {
+		var seasons []*model.Season
+		if err = s.dao.DB.Model(&model.Match{}).Where("id IN (?)", ids).Find(&seasons).Error; err != nil {
+			log.Error("ListAct season Error (%v)", err)
+			return
+		}
+		mapSeaon = make(map[int64]*model.Season, len(seasonIDs))
+		for _, v := range seasons {
+			mapSeaon[v.ID] = v
+		}
+	}
+	if mapMs, err = s.modules(maIDs, count); err != nil {
+		log.Error("ListAct s.modules maIDs(%+v) faild(%+v)", maIDs, err)
+		return
+	}
+	for _, ma := range mas {
+		if match, ok := mapMatch[ma.Mid]; ok {
+			matchTitle = match.Title
+			matchSub = match.SubTitle
+		} else {
+			matchTitle = ""
+			matchSub = ""
+		}
+		if season, ok := mapSeaon[ma.Sid]; ok {
+			seasonTitle = season.Title
+			seasonSub = season.SubTitle
+		} else {
+			seasonTitle = ""
+			seasonSub = ""
+		}
+		if rsMs, ok := mapMs[ma.ID]; ok {
+			tmpMs := rsMs
+			rs = append(rs, &model.MatchModule{MatchActive: ma, Modules: tmpMs, MatchTitle: matchTitle, MatchSubTitle: matchSub, SeasonTitle: seasonTitle, SeasonSubTitle: seasonSub})
+		} else {
+			rs = append(rs, &model.MatchModule{MatchActive: ma, Modules: _emptyModules, MatchTitle: matchTitle, MatchSubTitle: matchSub, SeasonTitle: seasonTitle, SeasonSubTitle: seasonSub})
+		}
+	}
+	return
+}
+
+func (s *Service) modules(maIDs []int64, count int64) (rs map[int64][]*model.Module, err error) {
+	var ms []*model.Module
+	if err = s.dao.DB.Model(&model.Module{}).Where("ma_id in(?)", maIDs).Where("status=?", _notDeleted).Find(&ms).Order("ma_id ASC").Error; err != nil {
+		err = errors.Wrap(err, "modules map Model Find")
+		return
+	}
+	rs = make(map[int64][]*model.Module, count)
+	for _, m := range ms {
+		tmpM := m
+		rs[tmpM.MaID] = append(rs[tmpM.MaID], tmpM)
+	}
+	return
+}

app/admin/main/esports/service/match_detail.go

@@ -0,0 +1,67 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// AddDetail .
+func (s *Service) AddDetail(c context.Context, param *model.MatchDetail) (err error) {
+	if err = s.dao.DB.Model(&model.MatchDetail{}).Create(param).Error; err != nil {
+		log.Error("AddDetail MatchDetail db.Model Create error(%v)", err)
+	}
+	return
+}
+
+// EditDetail .
+func (s *Service) EditDetail(c context.Context, param *model.MatchDetail) (err error) {
+	upFields := map[string]interface{}{"ma_id": param.MaID, "game_type": param.GameType, "stime": param.Stime,
+		"etime": param.Etime, "game_stage": param.GameStage, "knockout_type": param.KnockoutType,
+		"winner_type": param.WinnerType, "ScoreID": param.ScoreID, "status": param.Status, "online": param.Online}
+	if err = s.dao.DB.Model(&model.MatchDetail{}).Where("id=?", param.ID).Update(upFields).Error; err != nil {
+		log.Error("EditDetail MatchDetail db.Model Update error(%v)", err)
+	}
+	return
+}
+
+// ForbidDetail .
+func (s *Service) ForbidDetail(c context.Context, id int64, state int) (err error) {
+	if err = s.dao.DB.Model(&model.MatchDetail{}).Where("id=?", id).Updates(map[string]interface{}{"status": state}).Error; err != nil {
+		log.Error("ForbidDetail MatchDetail db.Model Updates(%d) error(%v)", id, err)
+	}
+	return
+}
+
+// UpOnline .
+func (s *Service) UpOnline(c context.Context, id int64, onLine int64) (err error) {
+	if onLine == _online {
+		var count int64
+		treeDB := s.dao.DB.Model(&model.Tree{}).Where("mad_id=?", id).Where("is_deleted=0")
+		if err = treeDB.Error; err != nil {
+			log.Error("upOnline  treeDB  Error (%v)", err)
+			return
+		}
+		treeDB.Count(&count)
+		if count == 0 {
+			err = ecode.EsportsTreeEmptyErr
+			return
+		}
+	}
+	if err = s.dao.DB.Model(&model.MatchDetail{}).Where("id=?", id).Updates(map[string]interface{}{"online": onLine}).Error; err != nil {
+		log.Error("UpOnline s.dao.DB.Model  Updates(%+v) error(%v)", id, err)
+	}
+	return
+}
+
+// ListDetail .
+func (s *Service) ListDetail(c context.Context, maID, pn, ps int64) (rs []*model.MatchDetail, count int64, err error) {
+	db := s.dao.DB.Model(&model.MatchDetail{}).Offset((pn-1)*ps).Where("ma_id=?", maID).Order("id ASC").Limit(ps).Find(&rs)
+	if err = db.Error; err != nil {
+		log.Error("ListDetail MatchDetail db.Model Find error(%v)", err)
+	}
+	db.Count(&count)
+	return
+}

app/admin/main/esports/service/match_test.go

@@ -0,0 +1,27 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/esports/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_AddMatch(t *testing.T) {
+	Convey("test add match", t, WithService(func(s *Service) {
+		gids := []int64{1}
+		err := s.AddMatch(context.Background(), &model.Match{Title: "match"}, gids)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestService_ForbidMatch(t *testing.T) {
+	Convey("test forbid match", t, WithService(func(s *Service) {
+		mid := int64(1)
+		state := 0
+		err := s.ForbidMatch(context.Background(), mid, state)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/esports/service/season.go

@@ -0,0 +1,194 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// SeasonInfo .
+func (s *Service) SeasonInfo(c context.Context, id int64) (data *model.SeasonInfo, err error) {
+	var gameMap map[int64][]*model.Game
+	season := new(model.Season)
+	if err = s.dao.DB.Where("id=?", id).First(&season).Error; err != nil {
+		log.Error("SeasonInfo Error (%v)", err)
+		return
+	}
+	if gameMap, err = s.gameList(c, model.TypeSeason, []int64{id}); err != nil {
+		return
+	}
+	if games, ok := gameMap[id]; ok {
+		data = &model.SeasonInfo{Season: season, Games: games}
+	} else {
+		data = &model.SeasonInfo{Season: season, Games: _emptyGameList}
+	}
+	return
+}
+
+// SeasonList .
+func (s *Service) SeasonList(c context.Context, mid, pn, ps int64) (list []*model.SeasonInfo, count int64, err error) {
+	var (
+		seasons   []*model.Season
+		seasonIDs []int64
+		gameMap   map[int64][]*model.Game
+	)
+	source := s.dao.DB.Model(&model.Season{})
+	if mid > 0 {
+		source = source.Where("mid=?", mid)
+	}
+	source.Count(&count)
+	if err = source.Offset((pn - 1) * ps).Order("rank DESC,id ASC").Limit(ps).Find(&seasons).Error; err != nil {
+		log.Error("SeasonList Error (%v)", err)
+		return
+	}
+	if len(seasons) == 0 {
+		return
+	}
+	for _, v := range seasons {
+		seasonIDs = append(seasonIDs, v.ID)
+	}
+	if gameMap, err = s.gameList(c, model.TypeSeason, seasonIDs); err != nil {
+		return
+	}
+	for _, v := range seasons {
+		if games, ok := gameMap[v.ID]; ok {
+			list = append(list, &model.SeasonInfo{Season: v, Games: games})
+		} else {
+			list = append(list, &model.SeasonInfo{Season: v, Games: _emptyGameList})
+		}
+	}
+	return
+}
+
+// AddSeason .
+func (s *Service) AddSeason(c context.Context, param *model.Season, gids []int64) (err error) {
+	var (
+		games   []*model.Game
+		gidMaps []*model.GIDMap
+	)
+	// TODO check name exist
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("AddSeason check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("AddSeason games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Season{}).Create(param).Error; err != nil {
+		log.Error("AddSeason s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	for _, v := range games {
+		gidMaps = append(gidMaps, &model.GIDMap{Type: model.TypeSeason, Oid: param.ID, Gid: v.ID})
+	}
+	if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(gidMaps)).Error; err != nil {
+		log.Error("AddSeason s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// EditSeason .
+func (s *Service) EditSeason(c context.Context, param *model.Season, gids []int64) (err error) {
+	var (
+		games                    []*model.Game
+		preGidMaps, addGidMaps   []*model.GIDMap
+		upGidMapAdd, upGidMapDel []int64
+	)
+	preData := new(model.Season)
+	if err = s.dao.DB.Where("id=?", param.ID).First(&preData).Error; err != nil {
+		log.Error("EditSeason s.dao.DB.Where id(%d) error(%d)", param.ID, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("EditSeason check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("EditSeason games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	if err = s.dao.DB.Model(&model.GIDMap{}).Where("oid=?", param.ID).Where("type=?", model.TypeSeason).Find(&preGidMaps).Error; err != nil {
+		log.Error("EditSeason games(%v) not found", gids)
+		return
+	}
+	gidsMap := make(map[int64]int64, len(gids))
+	preGidsMap := make(map[int64]int64, len(preGidMaps))
+	for _, v := range gids {
+		gidsMap[v] = v
+	}
+	for _, v := range preGidMaps {
+		preGidsMap[v.Gid] = v.Gid
+		if _, ok := gidsMap[v.Gid]; ok {
+			if v.IsDeleted == 1 {
+				upGidMapAdd = append(upGidMapAdd, v.ID)
+			}
+		} else {
+			upGidMapDel = append(upGidMapDel, v.ID)
+		}
+	}
+	for _, gid := range gids {
+		if _, ok := preGidsMap[gid]; !ok {
+			addGidMaps = append(addGidMaps, &model.GIDMap{Type: model.TypeSeason, Oid: param.ID, Gid: gid})
+		}
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Season{}).Save(param).Error; err != nil {
+		log.Error("EditSeason Match Update(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if len(upGidMapAdd) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapAdd).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("EditSeason GIDMap Add(%+v) error(%v)", upGidMapAdd, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(upGidMapDel) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapDel).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("EditSeason GIDMap Del(%+v) error(%v)", upGidMapDel, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(addGidMaps) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(addGidMaps)).Error; err != nil {
+			log.Error("EditSeason GIDMap Create(%+v) error(%v)", addGidMaps, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// ForbidSeason .
+func (s *Service) ForbidSeason(c context.Context, id int64, state int) (err error) {
+	preSeason := new(model.Season)
+	if err = s.dao.DB.Where("id=?", id).First(&preSeason).Error; err != nil {
+		log.Error("SeasonForbid s.dao.DB.Where id(%d) error(%d)", id, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Season{}).Where("id=?", id).Update(map[string]int{"status": state}).Error; err != nil {
+		log.Error("SeasonForbid s.dao.DB.Model error(%v)", err)
+	}
+	return
+}

app/admin/main/esports/service/service.go

@@ -0,0 +1,62 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/esports/conf"
+	"go-common/app/admin/main/esports/dao"
+	accclient "go-common/app/service/main/account/api"
+	accwarden "go-common/app/service/main/account/api"
+	arcclient "go-common/app/service/main/archive/api"
+)
+
+// Service biz service def.
+type Service struct {
+	c         *conf.Config
+	dao       *dao.Dao
+	arcClient arcclient.ArchiveClient
+	accClient accwarden.AccountClient
+}
+
+const (
+	_notDeleted = 0
+	_deleted    = 1
+	_online     = 1
+	_downLine   = 0
+	_statusOn   = 0
+	_statusAll  = -1
+)
+
+// New new a Service and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: dao.New(c),
+	}
+	var err error
+	if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil {
+		panic(err)
+	}
+	if s.accClient, err = accclient.NewClient(c.AccClient); err != nil {
+		panic(err)
+	}
+	return s
+}
+
+// Ping .
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+func unique(ids []int64) (outs []int64) {
+	idMap := make(map[int64]int64, len(ids))
+	for _, v := range ids {
+		if _, ok := idMap[v]; ok {
+			continue
+		} else {
+			idMap[v] = v
+		}
+		outs = append(outs, v)
+	}
+	return
+}

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

@@ -0,0 +1,24 @@
+package service
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/admin/main/esports/conf"
+)
+
+var svf *Service
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		dir, _ := filepath.Abs("../cmd/esports-admin-test.toml")
+		flag.Set("conf", dir)
+		conf.Init()
+		if svf == nil {
+			svf = New(conf.Conf)
+		}
+		time.Sleep(2 * time.Second)
+		f(svf)
+	}
+}

app/admin/main/esports/service/tag.go

@@ -0,0 +1,62 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/log"
+)
+
+var _emptyTagList = make([]*model.Tag, 0)
+
+// TagInfo .
+func (s *Service) TagInfo(c context.Context, id int64) (data *model.Tag, err error) {
+	data = new(model.Tag)
+	if err = s.dao.DB.Model(&model.Tag{}).Where("id=?", id).First(&data).Error; err != nil {
+		log.Error("TagInfo Error (%v)", err)
+	}
+	return
+}
+
+// TagList .
+func (s *Service) TagList(c context.Context, pn, ps int64) (list []*model.Tag, count int64, err error) {
+	s.dao.DB.Model(&model.Tag{}).Count(&count)
+	if err = s.dao.DB.Model(&model.Tag{}).Offset((pn - 1) * ps).Limit(ps).Find(&list).Error; err != nil {
+		log.Error("TagList Error (%v)", err)
+	}
+	return
+}
+
+// AddTag .
+func (s *Service) AddTag(c context.Context, param *model.Tag) (err error) {
+	if err = s.dao.DB.Model(&model.Tag{}).Create(param).Error; err != nil {
+		log.Error("AddTag s.dao.DB.Model Create(%+v) error(%v)", param, err)
+	}
+	return
+}
+
+// EditTag .
+func (s *Service) EditTag(c context.Context, param *model.Tag) (err error) {
+	preData := new(model.Tag)
+	if err = s.dao.DB.Where("id=?", param.ID).First(&preData).Error; err != nil {
+		log.Error("EditTag s.dao.DB.Where id(%d) error(%d)", param.ID, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Tag{}).Update(param).Error; err != nil {
+		log.Error("EditTag s.dao.DB.Model Update(%+v) error(%v)", param, err)
+	}
+	return
+}
+
+// ForbidTag .
+func (s *Service) ForbidTag(c context.Context, id int64, state int) (err error) {
+	preTag := new(model.Tag)
+	if err = s.dao.DB.Where("id=?", id).First(&preTag).Error; err != nil {
+		log.Error("TagForbid s.dao.DB.Where id(%d) error(%d)", id, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Tag{}).Where("id=?", id).Update(map[string]int{"status": state}).Error; err != nil {
+		log.Error("TagForbid s.dao.DB.Model error(%v)", err)
+	}
+	return
+}

app/admin/main/esports/service/team.go

@@ -0,0 +1,200 @@
+package service
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+var _emptyTeamList = make([]*model.Team, 0)
+
+// TeamInfo .
+func (s *Service) TeamInfo(c context.Context, id int64) (data *model.TeamInfo, err error) {
+	var gameMap map[int64][]*model.Game
+	team := new(model.Team)
+	if err = s.dao.DB.Where("id=?", id).Where("is_deleted=?", _notDeleted).First(&team).Error; err != nil {
+		log.Error("TeamInfo Error (%v)", err)
+		return
+	}
+	if gameMap, err = s.gameList(c, model.TypeTeam, []int64{id}); err != nil {
+		return
+	}
+	if games, ok := gameMap[id]; ok {
+		data = &model.TeamInfo{Team: team, Games: games}
+	} else {
+		data = &model.TeamInfo{Team: team, Games: _emptyGameList}
+	}
+	return
+}
+
+// TeamList .
+func (s *Service) TeamList(c context.Context, pn, ps int64, title string, status int) (list []*model.TeamInfo, count int64, err error) {
+	var (
+		teams   []*model.Team
+		teamIDs []int64
+		gameMap map[int64][]*model.Game
+	)
+	source := s.dao.DB.Model(&model.Team{})
+	if status != _statusAll {
+		source = source.Where("is_deleted=?", _notDeleted)
+	}
+	if title != "" {
+		likeStr := fmt.Sprintf("%%%s%%", title)
+		source = source.Where("title like ?", likeStr)
+	}
+	source.Count(&count)
+	if err = source.Offset((pn - 1) * ps).Limit(ps).Find(&teams).Error; err != nil {
+		log.Error("TeamList Error (%v)", err)
+		return
+	}
+	if len(teams) == 0 {
+		return
+	}
+	for _, v := range teams {
+		teamIDs = append(teamIDs, v.ID)
+	}
+	if gameMap, err = s.gameList(c, model.TypeTeam, teamIDs); err != nil {
+		return
+	}
+	for _, v := range teams {
+		if games, ok := gameMap[v.ID]; ok {
+			list = append(list, &model.TeamInfo{Team: v, Games: games})
+		} else {
+			list = append(list, &model.TeamInfo{Team: v, Games: _emptyGameList})
+		}
+	}
+	return
+}
+
+// AddTeam .
+func (s *Service) AddTeam(c context.Context, param *model.Team, gids []int64) (err error) {
+	var (
+		games   []*model.Game
+		gidMaps []*model.GIDMap
+	)
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("AddTeam check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("AddTeam games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Team{}).Create(param).Error; err != nil {
+		log.Error("AddTeam s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	for _, v := range games {
+		gidMaps = append(gidMaps, &model.GIDMap{Type: model.TypeTeam, Oid: param.ID, Gid: v.ID})
+	}
+	if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(gidMaps)).Error; err != nil {
+		log.Error("AddTeam s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// EditTeam .
+func (s *Service) EditTeam(c context.Context, param *model.Team, gids []int64) (err error) {
+	var (
+		games                    []*model.Game
+		preGidMaps, addGidMaps   []*model.GIDMap
+		upGidMapAdd, upGidMapDel []int64
+	)
+	preData := new(model.Team)
+	if err = s.dao.DB.Where("id=?", param.ID).First(&preData).Error; err != nil {
+		log.Error("EditTeam s.dao.DB.Where id(%d) error(%d)", param.ID, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Game{}).Where("status=?", _statusOn).Where("id IN (?)", gids).Find(&games).Error; err != nil {
+		log.Error("EditTeam check game ids Error (%v)", err)
+		return
+	}
+	if len(games) == 0 {
+		log.Error("EditTeam games(%v) not found", gids)
+		err = ecode.RequestErr
+		return
+	}
+	if err = s.dao.DB.Model(&model.GIDMap{}).Where("oid=?", param.ID).Where("type=?", model.TypeTeam).Find(&preGidMaps).Error; err != nil {
+		log.Error("EditTeam games(%v) not found", gids)
+		return
+	}
+	gidsMap := make(map[int64]int64, len(gids))
+	preGidsMap := make(map[int64]int64, len(preGidMaps))
+	for _, v := range gids {
+		gidsMap[v] = v
+	}
+	for _, v := range preGidMaps {
+		preGidsMap[v.Gid] = v.Gid
+		if _, ok := gidsMap[v.Gid]; ok {
+			if v.IsDeleted == 1 {
+				upGidMapAdd = append(upGidMapAdd, v.ID)
+			}
+		} else {
+			upGidMapDel = append(upGidMapDel, v.ID)
+		}
+	}
+	for _, gid := range gids {
+		if _, ok := preGidsMap[gid]; !ok {
+			addGidMaps = append(addGidMaps, &model.GIDMap{Type: model.TypeTeam, Oid: param.ID, Gid: gid})
+		}
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = tx.Model(&model.Team{}).Save(param).Error; err != nil {
+		log.Error("EditTeam Team Update(%+v) error(%v)", param, err)
+		err = tx.Rollback().Error
+		return
+	}
+	if len(upGidMapAdd) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapAdd).Updates(map[string]interface{}{"is_deleted": _notDeleted}).Error; err != nil {
+			log.Error("EditTeam GIDMap Add(%+v) error(%v)", upGidMapAdd, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(upGidMapDel) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Where("id IN (?)", upGidMapDel).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+			log.Error("EditTeam GIDMap Del(%+v) error(%v)", upGidMapDel, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(addGidMaps) > 0 {
+		if err = tx.Model(&model.GIDMap{}).Exec(model.GidBatchAddSQL(addGidMaps)).Error; err != nil {
+			log.Error("EditTeam GIDMap Create(%+v) error(%v)", addGidMaps, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// ForbidTeam .
+func (s *Service) ForbidTeam(c context.Context, id int64, state int) (err error) {
+	preTeam := new(model.Team)
+	if err = s.dao.DB.Where("id=?", id).First(&preTeam).Error; err != nil {
+		log.Error("TeamForbid s.dao.DB.Where id(%d) error(%d)", id, err)
+		return
+	}
+	if err = s.dao.DB.Model(&model.Team{}).Where("id=?", id).Update(map[string]int{"is_deleted": state}).Error; err != nil {
+		log.Error("TeamForbid s.dao.DB.Model error(%v)", err)
+	}
+	return
+}

app/admin/main/esports/service/team_test.go

@@ -0,0 +1,20 @@
+package service
+
+import (
+	"context"
+	"go-common/app/admin/main/esports/model"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_EditTeam(t *testing.T) {
+	Convey("test edit team", t, WithService(func(s *Service) {
+		arg := &model.Team{
+			ID: 3,
+		}
+		gids := []int64{3}
+		err := s.EditTeam(context.Background(), arg, gids)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/esports/service/tree.go

@@ -0,0 +1,218 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+
+	"go-common/app/admin/main/esports/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/xstr"
+
+	"github.com/jinzhu/gorm"
+)
+
+var _emptyTreeList = make([][]*model.TreeList, 0)
+
+// AddTree .
+func (s *Service) AddTree(c context.Context, param *model.Tree) (rs model.Tree, err error) {
+	var rootID int64
+	db := s.dao.DB.Model(&model.Tree{}).Create(param)
+	if err = db.Error; err != nil {
+		log.Error("AddTree s.dao.DB.Model Create(%+v) error(%v)", param, err)
+		return
+	}
+	rootID = (db.Value.(*model.Tree)).RootID
+	rs.ID = (db.Value.(*model.Tree)).ID
+	rs.MaID = (db.Value.(*model.Tree)).MaID
+	rs.MadID = (db.Value.(*model.Tree)).MadID
+	rs.Pid = (db.Value.(*model.Tree)).Pid
+	rs.Mid = (db.Value.(*model.Tree)).Mid
+	// update detail online.
+	s.UpOnline(c, rs.MadID, _downLine)
+	// update first root_id.
+	if param.RootID == 0 || rs.Pid == 0 {
+		upDB := s.dao.DB.Model(&model.Tree{})
+		if err = upDB.Where("id=?", rs.ID).Updates(map[string]interface{}{"root_id": rs.ID}).Error; err != nil {
+			log.Error("AddTree db.Model  Updates(%+v) error(%v)", rs.ID, err)
+			return
+		}
+		rootID = (upDB.Value.(*model.Tree)).RootID
+	}
+	rs.RootID = rootID
+	return
+}
+
+// EditTree .
+func (s *Service) EditTree(c context.Context, param *model.TreeEditParam) (err error) {
+	var (
+		paramIDs         []int64
+		trees, paramTree []*model.Tree
+		delIDs           []int64
+		nodes            map[int64]int64
+	)
+	if err = json.Unmarshal([]byte(param.Nodes), &nodes); err != nil {
+		err = ecode.RequestErr
+		return
+	}
+	if len(nodes) == 0 {
+		err = ecode.EsportsTreeEmptyErr
+		return
+	}
+	for id := range nodes {
+		if id > 0 {
+			paramIDs = append(paramIDs, id)
+		} else {
+			err = ecode.RequestErr
+			return
+		}
+	}
+	// check tree maid same .
+	if err = s.dao.DB.Model(&model.Tree{}).Model(&model.Tree{}).Where("id IN (?)", paramIDs).Find(&paramTree).Error; err != nil {
+		log.Error("EditTree s.dao.DB.Model  Find(%+v) error(%v)", paramIDs, err)
+	}
+	for _, tmpTree := range paramTree {
+		if tmpTree.MadID != param.MadID {
+			err = ecode.EsportsTreeNodeErr
+			return
+		}
+	}
+	ParamIDCount := len(paramIDs)
+	treeDB := s.dao.DB.Model(&model.Tree{})
+	if err = treeDB.Where("mad_id=?", param.MadID).Where("is_deleted=0").Find(&trees).Error; err != nil {
+		log.Error("EditTree Error (%v)", err)
+		return
+	}
+	treeCount := len(trees)
+	if ParamIDCount != treeCount {
+		for _, tree := range trees {
+			if _, ok := nodes[tree.ID]; !ok {
+				delIDs = append(delIDs, tree.ID)
+			}
+		}
+	}
+	// Prevent multiplayer editing
+	if ParamIDCount != (treeCount - len(delIDs)) {
+		err = ecode.EsportsMultiEdit
+		return
+	}
+	tx := s.dao.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("s.dao.DB.Begin error(%v)", err)
+		return
+	}
+	if err = upTree(tx, delIDs, nodes, param.MadID); err != nil {
+		err = tx.Rollback().Error
+		return
+	}
+	if err = tx.Commit().Error; err != nil {
+		log.Error("tx.Commit error(%v)", err)
+		return
+	}
+	return
+}
+
+func upTree(tx *gorm.DB, delIDs []int64, nodes map[int64]int64, madID int64) (err error) {
+	if err = tx.Model(&model.Tree{}).Where("id IN (?)", delIDs).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+		log.Error("upTree tx.Model  Updates(%+v) error(%v)", delIDs, err)
+		return
+	}
+	if err = tx.Model(&model.Tree{}).Exec(model.BatchEditTreeSQL(nodes)).Error; err != nil {
+		log.Error("upTree tx.Model Exec(%+v) error(%v)", nodes, err)
+	}
+	if err = tx.Model(&model.MatchDetail{}).Where("id=?", madID).Updates(map[string]interface{}{"online": _downLine}).Error; err != nil {
+		log.Error("upTree MatchDetail tx.Model Updates(%d) error(%v)", madID, err)
+	}
+	return
+}
+
+// DelTree .
+func (s *Service) DelTree(c context.Context, param *model.TreeDelParam) (err error) {
+	var ids []int64
+	if ids, err = xstr.SplitInts(param.IDs); err != nil {
+		err = ecode.RequestErr
+		return
+	}
+	if err = s.dao.DB.Model(&model.Tree{}).Model(&model.Tree{}).Where("id IN (?)", ids).Updates(map[string]interface{}{"is_deleted": _deleted}).Error; err != nil {
+		log.Error("DelTree treeDB.Model  Updates(%+v) error(%v)", ids, err)
+	}
+	// update detail online.
+	s.UpOnline(c, param.MadID, _downLine)
+	return
+}
+
+// TreeList .
+func (s *Service) TreeList(c context.Context, param *model.TreeListParam) (res *model.TreeDetailList, err error) {
+	var (
+		trees       []*model.Tree
+		mids        []int64
+		contests    []*model.Contest
+		mapContests map[int64]*model.ContestInfo
+		sTree       []*model.TreeList
+		cInfos      []*model.ContestInfo
+		detail      model.MatchDetail
+		rs          [][]*model.TreeList
+	)
+	db := s.dao.DB.Model(&model.MatchDetail{}).Where("id=?", param.MadID).First(&detail)
+	if err = db.Error; err != nil {
+		log.Error("TreeList MatchDetail db.Model Find error(%v)", err)
+	}
+	if detail.ID == 0 {
+		err = ecode.EsportsTreeDetailErr
+		return
+	}
+	treeDB := s.dao.DB.Model(&model.Tree{})
+	treeDB = treeDB.Where("mad_id=?", param.MadID).Where("is_deleted=0")
+	if err = treeDB.Limit(s.c.Rule.MaxTreeContests).Order("root_id ASC,pid ASC,game_rank ASC").Find(&trees).Error; err != nil {
+		log.Error("TreeList Error (%v)", err)
+		return
+	}
+	for _, tree := range trees {
+		mids = append(mids, tree.Mid)
+	}
+	contestsDB := s.dao.DB.Model(&model.Contest{})
+	contestsDB = contestsDB.Where("id IN (?)", mids)
+	count := len(mids)
+	if err = contestsDB.Offset(0).Limit(count).Find(&contests).Error; err != nil {
+		log.Error("ContestList Error (%v)", err)
+		return
+	}
+	if cInfos, err = s.contestInfos(c, contests, false); err != nil {
+		log.Error("s.contestInfos Error (%v)", err)
+		return
+	}
+	mapContests = make(map[int64]*model.ContestInfo, count)
+	for _, info := range cInfos {
+		mapContests[info.ID] = info
+	}
+	for _, tree := range trees {
+		if tree.Pid == 0 {
+			if len(sTree) > 0 {
+				rs = append(rs, sTree)
+			}
+			sTree = nil
+			if cInfo, ok := mapContests[tree.Mid]; ok {
+				sTree = append(sTree, &model.TreeList{Tree: tree, ContestInfo: cInfo})
+			} else {
+				sTree = append(sTree, &model.TreeList{Tree: tree})
+			}
+		} else {
+			if cInfo, ok := mapContests[tree.Mid]; ok {
+				sTree = append(sTree, &model.TreeList{Tree: tree, ContestInfo: cInfo})
+			} else {
+				sTree = append(sTree, &model.TreeList{Tree: tree})
+			}
+		}
+	}
+	if len(sTree) > 0 {
+		rs = append(rs, sTree)
+	}
+	res = new(model.TreeDetailList)
+	if len(trees) == 0 {
+		res.Tree = _emptyTreeList
+	} else {
+		res.Tree = rs
+	}
+	res.Detail = &detail
+	return
+}