You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
826 lines
27 KiB
826 lines
27 KiB
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 |
|
}
|
|
|