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.
628 lines
21 KiB
628 lines
21 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"database/sql" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
|
|
"go-common/app/interface/main/esports/model" |
|
xsql "go-common/library/database/sql" |
|
"go-common/library/log" |
|
"go-common/library/xstr" |
|
) |
|
|
|
const ( |
|
_matchsSQL = "SELECT id,title,sub_title,logo,rank FROM es_matchs WHERE status=0 order by rank DESC , ID ASC" |
|
_gamesSQL = "SELECT id,title,sub_title,logo FROM es_games WHERE status=0 order by id ASC" |
|
_teamsSQL = "SELECT id,title,sub_title,logo FROM es_teams WHERE is_deleted=0 order by id ASC" |
|
_tagsSQL = "SELECT id,name FROM es_tags WHERE status=0 order by id ASC" |
|
_yearsSQL = "SELECT distinct year as id, year FROM es_year_map WHERE is_deleted=0 order by id ASC" |
|
_dayContestSQL = "SELECT FROM_UNIXTIME(stime, '%Y-%m-%d') as s,count(1) as c FROM `es_contests` WHERE status=0 AND stime >= ? and stime <= ? GROUP BY s ORDER BY stime" |
|
_seasonSQL = "SELECT id,mid,title,sub_title,stime,etime,sponsor,logo,dic,ctime,mtime,status,rank,is_app,url,data_focus,focus_url FROM es_seasons WHERE status = 0 ORDER BY stime DESC" |
|
_epSeasonSQL = "SELECT id,mid,title,sub_title,stime,etime,sponsor,logo,dic,ctime,mtime,status,rank,is_app,url,data_focus,focus_url FROM es_seasons WHERE status = 0 and id in (%s) ORDER BY stime DESC" |
|
_seasonMSQL = "SELECT id,mid,title,sub_title,stime,etime,sponsor,logo,dic,ctime,mtime,status,rank,is_app,url,data_focus,focus_url FROM es_seasons WHERE status = 0 AND is_app = 1 ORDER BY rank DESC,stime DESC" |
|
_seasonsSQL = "SELECT id,title,sub_title,logo,url,data_focus,focus_url FROM es_seasons WHERE status = 0 ORDER BY stime DESC" |
|
_contestSQL = "SELECT id,game_stage,stime,etime,home_id,away_id,home_score,away_score,live_room,aid,collection,game_state,dic,ctime,mtime,status,sid,mid,special,special_name,special_tips,success_team,special_image,playback,collection_url,live_url,data_type,match_id FROM `es_contests` WHERE id= ?" |
|
_contestsSQL = "SELECT id,game_stage,stime,etime,home_id,away_id,home_score,away_score,live_room,aid,collection,game_state,dic,ctime,mtime,status,sid,mid,special,special_name,special_tips,success_team,special_image,playback,collection_url,live_url,data_type,match_id FROM `es_contests` WHERE id in (%s) ORDER BY ID ASC" |
|
_contestLeidaSQL = "SELECT id,game_stage,stime,etime,home_id,away_id,home_score,away_score,live_room,aid,collection,game_state,dic,ctime,mtime,status,sid,mid,special,special_name,special_tips,success_team,special_image,playback,collection_url,live_url,data_type,match_id FROM `es_contests` WHERE match_id > 0 and status = 0" |
|
_moduleSQL = "SELECT id,ma_id,name,oids FROM `es_matchs_module` WHERE id = ? AND status = 0" |
|
_activeSQL = "SELECT id,mid,sid,background,live_id,intr,focus,url,back_color,color_step,h5_background,h5_back_color,intr_logo,intr_title,intr_text,h5_focus,h5_url FROM es_matchs_active WHERE id = ? AND `status`= 0" |
|
_modulesSQL = "SELECT id,ma_id,name,oids FROM `es_matchs_module` WHERE ma_id = ? AND status = 0 ORDER BY ID ASC" |
|
_pDetailSQL = "SELECT ma_id,game_type,stime,etime FROM es_matchs_detail WHERE id = ? AND `status` = 0" |
|
_actDetail = "SELECT id,ma_id,game_type,stime,etime,score_id,game_stage,knockout_type,winner_type,online FROM es_matchs_detail WHERE ma_id = ? AND status = 0" |
|
_treeSQL = "SELECT id,ma_id,mad_id,pid,root_id,game_rank,mid FROM es_matchs_tree WHERE mad_id = ? AND is_deleted=0 ORDER BY root_id ASC,pid ASC,game_rank ASC" |
|
_teamsInSQL = "SELECT id,title,sub_title,logo FROM es_teams WHERE is_deleted=0 AND id in (%s)" |
|
_kDetailsSQL = "SELECT id,ma_id,game_type,stime,etime,online FROM es_matchs_detail WHERE `status` = 0 AND game_type = 2" |
|
_contestDataSQL = "SELECT id,cid,url,point_data FROM `es_contests_data` WHERE cid = ? AND is_deleted = 0" |
|
_contestRecent = "SELECT id,game_stage,stime,etime,home_id,away_id,home_score,away_score,live_room,aid,collection,game_state,dic,ctime,mtime,status,sid,mid,special,special_name,special_tips,success_team,special_image,playback,collection_url,live_url,data_type FROM es_contests WHERE ( `status` = 0 AND home_id = ? AND away_id = ? ) OR ( `status` = 0 AND home_id = ? AND away_id = ? ) ORDER BY stime DESC LIMIT ?" |
|
) |
|
|
|
// logoURL convert logo url to full url. |
|
func logoURL(uri string) (logo string) { |
|
if uri == "" { |
|
return |
|
} |
|
logo = uri |
|
if strings.Index(uri, "http://") == 0 || strings.Index(uri, "//") == 0 { |
|
return |
|
} |
|
if len(uri) >= 10 && uri[:10] == "/templets/" { |
|
return |
|
} |
|
if strings.HasPrefix(uri, "group1") { |
|
logo = "//i0.hdslb.com/" + uri |
|
return |
|
} |
|
if pos := strings.Index(uri, "/uploads/"); pos != -1 && (pos == 0 || pos == 3) { |
|
logo = uri[pos+8:] |
|
} |
|
logo = strings.Replace(logo, "{IMG}", "", -1) |
|
logo = "//i0.hdslb.com" + logo |
|
return |
|
} |
|
|
|
// Matchs filter matchs. |
|
func (d *Dao) Matchs(c context.Context) (res []*model.Filter, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _matchsSQL); err != nil { |
|
log.Error("Match:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Filter) |
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Logo, &r.Rank); err != nil { |
|
log.Error("Match:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Games filter games. |
|
func (d *Dao) Games(c context.Context) (res []*model.Filter, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _gamesSQL); err != nil { |
|
log.Error("Games:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Filter) |
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Logo); err != nil { |
|
log.Error("Games:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Teams filter teams. |
|
func (d *Dao) Teams(c context.Context) (res []*model.Filter, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _teamsSQL); err != nil { |
|
log.Error("Teams:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Filter) |
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Logo); err != nil { |
|
log.Error("Teams:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Tags filter Tags. |
|
func (d *Dao) Tags(c context.Context) (res []*model.Filter, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _tagsSQL); err != nil { |
|
log.Error("Tags:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Filter) |
|
if err = rows.Scan(&r.ID, &r.Title); err != nil { |
|
log.Error("Tags:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Years filter years. |
|
func (d *Dao) Years(c context.Context) (res []*model.Filter, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _yearsSQL); err != nil { |
|
log.Error("Years:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Year) |
|
if err = rows.Scan(&r.ID, &r.Year); err != nil { |
|
log.Error("Years:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res = append(res, &model.Filter{ID: r.ID, Title: strconv.FormatInt(r.Year, 10)}) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Calendar calendar count. |
|
func (d *Dao) Calendar(c context.Context, stime, etime int64) (res []*model.Calendar, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _dayContestSQL, stime, etime); err != nil { |
|
log.Error("Calendar:d.db.Query(%d,%d) error(%v)", stime, etime, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Calendar) |
|
if err = rows.Scan(&r.Stime, &r.Count); err != nil { |
|
log.Error("Calendar:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
return |
|
} |
|
|
|
// Season season list. |
|
func (d *Dao) Season(c context.Context) (res []*model.Season, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _seasonSQL); err != nil { |
|
log.Error("Contest:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Season) |
|
if err = rows.Scan(&r.ID, &r.Mid, &r.Title, &r.SubTitle, &r.Stime, &r.Etime, &r.Sponsor, &r.Logo, &r.Dic, &r.Ctime, |
|
&r.Mtime, &r.Status, &r.Rank, &r.IsApp, &r.URL, &r.DataFocus, &r.FocusURL); err != nil { |
|
log.Error("Contest:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Module active module |
|
func (d *Dao) Module(c context.Context, mmid int64) (mod *model.Module, err error) { |
|
mod = &model.Module{} |
|
row := d.db.QueryRow(c, _moduleSQL, mmid) |
|
if err = row.Scan(&mod.ID, &mod.MAid, &mod.Name, &mod.Oids); err != nil { |
|
if err == sql.ErrNoRows { |
|
mod = nil |
|
err = nil |
|
} else { |
|
log.Error("Esport dao Module:row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Modules active module |
|
func (d *Dao) Modules(c context.Context, aid int64) (mods []*model.Module, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _modulesSQL, aid); err != nil { |
|
log.Error("Esport dao Modules:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Module) |
|
if err = rows.Scan(&r.ID, &r.MAid, &r.Name, &r.Oids); err != nil { |
|
log.Error("Esport dao Modules:row.Scan() error(%v)", err) |
|
return |
|
} |
|
mods = append(mods, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("Esport dao Modules.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Trees match tree |
|
func (d *Dao) Trees(c context.Context, madID int64) (mods []*model.Tree, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _treeSQL, madID); err != nil { |
|
log.Error("Esport dao Trees:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Tree) |
|
if err = rows.Scan(&r.ID, &r.MaID, &r.MadID, &r.Pid, &r.RootID, &r.GameRank, &r.Mid); err != nil { |
|
log.Error("Esport dao Trees:row.Scan() error(%v)", err) |
|
return |
|
} |
|
mods = append(mods, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("Esport dao Trees.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Active matchs active |
|
func (d *Dao) Active(c context.Context, aid int64) (mod *model.Active, err error) { |
|
mod = &model.Active{} |
|
row := d.db.QueryRow(c, _activeSQL, aid) |
|
if err = row.Scan(&mod.ID, &mod.Mid, &mod.Sid, &mod.Background, &mod.Liveid, &mod.Intr, &mod.Focus, &mod.URL, &mod.BackColor, &mod.ColorStep, &mod.H5Background, &mod.H5BackColor, &mod.IntrLogo, &mod.IntrTitle, &mod.IntrText, &mod.H5Focus, &mod.H5Url); err != nil { |
|
if err == sql.ErrNoRows { |
|
mod = nil |
|
err = nil |
|
} else { |
|
log.Error("Esport dao Active:row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// PActDetail poin match detail |
|
func (d *Dao) PActDetail(c context.Context, id int64) (mod *model.ActiveDetail, err error) { |
|
mod = &model.ActiveDetail{} |
|
row := d.db.QueryRow(c, _pDetailSQL, id) |
|
if err = row.Scan(&mod.Maid, &mod.GameType, &mod.STime, &mod.ETime); err != nil { |
|
if err == sql.ErrNoRows { |
|
mod = nil |
|
err = nil |
|
} else { |
|
log.Error("Esport dao Contest:row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ActDetail data module |
|
func (d *Dao) ActDetail(c context.Context, aid int64) (actDetail []*model.ActiveDetail, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _actDetail, aid); err != nil { |
|
log.Error("Esport dao Modules:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.ActiveDetail) |
|
if err = rows.Scan(&r.ID, &r.Maid, &r.GameType, &r.STime, &r.ETime, &r.ScoreID, &r.GameStage, &r.KnockoutType, &r.WinnerType, &r.Online); err != nil { |
|
log.Error("Esport dao ActDetail:row.Scan() error(%v)", err) |
|
return |
|
} |
|
actDetail = append(actDetail, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("Esport dao ActDetail.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// AppSeason season match list. |
|
func (d *Dao) AppSeason(c context.Context) (res []*model.Season, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _seasonMSQL); err != nil { |
|
log.Error("Contest:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Season) |
|
if err = rows.Scan(&r.ID, &r.Mid, &r.Title, &r.SubTitle, &r.Stime, &r.Etime, &r.Sponsor, &r.Logo, |
|
&r.Dic, &r.Ctime, &r.Mtime, &r.Status, &r.Rank, &r.IsApp, &r.URL, &r.DataFocus, &r.FocusURL); err != nil { |
|
log.Error("Contest:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// SeasonAll all season list. |
|
func (d *Dao) SeasonAll(c context.Context) (res []*model.Filter, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _seasonsSQL); err != nil { |
|
log.Error("SeasonAll:d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
r := new(model.Filter) |
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Logo, &r.URL, &r.DataFocus, &r.FocusURL); err != nil { |
|
log.Error("SeasonAll:row.Scan() error(%v)", err) |
|
return |
|
} |
|
r.Logo = logoURL(r.Logo) |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Contest get contest by id. |
|
func (d *Dao) Contest(c context.Context, cid int64) (res *model.Contest, err error) { |
|
res = &model.Contest{} |
|
row := d.db.QueryRow(c, _contestSQL, cid) |
|
if err = row.Scan(&res.ID, &res.GameStage, &res.Stime, &res.Etime, &res.HomeID, &res.AwayID, &res.HomeScore, &res.AwayScore, |
|
&res.LiveRoom, &res.Aid, &res.Collection, &res.GameState, &res.Dic, &res.Ctime, &res.Mtime, &res.Status, &res.Sid, &res.Mid, |
|
&res.Special, &res.SpecialName, &res.SpecialTips, &res.SuccessTeam, &res.SpecialImage, &res.Playback, &res.CollectionURL, |
|
&res.LiveURL, &res.DataType, &res.MatchID); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
} else { |
|
log.Error("Contest:row.Scan error(%v)", err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ContestRecent get recent contest |
|
func (d *Dao) ContestRecent(c context.Context, homeid, awayid, contestid, ps int64) (res []*model.Contest, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _contestRecent, homeid, awayid, awayid, homeid, ps+1); err != nil { |
|
log.Error("ContestRecent: db.Exec(%s) error(%v)", _contestRecent, err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*model.Contest, 0) |
|
for rows.Next() { |
|
r := new(model.Contest) |
|
if err = rows.Scan(&r.ID, &r.GameStage, &r.Stime, &r.Etime, &r.HomeID, &r.AwayID, &r.HomeScore, &r.AwayScore, |
|
&r.LiveRoom, &r.Aid, &r.Collection, &r.GameState, &r.Dic, &r.Ctime, &r.Mtime, &r.Status, &r.Sid, &r.Mid, |
|
&r.Special, &r.SpecialName, &r.SpecialTips, &r.SuccessTeam, &r.SpecialImage, &r.Playback, &r.CollectionURL, &r.LiveURL, &r.DataType); err != nil { |
|
log.Error("Contests:row.Scan() error(%v)", err) |
|
return |
|
} |
|
if r.ID != contestid && len(res) != int(ps) { |
|
res = append(res, r) |
|
} |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// ContestData get contest by id. |
|
func (d *Dao) ContestData(c context.Context, cid int64) (res []*model.ContestsData, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _contestDataSQL, cid); err != nil { |
|
log.Error("ContestsData: db.Exec(%s) error(%v)", _contestDataSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
data := new(model.ContestsData) |
|
if err = rows.Scan(&data.ID, &data.Cid, &data.URL, &data.PointData); err != nil { |
|
log.Error("ContestsData:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res = append(res, data) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("ContestssData rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// ContestDatas contest datas. |
|
func (d *Dao) ContestDatas(c context.Context) (res []*model.Contest, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _contestLeidaSQL); err != nil { |
|
log.Error("Contests: db.Exec(%s) error(%v)", _contestLeidaSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*model.Contest, 0) |
|
for rows.Next() { |
|
r := new(model.Contest) |
|
if err = rows.Scan(&r.ID, &r.GameStage, &r.Stime, &r.Etime, &r.HomeID, &r.AwayID, &r.HomeScore, &r.AwayScore, |
|
&r.LiveRoom, &r.Aid, &r.Collection, &r.GameState, &r.Dic, &r.Ctime, &r.Mtime, &r.Status, &r.Sid, &r.Mid, |
|
&r.Special, &r.SpecialName, &r.SpecialTips, &r.SuccessTeam, &r.SpecialImage, &r.Playback, &r.CollectionURL, &r.LiveURL, &r.DataType, &r.MatchID); err != nil { |
|
log.Error("Contests:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// RawEpContests get contests by ids. |
|
func (d *Dao) RawEpContests(c context.Context, cids []int64) (res map[int64]*model.Contest, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, fmt.Sprintf(_contestsSQL, xstr.JoinInts(cids))); err != nil { |
|
log.Error("Contests: db.Exec(%s) error(%v)", xstr.JoinInts(cids), err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make(map[int64]*model.Contest, len(cids)) |
|
for rows.Next() { |
|
r := new(model.Contest) |
|
if err = rows.Scan(&r.ID, &r.GameStage, &r.Stime, &r.Etime, &r.HomeID, &r.AwayID, &r.HomeScore, &r.AwayScore, |
|
&r.LiveRoom, &r.Aid, &r.Collection, &r.GameState, &r.Dic, &r.Ctime, &r.Mtime, &r.Status, &r.Sid, &r.Mid, |
|
&r.Special, &r.SpecialName, &r.SpecialTips, &r.SuccessTeam, &r.SpecialImage, &r.Playback, &r.CollectionURL, |
|
&r.LiveURL, &r.DataType, &r.MatchID); err != nil { |
|
log.Error("Contests:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res[r.ID] = r |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// RawEpSeasons get seasons by ids. |
|
func (d *Dao) RawEpSeasons(c context.Context, sids []int64) (res map[int64]*model.Season, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, fmt.Sprintf(_epSeasonSQL, xstr.JoinInts(sids))); err != nil { |
|
log.Error("Contests: db.Exec(%s) error(%v)", xstr.JoinInts(sids), err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make(map[int64]*model.Season, len(sids)) |
|
for rows.Next() { |
|
r := new(model.Season) |
|
if err = rows.Scan(&r.ID, &r.Mid, &r.Title, &r.SubTitle, &r.Stime, &r.Etime, &r.Sponsor, &r.Logo, &r.Dic, &r.Ctime, |
|
&r.Mtime, &r.Status, &r.Rank, &r.IsApp, &r.URL, &r.DataFocus, &r.FocusURL); err != nil { |
|
log.Error("Contest:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res[r.ID] = r |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// ActTeams get teams by ids in |
|
func (d *Dao) ActTeams(c context.Context, tids []int64) (res []*model.Team, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, fmt.Sprintf(_teamsInSQL, xstr.JoinInts(tids))); err != nil { |
|
log.Error("ActTeams: db.Exec(%s) error(%v)", xstr.JoinInts(tids), err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*model.Team, len(tids)) |
|
for rows.Next() { |
|
r := new(model.Team) |
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Logo); err != nil { |
|
log.Error("ActTeams:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("ActTeams rows.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// RawEpTeams get seasons by ids. |
|
func (d *Dao) RawEpTeams(c context.Context, tids []int64) (res map[int64]*model.Team, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, fmt.Sprintf(_teamsInSQL, xstr.JoinInts(tids))); err != nil { |
|
log.Error("RawEpTeams: db.Exec(%s) error(%v)", xstr.JoinInts(tids), err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make(map[int64]*model.Team, len(tids)) |
|
for rows.Next() { |
|
r := new(model.Team) |
|
if err = rows.Scan(&r.ID, &r.Title, &r.SubTitle, &r.Logo); err != nil { |
|
log.Error("RawEpTeams:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res[r.ID] = r |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("RawEpTeams.Err() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// KDetails knockout detail |
|
func (d *Dao) KDetails(c context.Context) (res []*model.ActiveDetail, err error) { |
|
var ( |
|
rows *xsql.Rows |
|
) |
|
if rows, err = d.db.Query(c, _kDetailsSQL); err != nil { |
|
log.Error("ActPDetails: db.Exec(%s) error(%v)", _kDetailsSQL, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
detail := new(model.ActiveDetail) |
|
if err = rows.Scan(&detail.ID, &detail.Maid, &detail.GameType, &detail.STime, &detail.ETime, &detail.Online); err != nil { |
|
log.Error("KDetails:row.Scan() error(%v)", err) |
|
return |
|
} |
|
res = append(res, detail) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("KDetails rows.Err() error(%v)", err) |
|
} |
|
return |
|
}
|
|
|