219 lines
6.2 KiB
Go
219 lines
6.2 KiB
Go
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(¶mTree).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
|
|
}
|