419 lines
12 KiB
Go
419 lines
12 KiB
Go
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
|
||
}
|