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.
418 lines
12 KiB
418 lines
12 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/interface/main/dm2/model" |
|
"go-common/library/database/elastic" |
|
"go-common/library/log" |
|
"go-common/library/xstr" |
|
) |
|
|
|
var ( |
|
_dataTimeFormat = "2006-01-02 15:03:04" |
|
|
|
_subtitleFields = []string{"oid", "id"} |
|
|
|
_dmRecentFields = []string{"attr", "color", "ctime", "fontsize", "id", "mid", "mode", "msg", "mtime", "oid", "pool", "progress", "state", "type", "pid"} |
|
) |
|
|
|
func hisDateIndex(month string) string { |
|
return "dm_date_" + strings.Replace(month, "-", "_", -1) |
|
} |
|
|
|
// SearchDMHisIndex get dm date index by oid from search. |
|
func (d *Dao) SearchDMHisIndex(c context.Context, tp int32, oid int64, month string) (dates []string, err error) { |
|
var ( |
|
pn, ps = 1, 31 |
|
res model.SearchHistoryIdxResult |
|
) |
|
req := d.elastic.NewRequest("dm_date") |
|
req.Fields("date").WhereEq("oid", oid) |
|
req.Index(hisDateIndex(month)).Pn(pn).Ps(ps).Order("date", "asc") |
|
if err = req.Scan(c, &res); err != nil { |
|
log.Error("elastic search(%s) error(%v)", req.Params(), err) |
|
return |
|
} |
|
for _, v := range res.Result { |
|
dates = append(dates, v.Date) |
|
} |
|
return |
|
} |
|
|
|
// SearchDMHistory get history dmid from search. |
|
// 搜索定制api，改动需要沟通 |
|
func (d *Dao) SearchDMHistory(c context.Context, tp int32, oid, ctimeTo int64, pn, ps int) (dmids []int64, err error) { |
|
var ( |
|
res model.SearchHistoryResult |
|
end = time.Unix(ctimeTo, 0).Format("2006-01-02 15:04:05") |
|
) |
|
req := d.elastic.NewRequest("dm_history") |
|
req.Index(fmt.Sprintf("dm_search_%03d", oid%_indexSharding)) |
|
req.Fields("id").WhereEq("oid", oid).WhereIn("state", []int64{0, 2, 6}) |
|
req.WhereRange("ctime", nil, end, elastic.RangeScopeLcRc) |
|
req.Pn(pn).Ps(ps).Order("ctime", "desc") |
|
if err = req.Scan(c, &res); err != nil { |
|
log.Error("elastic search(%s) error(%v)", req.Params(), err) |
|
return |
|
} |
|
for _, v := range res.Result { |
|
dmids = append(dmids, v.ID) |
|
} |
|
return |
|
} |
|
|
|
// SearchDM 搜索弹幕 |
|
func (d *Dao) SearchDM(c context.Context, p *model.SearchDMParams) (res *model.SearchDMData, err error) { |
|
req := d.elastic.NewRequest("dm_search") |
|
req.Fields("id").Index(fmt.Sprintf("dm_search_%03d", p.Oid%_indexSharding)).WhereEq("oidstr", p.Oid) |
|
if p.Mids != "" { |
|
mids, _ := xstr.SplitInts(p.Mids) |
|
req.WhereIn("mid", mids) |
|
} |
|
if p.State != "" { |
|
states, _ := xstr.SplitInts(p.State) |
|
req.WhereIn("state", states) |
|
} |
|
if p.Mode != "" { |
|
modes, _ := xstr.SplitInts(p.Mode) |
|
req.WhereIn("mode", modes) |
|
} |
|
if p.Pool != "" { |
|
pools, _ := xstr.SplitInts(p.Pool) |
|
req.WhereIn("pool", pools) |
|
} |
|
if p.Attrs != "" { |
|
attrs, _ := xstr.SplitInts(p.Attrs) |
|
req.WhereIn("attr_format", attrs) |
|
} |
|
req.WhereEq("type", p.Type) |
|
switch { |
|
case p.ProgressFrom != model.CondIntNil && p.ProgressTo != model.CondIntNil: |
|
req.WhereRange("progress_long", p.ProgressFrom, p.ProgressTo, elastic.RangeScopeLcRc) |
|
case p.ProgressFrom != model.CondIntNil: |
|
req.WhereRange("progress_long", p.ProgressFrom, nil, elastic.RangeScopeLcRc) |
|
case p.ProgressTo != model.CondIntNil: |
|
req.WhereRange("progress_long", nil, p.ProgressTo, elastic.RangeScopeLcRc) |
|
} |
|
req.WhereRange("ctime", p.CtimeFrom, p.CtimeTo, elastic.RangeScopeLcRc) |
|
if p.Keyword != "" { |
|
req.WhereLike([]string{"msg"}, []string{p.Keyword}, true, elastic.LikeLevelHigh) |
|
req.OrderScoreFirst(true) |
|
} |
|
if p.Order == "progress" { |
|
p.Order = "progress_long" |
|
} |
|
req.Order(p.Order, p.Sort) |
|
req.Pn(int(p.Pn)).Ps(int(p.Ps)) |
|
res = &model.SearchDMData{} |
|
if err = req.Scan(c, &res); err != nil { |
|
log.Error("search params(%s), error(%v)", req.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// UptSearchDMState update dm search state |
|
func (d *Dao) UptSearchDMState(c context.Context, dmids []int64, oid int64, state, tp int32) (err error) { |
|
upt := d.elastic.NewUpdate("dm_search") |
|
for _, dmid := range dmids { |
|
data := &model.UptSearchDMState{ |
|
ID: dmid, |
|
Oid: oid, |
|
State: state, |
|
Type: tp, |
|
Mtime: time.Now().Format("2006-01-02 15:04:05"), |
|
} |
|
upt.AddData(fmt.Sprintf("dm_search_%03d", oid%_indexSharding), data) |
|
} |
|
if err = upt.Do(c); err != nil { |
|
log.Error("update.Do() params(%s) error(%v)", upt.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// UptSearchDMPool update dm search pool |
|
func (d *Dao) UptSearchDMPool(c context.Context, dmids []int64, oid int64, pool, tp int32) (err error) { |
|
upt := d.elastic.NewUpdate("dm_search") |
|
for _, dmid := range dmids { |
|
data := &model.UptSearchDMPool{ |
|
ID: dmid, |
|
Oid: oid, |
|
Pool: pool, |
|
Type: tp, |
|
Mtime: time.Now().Format("2006-01-02 15:04:05"), |
|
} |
|
upt.AddData(fmt.Sprintf("dm_search_%03d", oid%_indexSharding), data) |
|
} |
|
if err = upt.Do(c); err != nil { |
|
log.Error("update.Do() params(%s) error(%v)", upt.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// UptSearchDMAttr update dm search attr |
|
func (d *Dao) UptSearchDMAttr(c context.Context, dmids []int64, oid int64, attr, tp int32) (err error) { |
|
var bits []int64 |
|
for k, v := range strconv.FormatInt(int64(attr), 2) { |
|
if v == 49 { |
|
bits = append(bits, int64(k+1)) |
|
} |
|
} |
|
upt := d.elastic.NewUpdate("dm_search") |
|
for _, dmid := range dmids { |
|
data := &model.UptSearchDMAttr{ |
|
ID: dmid, |
|
Oid: oid, |
|
Attr: attr, |
|
AttrFormat: bits, |
|
Type: tp, |
|
Mtime: time.Now().Format("2006-01-02 15:04:05"), |
|
} |
|
upt.AddData(fmt.Sprintf("dm_search_%03d", oid%_indexSharding), data) |
|
} |
|
if err = upt.Do(c); err != nil { |
|
log.Error("update.Do() params(%s) error(%v)", upt.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// SearchSubtitles . |
|
func (d *Dao) SearchSubtitles(c context.Context, page, size int32, mid int64, upMids []int64, aid, oid int64, tp int32, status []int64) (res *model.SearchSubtitleResult, err error) { |
|
var ( |
|
req *elastic.Request |
|
fields []string |
|
) |
|
fields = _subtitleFields |
|
req = d.elastic.NewRequest("dm_subtitle").Index("subtitle").Fields(fields...).Pn(int(page)).Ps(int(size)) |
|
if mid > 0 { |
|
req.WhereEq("mid", mid) |
|
} |
|
if aid > 0 { |
|
req.WhereEq("aid", aid) |
|
} |
|
if oid > 0 { |
|
req.WhereEq("oid", oid) |
|
req.WhereEq("type", tp) |
|
} |
|
|
|
switch { |
|
case len(upMids) > 0 && len(status) > 0: |
|
cmbs := &elastic.Combo{} |
|
cmbu := &elastic.Combo{} |
|
var ( |
|
statusInf []interface{} |
|
upMidsInf []interface{} |
|
) |
|
for _, s := range status { |
|
statusInf = append(statusInf, s) |
|
} |
|
for _, s := range upMids { |
|
upMidsInf = append(upMidsInf, s) |
|
} |
|
cmbs.ComboIn([]map[string][]interface{}{ |
|
{"status": statusInf}, |
|
}) |
|
cmbu.ComboIn([]map[string][]interface{}{ |
|
{"up_mid": upMidsInf}, |
|
}) |
|
req = req.WhereCombo(cmbs.MinIn(1).MinAll(1), cmbu.MinIn(1).MinAll(1)) |
|
case len(upMids) > 0: |
|
req.WhereIn("up_mid", upMids) |
|
case len(status) > 0: |
|
req.WhereIn("status", status) |
|
} |
|
req.Order("mtime", "desc") |
|
if err = req.Scan(c, &res); err != nil { |
|
log.Error("elastic search(%s) error(%v)", req.Params(), err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// CountSubtitles . |
|
func (d *Dao) CountSubtitles(c context.Context, mid int64, upMids []int64, aid, oid int64, tp int32) (countSubtitle *model.CountSubtitleResult, err error) { |
|
var ( |
|
req *elastic.Request |
|
fields []string |
|
res map[string]interface{} |
|
_searchStatus = []string{ |
|
fmt.Sprint(model.SubtitleStatusDraft), |
|
fmt.Sprint(model.SubtitleStatusToAudit), |
|
fmt.Sprint(model.SubtitleStatusAuditBack), |
|
fmt.Sprint(model.SubtitleStatusPublish), |
|
fmt.Sprint(model.SubtitleStatusCheckToAudit), |
|
fmt.Sprint(model.SubtitleStatusCheckPublish), |
|
fmt.Sprint(model.SubtitleStatusManagerBack), |
|
} |
|
result map[string]interface{} |
|
groupStatus []interface{} |
|
itemStatus map[string]interface{} |
|
ok bool |
|
) |
|
req = d.elastic.NewRequest("dm_subtitle").Index("subtitle").Fields(fields...).Pn(0).Ps(0) |
|
if mid > 0 { |
|
req.WhereEq("mid", mid) |
|
} |
|
if aid > 0 { |
|
req.WhereEq("aid", aid) |
|
} |
|
if oid > 0 { |
|
req.WhereEq("oid", oid) |
|
req.WhereEq("type", tp) |
|
} |
|
if len(upMids) > 0 { |
|
req.WhereIn("up_mid", upMids) |
|
} |
|
req = req.GroupBy(elastic.EnhancedModeGroupBy, "status", nil).WhereIn("status", _searchStatus) |
|
if err = req.Scan(c, &res); err != nil { |
|
log.Error("elastic search(%s) error(%v)", req.Params(), err) |
|
return |
|
} |
|
countSubtitle = &model.CountSubtitleResult{} |
|
if result, ok = res["result"].(map[string]interface{}); !ok { |
|
return |
|
} |
|
if groupStatus, ok = result["group_by_status"].([]interface{}); !ok { |
|
return |
|
} |
|
for _, item := range groupStatus { |
|
if itemStatus, ok = item.(map[string]interface{}); ok { |
|
docCount, _ := itemStatus["doc_count"].(float64) |
|
switch itemStatus["key"] { |
|
case fmt.Sprint(model.SubtitleStatusDraft): |
|
countSubtitle.Draft += int64(docCount) |
|
case fmt.Sprint(model.SubtitleStatusToAudit): |
|
countSubtitle.ToAudit += int64(docCount) |
|
case fmt.Sprint(model.SubtitleStatusAuditBack): |
|
countSubtitle.AuditBack += int64(docCount) |
|
case fmt.Sprint(model.SubtitleStatusPublish): |
|
countSubtitle.Publish += int64(docCount) |
|
case fmt.Sprint(model.SubtitleStatusCheckToAudit): |
|
countSubtitle.ToAudit += int64(docCount) |
|
case fmt.Sprint(model.SubtitleStatusCheckPublish): |
|
countSubtitle.Publish += int64(docCount) |
|
case fmt.Sprint(model.SubtitleStatusManagerBack): |
|
countSubtitle.AuditBack += int64(docCount) |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
// UptSearchRecentState . |
|
func (d *Dao) UptSearchRecentState(c context.Context, dmids []int64, oid int64, state, tp int32) (err error) { |
|
upt := d.elastic.NewUpdate("dm_home") |
|
year, month, _ := time.Now().Date() |
|
yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date() |
|
for _, dmid := range dmids { |
|
data := &model.UptSearchDMState{ |
|
ID: dmid, |
|
Oid: oid, |
|
State: state, |
|
Type: tp, |
|
Mtime: time.Now().Format("2006-01-02 15:04:05"), |
|
} |
|
upt.AddData(fmt.Sprintf("dm_home_%v", |
|
fmt.Sprintf("%d_%02d", yearPre, int(monthPre)), |
|
), data) |
|
upt.AddData(fmt.Sprintf("dm_home_%v", |
|
fmt.Sprintf("%d_%02d", year, int(month)), |
|
), data) |
|
} |
|
if err = upt.Do(c); err != nil { |
|
log.Error("update.Do() params(%s) error(%v)", upt.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// UptSearchRecentAttr . |
|
func (d *Dao) UptSearchRecentAttr(c context.Context, dmids []int64, oid int64, attr, tp int32) (err error) { |
|
var bits []int64 |
|
for k, v := range strconv.FormatInt(int64(attr), 2) { |
|
if v == 49 { |
|
bits = append(bits, int64(k+1)) |
|
} |
|
} |
|
upt := d.elastic.NewUpdate("dm_home") |
|
year, month, _ := time.Now().Date() |
|
yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date() |
|
for _, dmid := range dmids { |
|
data := &model.UptSearchDMAttr{ |
|
ID: dmid, |
|
Oid: oid, |
|
Attr: attr, |
|
AttrFormat: bits, |
|
Type: tp, |
|
Mtime: time.Now().Format("2006-01-02 15:04:05"), |
|
} |
|
upt.AddData(fmt.Sprintf("dm_home_%v", |
|
fmt.Sprintf("%d_%02d", yearPre, int(monthPre)), |
|
), data) |
|
upt.AddData(fmt.Sprintf("dm_home_%v", |
|
fmt.Sprintf("%d_%02d", year, int(month)), |
|
), data) |
|
} |
|
if err = upt.Do(c); err != nil { |
|
log.Error("update.Do() params(%s) error(%v)", upt.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// UptSearchRecentPool . |
|
func (d *Dao) UptSearchRecentPool(c context.Context, dmids []int64, oid int64, pool, tp int32) (err error) { |
|
upt := d.elastic.NewUpdate("dm_home") |
|
year, month, _ := time.Now().Date() |
|
yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date() |
|
for _, dmid := range dmids { |
|
data := &model.UptSearchDMPool{ |
|
ID: dmid, |
|
Oid: oid, |
|
Pool: pool, |
|
Type: tp, |
|
Mtime: time.Now().Format("2006-01-02 15:04:05"), |
|
} |
|
upt.AddData(fmt.Sprintf("dm_home_%v", |
|
fmt.Sprintf("%d_%02d", yearPre, int(monthPre)), |
|
), data) |
|
upt.AddData(fmt.Sprintf("dm_home_%v", |
|
fmt.Sprintf("%d_%02d", year, int(month)), |
|
), data) |
|
} |
|
if err = upt.Do(c); err != nil { |
|
log.Error("update.Do() params(%s) error(%v)", upt.Params(), err) |
|
} |
|
return |
|
} |
|
|
|
// SearhcDmRecent . |
|
func (d *Dao) SearhcDmRecent(c context.Context, param *model.SearchRecentDMParam) (res *model.SearchRecentDMResult, err error) { |
|
var ( |
|
req *elastic.Request |
|
) |
|
year, month, _ := time.Now().Date() |
|
yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date() |
|
req = d.elastic.NewRequest("dm_home").Index(fmt.Sprintf("dm_home_%v,dm_home_%v", |
|
fmt.Sprintf("%d_%02d", year, int(month)), |
|
fmt.Sprintf("%d_%02d", yearPre, int(monthPre)), |
|
)).Fields(_dmRecentFields...).Pn(param.Pn).Ps(param.Ps) |
|
if param.Type > 0 { |
|
req.WhereEq("type", param.Type) |
|
} |
|
if param.UpMid > 0 { |
|
req.WhereEq("o_mid", param.UpMid) |
|
} |
|
if len(param.States) > 0 { |
|
req.WhereIn("state", param.States) |
|
} |
|
req.WhereRange("ctime", time.Now().Local().AddDate(0, 0, -30).Format(_dataTimeFormat), time.Now().Local().Format(_dataTimeFormat), elastic.RangeScopeLcRo) |
|
req.Order(param.Field, param.Sort) |
|
res = &model.SearchRecentDMResult{} |
|
if err = req.Scan(c, &res); err != nil { |
|
log.Error("search params(%s), error(%v)", req.Params(), err) |
|
} |
|
return |
|
}
|
|
|