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.
233 lines
7.5 KiB
233 lines
7.5 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"net/url" |
|
"strconv" |
|
"time" |
|
|
|
"go-common/app/admin/main/workflow/model/manager" |
|
"go-common/app/admin/main/workflow/model/search" |
|
"go-common/library/database/elastic" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/xstr" |
|
) |
|
|
|
const ( |
|
_unameURI = "http://manager.bilibili.co/x/admin/manager/users/unames" |
|
_srhAuditLogURI = "http://bili-search.bilibili.co/x/admin/search/log" |
|
) |
|
|
|
// SearchGroup will search group by given conditions |
|
func (d *Dao) SearchGroup(c context.Context, cond *search.GroupSearchCommonCond) (resp *search.GroupSearchCommonResp, err error) { |
|
start := time.Now() |
|
var r *elastic.Request |
|
defer func() { |
|
log.Info("SearchGroup params(%s) group search ts %s err_or(%v)", r.Params(), time.Since(start).String(), err) |
|
}() |
|
|
|
r = d.es.NewRequest(search.GroupSrhComID).Index(search.GroupSrhComID).Fields(cond.Fields...). |
|
WhereEq("business", cond.Business).WhereIn("round", cond.Rounds).WhereIn("tid", cond.Tids). |
|
WhereIn("state", cond.States).WhereIn("mid", cond.Mids).WhereIn("oid", cond.Oids).WhereIn("typeid", cond.TypeIDs). |
|
WhereIn("fid", cond.FID).WhereIn("rid", cond.RID).WhereIn("eid", cond.EID). |
|
WhereIn("report_mid", cond.ReportMID).WhereIn("first_user_tid", cond.FirstUserTid). |
|
Order(cond.Order, cond.Sort). |
|
Pn(int(cond.PN)).Ps(int(cond.PS)) |
|
|
|
// 是否关键字匹配优先 |
|
if cond.KWPriority == true { |
|
r.OrderScoreFirst(true) |
|
} else { |
|
r.OrderScoreFirst(false) |
|
} |
|
if len(cond.KWFields) > 0 && len(cond.KWFields) == len(cond.KW) { |
|
r.WhereLike(cond.KWFields, cond.KW, true, elastic.LikeLevelMiddle) |
|
} |
|
r.WhereRange("ctime", cond.CTimeFrom, cond.CTimeTo, elastic.RangeScopeLcRc) |
|
|
|
if err = r.Scan(c, &resp); err != nil { |
|
log.Error("r.Scan(%+v) error(%v) params(%s)", resp, err, r.Params()) |
|
} |
|
return |
|
} |
|
|
|
// SearchGroupMultiPage . |
|
func (d *Dao) SearchGroupMultiPage(c context.Context, cond *search.GroupSearchCommonCond) (result []*search.GroupSearchCommonData, err error) { |
|
var resp *search.GroupSearchCommonResp |
|
cond.PS = 1000 |
|
cond.PN = 1 |
|
result = make([]*search.GroupSearchCommonData, 0, len(cond.IDs)) |
|
for { |
|
if resp, err = d.SearchGroup(c, cond); err != nil { |
|
return |
|
} |
|
result = append(result, resp.Result...) |
|
if len(resp.Result) < resp.Page.Size { |
|
break |
|
} |
|
cond.PN++ |
|
} |
|
return |
|
} |
|
|
|
// SearchChallenge will search challenge by given conditions |
|
func (d *Dao) SearchChallenge(c context.Context, cond *search.ChallSearchCommonCond) (resp *search.ChallSearchCommonResp, err error) { |
|
start := time.Now() |
|
var r *elastic.Request |
|
defer func() { |
|
log.Info("SearchChallenge params(%s) challenge search ts %s err_or(%v)", r.Params(), time.Since(start).String(), err) |
|
}() |
|
|
|
r = d.es.NewRequest(search.ChallSrhComID).Fields(cond.Fields...). |
|
WhereIn("id", cond.IDs).WhereIn("round", cond.Rounds).WhereIn("tid", cond.Tids).WhereIn("state", cond.States). |
|
WhereIn("business_state", cond.BusinessStates).WhereIn("mid", cond.Mids).WhereIn("oid", cond.Oids).WhereIn("typeid", cond.TypeIDs). |
|
WhereIn("gid", cond.Gids).WhereIn("assignee_adminid", cond.AssigneeAdminIDs).WhereIn("adminid", cond.AdminIDs) |
|
if cond.Business > 0 { |
|
r.WhereEq("business", cond.Business) |
|
} |
|
if len(cond.KWFields) > 0 && len(cond.KWFields) == len(cond.KW) { |
|
r.WhereLike(cond.KWFields, cond.KW, true, elastic.LikeLevelLow) |
|
} |
|
if cond.Order == "" { |
|
cond.Order = "id" |
|
} |
|
if cond.Sort == "" { |
|
cond.Sort = "desc" |
|
} |
|
r.Order(cond.Order, cond.Sort) |
|
r.WhereRange("ctime", cond.CTimeFrom, cond.CTimeTo, elastic.RangeScopeLcRc) |
|
if len(cond.Distinct) > 0 { |
|
for _, g := range cond.Distinct { |
|
r.GroupBy("distinct", g, nil) |
|
} |
|
} |
|
r.Index(search.ChallSrhComID) |
|
r.Pn(1) |
|
r.Ps(50) |
|
if cond.PN != 0 { |
|
r.Pn(int(cond.PN)) |
|
} |
|
if cond.PS != 0 { |
|
r.Ps(int(cond.PS)) |
|
} |
|
if err = r.Scan(c, &resp); err != nil { |
|
log.Error("r.Scan(%+v) error(%v) params(%s)", resp, err, r.Params()) |
|
} |
|
return |
|
} |
|
|
|
// SearchChallengeMultiPage . |
|
func (d *Dao) SearchChallengeMultiPage(c context.Context, cond *search.ChallSearchCommonCond) (result []*search.ChallSearchCommonData, err error) { |
|
var resp *search.ChallSearchCommonResp |
|
cond.PS = 1000 |
|
cond.PN = 1 |
|
result = make([]*search.ChallSearchCommonData, 0, len(cond.IDs)) |
|
for { |
|
if resp, err = d.SearchChallenge(c, cond); err != nil { |
|
return |
|
} |
|
result = append(result, resp.Result...) |
|
if len(resp.Result) < resp.Page.Size { |
|
break |
|
} |
|
cond.PN++ |
|
// return if result too long |
|
if cond.PN > 10 { |
|
log.Warn("cond(%+v) result is too long to degrade", cond) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// BatchUNameByUID will search unames by uids |
|
func (d *Dao) BatchUNameByUID(c context.Context, uids []int64) (UNames map[int64]string, err error) { |
|
//todo: local cache uname |
|
uri := _unameURI |
|
uv := url.Values{} |
|
UNames = make(map[int64]string) |
|
if len(uids) == 0 { |
|
return |
|
} |
|
uv.Set("uids", xstr.JoinInts(uids)) |
|
unameSchRes := new(manager.UNameSearchResult) |
|
if err = d.httpRead.Get(c, uri, "", uv, unameSchRes); err != nil { |
|
return |
|
} |
|
if unameSchRes.Code != ecode.OK.Code() { |
|
log.Error("search uname failed: %s?%s, error code(%d)", uri, uv.Get("uids"), unameSchRes.Code) |
|
err = ecode.Int(unameSchRes.Code) |
|
return |
|
} |
|
UNames = unameSchRes.Data |
|
return |
|
} |
|
|
|
// SearchAuditLogGroup search archive audit log from log platform |
|
func (d *Dao) SearchAuditLogGroup(c context.Context, cond *search.AuditLogGroupSearchCond) (auditLogSchRes *search.AuditLogSearchResult, err error) { |
|
uri := _srhAuditLogURI |
|
uv := cond.Query() |
|
auditLogSchRes = new(search.AuditLogSearchResult) |
|
if err = d.httpRead.Get(c, uri, "", uv, auditLogSchRes); err != nil { |
|
log.Error("call search audit log %s error(%v)", uri, err) |
|
return |
|
} |
|
if auditLogSchRes.Code != ecode.OK.Code() { |
|
log.Error("call search audit log %s result error code(%d), message(%s)", uri, auditLogSchRes.Code, auditLogSchRes.Message) |
|
err = ecode.Int(auditLogSchRes.Code) |
|
} |
|
return |
|
} |
|
|
|
// SearchAuditReportLog . |
|
func (d *Dao) SearchAuditReportLog(c context.Context, cond *search.AuditReportSearchCond) (resp *search.AuditLogSearchCommonResult, err error) { |
|
if len(cond.Fields) == 0 { |
|
return |
|
} |
|
r := d.es.NewRequest(search.LogAuditAction).Fields(cond.Fields...).WhereIn("uid", cond.UID).WhereIn("oid", cond.Oid). |
|
WhereEq("business", cond.Business).WhereIn("type", cond.Type).Order(cond.Order, cond.Sort).Pn(1).Ps(1000) |
|
|
|
indexPrefix := search.LogAuditAction + "_" + strconv.Itoa(cond.Business) |
|
if cond.IndexTimeType != "" { |
|
switch cond.IndexTimeType { |
|
case "year": |
|
r.IndexByTime(indexPrefix, elastic.IndexTypeYear, cond.IndexTimeFrom, cond.IndexTimeEnd) |
|
case "month": |
|
r.IndexByTime(indexPrefix, elastic.IndexTypeMonth, cond.IndexTimeFrom, cond.IndexTimeEnd) |
|
case "week": |
|
r.IndexByTime(indexPrefix, elastic.IndexTypeWeek, cond.IndexTimeFrom, cond.IndexTimeEnd) |
|
case "day": |
|
r.IndexByTime(indexPrefix, elastic.IndexTypeDay, cond.IndexTimeFrom, cond.IndexTimeEnd) |
|
default: |
|
r.Index(indexPrefix + "_all") |
|
} |
|
} else { |
|
r.Index(indexPrefix + "_all") |
|
} |
|
|
|
r.WhereIn("int_0", cond.Int0).WhereIn("int_1", cond.Int1).WhereIn("int_2", cond.Int2) |
|
if cond.Str0 != "" { |
|
r.WhereEq("str_0", cond.Str0) |
|
} |
|
if cond.Str1 != "" { |
|
r.WhereEq("str_1", cond.Str1) |
|
} |
|
if cond.Str2 != "" { |
|
r.WhereEq("str_2", cond.Str2) |
|
} |
|
|
|
if cond.Group != "" { |
|
r.GroupBy(elastic.EnhancedModeGroupBy, cond.Group, []map[string]string{{"ctime": "desc"}}) |
|
} |
|
|
|
if cond.Distinct != "" { |
|
r.GroupBy(elastic.EnhancedModeDistinct, cond.Distinct, []map[string]string{{"ctime": "desc"}}) |
|
} |
|
|
|
if err = r.Scan(c, &resp); err != nil { |
|
log.Error("r.Scan(%+v) error(%v) params(%s)", resp, err, r.Params()) |
|
} |
|
log.Info("SearchAuditReportLog end param(%v) err(%v)", r.Params(), err) |
|
return |
|
}
|
|
|