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.
1480 lines
51 KiB
1480 lines
51 KiB
package search |
|
|
|
import ( |
|
"context" |
|
"net/http" |
|
"net/url" |
|
"strconv" |
|
"time" |
|
|
|
"go-common/app/interface/main/app-interface/conf" |
|
arcdao "go-common/app/interface/main/app-interface/dao/archive" |
|
bangumidao "go-common/app/interface/main/app-interface/dao/bangumi" |
|
livedao "go-common/app/interface/main/app-interface/dao/live" |
|
"go-common/app/interface/main/app-interface/model" |
|
bangumimdl "go-common/app/interface/main/app-interface/model/bangumi" |
|
livemdl "go-common/app/interface/main/app-interface/model/live" |
|
"go-common/app/interface/main/app-interface/model/search" |
|
"go-common/app/service/main/archive/api" |
|
locmdl "go-common/app/service/main/location/model" |
|
locrpc "go-common/app/service/main/location/rpc/client" |
|
seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
httpx "go-common/library/net/http/blademaster" |
|
"go-common/library/net/metadata" |
|
"go-common/library/sync/errgroup" |
|
|
|
"github.com/pkg/errors" |
|
) |
|
|
|
const ( |
|
_main = "/main/search" |
|
_suggest = "/main/suggest" |
|
_hot = "/main/hotword" |
|
_defaultWords = "/widget/getSearchDefaultWords" |
|
_rcmd = "/query/recommend" |
|
_rcmdNoResult = "/search/recommend" |
|
_suggest3 = "/main/suggest/new" |
|
_pre = "/search/frontpage" |
|
) |
|
|
|
const ( |
|
_oldAndroid = 514000 |
|
_oldIOS = 6090 |
|
|
|
_searchCodeLimitAndroid = 5250001 |
|
_searchCodeLimitIPhone = 6680 |
|
) |
|
|
|
// Dao is search dao |
|
type Dao struct { |
|
c *conf.Config |
|
arcDao *arcdao.Dao |
|
liveDao *livedao.Dao |
|
bangumiDao *bangumidao.Dao |
|
client *httpx.Client |
|
client2 *httpx.Client |
|
main string |
|
suggest string |
|
hot string |
|
defaultWords string |
|
rcmd string |
|
rcmdNoResult string |
|
suggest3 string |
|
pre string |
|
// rpc |
|
locRPC *locrpc.Service |
|
} |
|
|
|
// New initial search dao |
|
func New(c *conf.Config) (d *Dao) { |
|
d = &Dao{ |
|
c: c, |
|
arcDao: arcdao.New(c), |
|
liveDao: livedao.New(c), |
|
bangumiDao: bangumidao.New(c), |
|
client: httpx.NewClient(c.HTTPSearch), |
|
client2: httpx.NewClient(c.HTTPClient), |
|
main: c.Host.Search + _main, |
|
suggest: c.Host.Search + _suggest, |
|
hot: c.Host.Search + _hot, |
|
defaultWords: c.Host.WWW + _defaultWords, |
|
rcmd: c.Host.Search + _rcmd, |
|
rcmdNoResult: c.Host.Search + _rcmdNoResult, |
|
suggest3: c.Host.Search + _suggest3, |
|
pre: c.Host.Search + _pre, |
|
locRPC: locrpc.New(c.LocationRPC), |
|
} |
|
return |
|
} |
|
|
|
// Search app all search . |
|
func (d *Dao) Search(c context.Context, mid, zoneid int64, mobiApp, device, platform, buvid, keyword, duration, order, filtered, fromSource, recommend, parent string, plat int8, seasonNum, movieNum, upUserNum, uvLimit, userNum, userVideoLimit, biliUserNum, biliUserVideoLimit, rid, highlight, build, pn, ps, isQuery int, old bool, now time.Time, newPGC, flow bool) (res *search.Search, code int, err error) { |
|
var ( |
|
req *http.Request |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
ipInfo *locmdl.Info |
|
) |
|
if ipInfo, err = d.locRPC.Info(c, &locmdl.ArgIP{IP: ip}); err != nil { |
|
log.Warn("%v", err) |
|
err = nil |
|
} |
|
res = &search.Search{} |
|
params := url.Values{} |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("keyword", keyword) |
|
params.Set("main_ver", "v3") |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("tids", strconv.Itoa(rid)) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
if newPGC { |
|
params.Set("media_bangumi_num", strconv.Itoa(seasonNum)) |
|
} else { |
|
params.Set("bangumi_num", strconv.Itoa(seasonNum)) |
|
params.Set("smerge", "1") |
|
} |
|
if (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) { |
|
params.Set("is_new_user", "1") |
|
} else { |
|
if old { |
|
params.Set("upuser_num", strconv.Itoa(upUserNum)) |
|
params.Set("uv_limit", strconv.Itoa(uvLimit)) |
|
} else { |
|
params.Set("bili_user_num", strconv.Itoa(biliUserNum)) |
|
params.Set("bili_user_vl", strconv.Itoa(biliUserVideoLimit)) |
|
} |
|
params.Set("user_num", strconv.Itoa(userNum)) |
|
params.Set("user_video_limit", strconv.Itoa(userVideoLimit)) |
|
params.Set("query_rec_need", recommend) |
|
} |
|
params.Set("platform", platform) |
|
params.Set("duration", duration) |
|
params.Set("order", order) |
|
params.Set("search_type", "all") |
|
params.Set("from_source", fromSource) |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
if model.IsOverseas(plat) { |
|
params.Set("use_area", "1") |
|
params.Set("zone_id", strconv.FormatInt(zoneid, 10)) |
|
} else if newPGC { |
|
params.Set("media_ft_num", strconv.Itoa(movieNum)) |
|
params.Set("is_new_pgc", "1") |
|
} else { |
|
params.Set("movie_num", strconv.Itoa(movieNum)) |
|
} |
|
if flow { |
|
params.Set("flow_need", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.ComicAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.ComicIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_comic", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > search.SearchLiveAllAndroid) || (model.IsIPhone(plat) && build > search.SearchLiveAllIOS) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
params.Set("new_live", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > search.SearchTwitterAndroid) || (model.IsIPhone(plat) && build > search.SearchTwitterIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_twitter", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.PGCHighLightAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.PGCHighLightIOS) { |
|
params.Set("app_highlight", "media_bangumi,media_ft") |
|
} |
|
if (model.IsAndroid(plat) && build >= search.SearchConvergeAndroid) || (model.IsIPhone(plat) && build >= search.SearchConvergeIOS) || model.IsIPhoneB(plat) { |
|
params.Set("card_num", "1") |
|
} |
|
params.Set("is_parents", parent) |
|
if (model.IsAndroid(plat) && build > search.SearchStarAndroid) || (model.IsIPhone(plat) && build > search.SearchStarIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_star", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.PGCALLAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.PGCALLIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_pgc_all", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > search.SearchTicketAndroid) || (model.IsIPhone(plat) && build > search.SearchTicketIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_ticket", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > search.SearchProductAndroid) || (model.IsIPhone(plat) && build > search.SearchProductIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_product", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SearchArticleAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SearchArticleIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_article", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.ChannelAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.ChannelIOS) { |
|
params.Set("is_tag", "1") |
|
} |
|
params.Set("is_org_query", strconv.Itoa(isQuery)) |
|
if ipInfo != nil { |
|
params.Set("user_city", ipInfo.City) |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
if err = d.client.Do(c, req, res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
} |
|
for _, flow := range res.FlowResult { |
|
flow.Change() |
|
} |
|
code = res.Code |
|
return |
|
} |
|
|
|
// Season search season data. |
|
func (d *Dao) Season(c context.Context, mid, zoneID int64, keyword, mobiApp, device, platform, buvid, filtered string, plat int8, build, pn, ps int, now time.Time) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("keyword", keyword) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("func", "search") |
|
params.Set("smerge", "1") |
|
params.Set("search_type", "bangumi") |
|
params.Set("source_type", "0") |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
if model.IsOverseas(plat) { |
|
params.Set("use_area", "1") |
|
params.Set("zone_id", strconv.FormatInt(zoneID, 10)) |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.Bangumi `json:"result"` |
|
} |
|
// do |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
if (model.IsAndroid(plat) && build <= _oldAndroid) || (model.IsIPhone(plat) && build <= _oldIOS) { |
|
si.FromSeason(v, model.GotoBangumi) |
|
} else { |
|
si.FromSeason(v, model.GotoBangumiWeb) |
|
} |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// Upper search upper data. |
|
func (d *Dao) Upper(c context.Context, mid int64, keyword, mobiApp, device, platform, buvid, filtered, order string, biliUserVL, highlight, build, userType, orderSort, pn, ps int, old bool, now time.Time) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
avids []int64 |
|
avm map[int64]*api.Arc |
|
roomIDs []int64 |
|
lm map[int64]*livemdl.RoomInfo |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("keyword", keyword) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("func", "search") |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("smerge", "1") |
|
params.Set("platform", platform) |
|
params.Set("build", strconv.Itoa(build)) |
|
if old { |
|
params.Set("search_type", "upuser") |
|
} else { |
|
params.Set("search_type", "bili_user") |
|
params.Set("bili_user_vl", strconv.Itoa(biliUserVL)) |
|
params.Set("user_type", strconv.Itoa(userType)) |
|
params.Set("order_sort", strconv.Itoa(orderSort)) |
|
} |
|
params.Set("order", order) |
|
params.Set("source_type", "0") |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.User `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
for _, vr := range v.Res { |
|
avids = append(avids, vr.Aid) |
|
} |
|
roomIDs = append(roomIDs, v.RoomID) |
|
} |
|
g, ctx := errgroup.WithContext(c) |
|
if len(avids) != 0 { |
|
g.Go(func() (err error) { |
|
if avm, err = d.arcDao.Archives2(ctx, avids); err != nil { |
|
log.Error("Upper %+v", err) |
|
err = nil |
|
} |
|
return |
|
}) |
|
} |
|
if len(roomIDs) > 0 { |
|
g.Go(func() (err error) { |
|
if lm, err = d.liveDao.LiveByRIDs(ctx, roomIDs); err != nil { |
|
log.Error("Upper %+v", err) |
|
err = nil |
|
} |
|
return |
|
}) |
|
} |
|
if err = g.Wait(); err != nil { |
|
log.Error("%+v", err) |
|
return |
|
} |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromUpUser(v, avm, lm[v.RoomID]) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// MovieByType search movie data from api . |
|
func (d *Dao) MovieByType(c context.Context, mid, zoneid int64, keyword, mobiApp, device, platform, buvid, filtered string, plat int8, build, pn, ps int, now time.Time) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
avids []int64 |
|
avm map[int64]*api.Arc |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("search_type", "pgc") |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("order", "totalrank") |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
if model.IsOverseas(plat) { |
|
params.Set("use_area", "1") |
|
params.Set("zone_id", strconv.FormatInt(zoneid, 10)) |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.Movie `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
if v.Type == "movie" { |
|
avids = append(avids, v.Aid) |
|
} |
|
} |
|
if len(avids) != 0 { |
|
if avm, err = d.arcDao.Archives2(c, avids); err != nil { |
|
log.Error("RecommendNoResult %+v", err) |
|
err = nil |
|
} |
|
} |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromMovie(v, avm) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// LiveByType search by diff type |
|
func (d *Dao) LiveByType(c context.Context, mid, zoneid int64, keyword, mobiApp, device, platform, buvid, filtered, order, sType string, plat int8, build, pn, ps int, now time.Time) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
// roomIDs []int64 |
|
// lm map[int64]*livemdl.RoomInfo |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("search_type", sType) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("order", order) |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
if model.IsOverseas(plat) { |
|
params.Set("use_area", "1") |
|
params.Set("zone_id", strconv.FormatInt(zoneid, 10)) |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.Live `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
// for _, v := range res.List { |
|
// roomIDs = append(roomIDs, v.RoomID) |
|
// } |
|
// if len(roomIDs) > 0 { |
|
// if lm, err = d.liveDao.LiveByRIDs(c, roomIDs, ip); err != nil { |
|
// log.Error("LiveByType %+v", err) |
|
// err = nil |
|
// } |
|
// } |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromLive(v, nil) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// Live search for live |
|
func (d *Dao) Live(c context.Context, mid int64, keyword, mobiApp, platform, buvid, device, order, sType string, build, pn, ps int) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
roomIDs []int64 |
|
lm map[int64]*livemdl.RoomInfo |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("search_type", sType) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("device", device) |
|
params.Set("order", order) |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.Live `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
if !model.IsAndroid(plat) || (model.IsAndroid(plat) && build > search.LiveBroadcastTypeAndroid) { |
|
for _, v := range res.List { |
|
roomIDs = append(roomIDs, v.RoomID) |
|
} |
|
if len(roomIDs) > 0 { |
|
if lm, err = d.liveDao.LiveByRIDs(c, roomIDs); err != nil { |
|
log.Error("Live %+v", err) |
|
err = nil |
|
} |
|
} |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromLive2(v, lm[v.RoomID]) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// LiveAll search for live version > 5.28 |
|
func (d *Dao) LiveAll(c context.Context, mid int64, keyword, mobiApp, platform, buvid, device, order, sType string, build, pn, ps int) (st *search.TypeSearchLiveAll, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
roomIDs []int64 |
|
lm map[int64]*livemdl.RoomInfo |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("search_type", sType) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("live_room_num", strconv.Itoa(ps)) |
|
params.Set("device", device) |
|
params.Set("order", order) |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
PageInfo *struct { |
|
Master *search.Live `json:"live_master"` |
|
Room *search.Live `json:"live_room"` |
|
} `json:"pageinfo"` |
|
List *struct { |
|
Master []*search.Live `json:"live_master"` |
|
Room []*search.Live `json:"live_room"` |
|
} `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || model.IsIPad(plat) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
st = &search.TypeSearchLiveAll{ |
|
TrackID: res.SeID, |
|
Pages: res.Pages, |
|
Master: &search.TypeSearch{}, |
|
Room: &search.TypeSearch{}, |
|
} |
|
if res.PageInfo != nil { |
|
if res.PageInfo.Master != nil { |
|
st.Master.Pages = res.PageInfo.Master.Pages |
|
st.Master.Total = res.PageInfo.Master.Total |
|
} |
|
if res.PageInfo.Room != nil { |
|
st.Room.Pages = res.PageInfo.Room.Pages |
|
st.Room.Total = res.PageInfo.Room.Total |
|
} |
|
} |
|
if res.List != nil { |
|
if !model.IsAndroid(plat) || (model.IsAndroid(plat) && build > search.LiveBroadcastTypeAndroid) { |
|
for _, v := range res.List.Master { |
|
roomIDs = append(roomIDs, v.RoomID) |
|
} |
|
for _, v := range res.List.Room { |
|
roomIDs = append(roomIDs, v.RoomID) |
|
} |
|
if len(roomIDs) > 0 { |
|
if lm, err = d.liveDao.LiveByRIDs(c, roomIDs); err != nil { |
|
log.Error("LiveAll %+v", err) |
|
err = nil |
|
} |
|
} |
|
} |
|
st.Master.Items = make([]*search.Item, 0, len(res.List.Master)) |
|
for _, v := range res.List.Master { |
|
si := &search.Item{} |
|
si.FromLiveMaster(v, lm[v.RoomID]) |
|
st.Master.Items = append(st.Master.Items, si) |
|
} |
|
st.Room.Items = make([]*search.Item, 0, len(res.List.Room)) |
|
for _, v := range res.List.Room { |
|
si := &search.Item{} |
|
si.FromLive2(v, lm[v.RoomID]) |
|
st.Room.Items = append(st.Room.Items, si) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ArticleByType search article. |
|
func (d *Dao) ArticleByType(c context.Context, mid, zoneid int64, keyword, mobiApp, device, platform, buvid, filtered, order, sType string, plat int8, categoryID, build, highlight, pn, ps int, now time.Time) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("search_type", sType) |
|
params.Set("category_id", strconv.Itoa(categoryID)) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("order", order) |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
if model.IsOverseas(plat) { |
|
params.Set("use_area", "1") |
|
params.Set("zone_id", strconv.FormatInt(zoneid, 10)) |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.Article `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromArticle(v, nil) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// HotSearch is hot words search data. |
|
func (d *Dao) HotSearch(c context.Context, buvid string, mid int64, build, limit int, mobiApp, device, platform string, now time.Time) (res *search.Hot, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("actionKey", "appkey") |
|
params.Set("limit", strconv.Itoa(limit)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
req, err := d.client.NewRequest("GET", d.hot, ip, params) |
|
if err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrap(ecode.Int(res.Code), d.hot+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
|
|
// Suggest suggest data. |
|
func (d *Dao) Suggest(c context.Context, mid int64, buvid, term string, build int, mobiApp, device string, now time.Time) (res *search.Suggest, err error) { |
|
plat := model.Plat(mobiApp, device) |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v4") |
|
params.Set("func", "suggest") |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("buvid", buvid) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("bangumi_acc_num", "3") |
|
params.Set("special_acc_num", "3") |
|
params.Set("topic_acc_num", "3") |
|
params.Set("upuser_acc_num", "1") |
|
params.Set("tag_num", "10") |
|
params.Set("special_num", "10") |
|
params.Set("bangumi_num", "10") |
|
params.Set("upuser_num", "3") |
|
params.Set("suggest_type", "accurate") |
|
params.Set("term", term) |
|
res = &search.Suggest{} |
|
if err = d.client.Get(c, d.suggest, ip, params, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.suggest+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.suggest+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
if res.ResultBs == nil { |
|
return |
|
} |
|
switch v := res.ResultBs.(type) { |
|
case []interface{}: |
|
return |
|
case map[string]interface{}: |
|
if acc, ok := v["accurate"]; ok { |
|
if accm, ok := acc.(map[string]interface{}); ok && accm != nil { |
|
res.Result.Accurate.UpUser = accm["upuser"] |
|
res.Result.Accurate.Bangumi = accm["bangumi"] |
|
} |
|
} |
|
if tag, ok := v["tag"]; ok { |
|
if tags, ok := tag.([]interface{}); ok { |
|
for _, t := range tags { |
|
if tm, ok := t.(map[string]interface{}); ok && tm != nil { |
|
if v, ok := tm["value"]; ok { |
|
if vs, ok := v.(string); ok { |
|
res.Result.Tag = append(res.Result.Tag, &struct { |
|
Value string `json:"value,omitempty"` |
|
}{vs}) |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Suggest2 suggest data. |
|
func (d *Dao) Suggest2(c context.Context, mid int64, platform, buvid, term string, build int, mobiApp string, now time.Time) (res *search.Suggest2, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v4") |
|
params.Set("suggest_type", "accurate") |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("clientip", ip) |
|
params.Set("build", strconv.Itoa(build)) |
|
if mid != 0 { |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
} |
|
params.Set("term", term) |
|
params.Set("sug_num", "10") |
|
params.Set("buvid", buvid) |
|
res = &search.Suggest2{} |
|
if err = d.client.Get(c, d.suggest, ip, params, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrap(ecode.Int(res.Code), d.suggest+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
|
|
// Suggest3 suggest data. |
|
func (d *Dao) Suggest3(c context.Context, mid int64, platform, buvid, term, device string, build, highlight int, mobiApp string, now time.Time) (res *search.Suggest3, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("suggest_type", "accurate") |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("clientip", ip) |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("build", strconv.Itoa(build)) |
|
if mid != 0 { |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
} |
|
params.Set("term", term) |
|
params.Set("sug_num", "10") |
|
params.Set("buvid", buvid) |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SugDetailAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SugDetailIOS) { |
|
params.Set("is_detail_info", "1") |
|
} |
|
if req, err = d.client.NewRequest("GET", d.suggest3, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
res = &search.Suggest3{} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrap(ecode.Int(res.Code), d.suggest3+"?"+params.Encode()) |
|
return |
|
} |
|
for _, flow := range res.Result { |
|
flow.SugChange() |
|
} |
|
return |
|
} |
|
|
|
// Season2 search new season data. |
|
func (d *Dao) Season2(c context.Context, mid int64, keyword, mobiApp, device, platform, buvid string, highlight, build, pn, ps int) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
seasonIDs []int64 |
|
bangumis map[string]*bangumimdl.Card |
|
) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("keyword", keyword) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("search_type", "media_bangumi") |
|
params.Set("order", "totalrank") |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("app_highlight", "media_bangumi") |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.PGCALLAndroid) || (model.IsIPhone(plat) && build >= d.c.SearchBuildLimit.PGCALLIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_pgc_all", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Total int `json:"numResults"` |
|
Pages int `json:"numPages"` |
|
List []*search.Media `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
for _, v := range res.List { |
|
seasonIDs = append(seasonIDs, v.SeasonID) |
|
} |
|
if len(seasonIDs) > 0 { |
|
if bangumis, err = d.bangumiDao.Card(c, mid, seasonIDs); err != nil { |
|
log.Error("Season2 %+v", err) |
|
err = nil |
|
} |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromMedia(v, "", model.GotoBangumi, bangumis) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Total: res.Total, Items: items} |
|
return |
|
} |
|
|
|
// MovieByType2 search new movie data from api . |
|
func (d *Dao) MovieByType2(c context.Context, mid int64, keyword, mobiApp, device, platform, buvid string, highlight, build, pn, ps int) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
seasonIDs []int64 |
|
bangumis map[string]*bangumimdl.Card |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("search_type", "media_ft") |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("order", "totalrank") |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("app_highlight", "media_ft") |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.PGCALLAndroid) || (model.IsIPhone(plat) && build >= d.c.SearchBuildLimit.PGCALLIOS) || model.IsIPhoneB(plat) { |
|
params.Set("is_pgc_all", "1") |
|
} |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Total int `json:"numResults"` |
|
Pages int `json:"numPages"` |
|
List []*search.Media `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
for _, v := range res.List { |
|
seasonIDs = append(seasonIDs, v.SeasonID) |
|
} |
|
if len(seasonIDs) > 0 { |
|
if bangumis, err = d.bangumiDao.Card(c, mid, seasonIDs); err != nil { |
|
log.Error("MovieByType2 %+v", err) |
|
err = nil |
|
} |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromMedia(v, "", model.GotoMovie, bangumis) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Total: res.Total, Items: items} |
|
return |
|
} |
|
|
|
// User search user data. |
|
func (d *Dao) User(c context.Context, mid int64, keyword, mobiApp, device, platform, buvid, filtered, order, fromSource string, highlight, build, userType, orderSort, pn, ps int, now time.Time) (user []*search.User, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("keyword", keyword) |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("main_ver", "v3") |
|
params.Set("func", "search") |
|
params.Set("smerge", "1") |
|
params.Set("source_type", "0") |
|
params.Set("search_type", "bili_user") |
|
params.Set("user_type", strconv.Itoa(userType)) |
|
params.Set("order", order) |
|
params.Set("order_sort", strconv.Itoa(orderSort)) |
|
params.Set("from_source", fromSource) |
|
if filtered == "1" { |
|
params.Set("filtered", filtered) |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.User `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if (model.IsAndroid(plat) && build > _searchCodeLimitAndroid) || (model.IsIPhone(plat) && build > _searchCodeLimitIPhone) || (plat == model.PlatIPad && build >= search.SearchNewIPad) || (plat == model.PlatIpadHD && build >= search.SearchNewIPadHD) || model.IsIPhoneB(plat) { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} else if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
user = res.List |
|
return |
|
} |
|
|
|
// Recommend is recommend search data. |
|
func (d *Dao) Recommend(c context.Context, mid int64, build, from, show int, buvid, platform, mobiApp, device string) (res *search.RecommendResult, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("clientip", ip) |
|
params.Set("device", device) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("search_type", "guess") |
|
params.Set("req_source", strconv.Itoa(from)) |
|
params.Set("show_area", strconv.Itoa(show)) |
|
req, err := d.client.NewRequest("GET", d.rcmd, ip, params) |
|
if err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var rcmdRes struct { |
|
Code int `json:"code,omitempty"` |
|
SeID string `json:"seid,omitempty"` |
|
Tips string `json:"recommend_tips,omitempty"` |
|
NumResult int `json:"numResult,omitempty"` |
|
Resutl []struct { |
|
ID int64 `json:"id,omitempty"` |
|
Name string `json:"name,omitempty"` |
|
Type string `json:"type,omitempty"` |
|
} `json:"result,omitempty"` |
|
} |
|
if err = d.client.Do(c, req, &rcmdRes); err != nil { |
|
return |
|
} |
|
if rcmdRes.Code != ecode.OK.Code() { |
|
if rcmdRes.Code != model.ForbidCode { |
|
err = errors.Wrap(ecode.Int(rcmdRes.Code), d.rcmd+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
res = &search.RecommendResult{TrackID: rcmdRes.SeID, Title: rcmdRes.Tips, Pages: rcmdRes.NumResult} |
|
for _, v := range rcmdRes.Resutl { |
|
item := &search.Item{} |
|
item.ID = v.ID |
|
item.Param = strconv.Itoa(int(v.ID)) |
|
item.Title = v.Name |
|
item.Type = v.Type |
|
res.Items = append(res.Items, item) |
|
} |
|
return |
|
} |
|
|
|
// DefaultWords is default words search data. |
|
func (d *Dao) DefaultWords(c context.Context, mid int64, build, from int, buvid, platform, mobiApp, device string) (res *search.DefaultWords, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("clientip", ip) |
|
params.Set("device", device) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("search_type", "default") |
|
params.Set("req_source", strconv.Itoa(from)) |
|
req, err := d.client.NewRequest("GET", d.rcmd, ip, params) |
|
if err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var rcmdRes struct { |
|
Code int `json:"code,omitempty"` |
|
SeID string `json:"seid,omitempty"` |
|
Tips string `json:"recommend_tips,omitempty"` |
|
NumResult int `json:"numResult,omitempty"` |
|
ShowFront int `json:"show_front,omitempty"` |
|
Resutl []struct { |
|
ID int64 `json:"id,omitempty"` |
|
Name string `json:"name,omitempty"` |
|
ShowName string `json:"show_name,omitempty"` |
|
Type string `json:"type,omitempty"` |
|
} `json:"result,omitempty"` |
|
} |
|
if err = d.client.Do(c, req, &rcmdRes); err != nil { |
|
return |
|
} |
|
if rcmdRes.Code != ecode.OK.Code() { |
|
if rcmdRes.Code != model.ForbidCode { |
|
err = errors.Wrap(ecode.Int(rcmdRes.Code), d.rcmd+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
if len(rcmdRes.Resutl) == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
res = &search.DefaultWords{} |
|
for _, v := range rcmdRes.Resutl { |
|
res.Trackid = rcmdRes.SeID |
|
res.Param = strconv.Itoa(int(v.ID)) |
|
res.Show = v.ShowName |
|
res.Word = v.Name |
|
res.ShowFront = rcmdRes.ShowFront |
|
} |
|
return |
|
} |
|
|
|
// RecommendNoResult is no result recommend search data. |
|
func (d *Dao) RecommendNoResult(c context.Context, platform, mobiApp, device, buvid, keyword string, build, pn, ps int, mid int64) (res *search.NoResultRcndResult, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("clientip", ip) |
|
params.Set("device", device) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("search_type", "video") |
|
params.Set("keyword", keyword) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
req, err := d.client.NewRequest("GET", d.rcmdNoResult, ip, params) |
|
if err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var ( |
|
resTmp *search.NoResultRcmd |
|
avids []int64 |
|
avm map[int64]*api.Arc |
|
cooperation bool |
|
) |
|
if err = d.client.Do(c, req, &resTmp); err != nil { |
|
return |
|
} |
|
if resTmp.Code != ecode.OK.Code() { |
|
if resTmp.Code != model.ForbidCode { |
|
err = errors.Wrap(ecode.Int(resTmp.Code), d.rcmdNoResult+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
res = &search.NoResultRcndResult{TrackID: resTmp.Trackid, Title: resTmp.RecommendTips, Pages: resTmp.NumResults} |
|
for _, v := range resTmp.Result { |
|
avids = append(avids, v.ID) |
|
} |
|
if len(avids) != 0 { |
|
if avm, err = d.arcDao.Archives2(c, avids); err != nil { |
|
log.Error("RecommendNoResult %+v", err) |
|
err = nil |
|
} |
|
} |
|
items := make([]*search.Item, 0, len(resTmp.Result)) |
|
for _, v := range resTmp.Result { |
|
ri := &search.Item{} |
|
ri.FromVideo(v, avm[v.ID], cooperation) |
|
items = append(items, ri) |
|
} |
|
res.Items = items |
|
return |
|
} |
|
|
|
// Channel for search channel |
|
func (d *Dao) Channel(c context.Context, mid int64, keyword, mobiApp, platform, buvid, device, order, sType string, build, pn, ps, highlight int) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
plat = model.Plat(mobiApp, device) |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
) |
|
params := url.Values{} |
|
params.Set("keyword", keyword) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("platform", platform) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("main_ver", "v3") |
|
params.Set("search_type", sType) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("device", device) |
|
params.Set("order", order) |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
// new request |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Pages int `json:"numPages"` |
|
List []*search.Channel `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
if res.Code != model.ForbidCode && res.Code != model.NoResultCode { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
avm := make(map[int64]*api.Arc) |
|
bangumis := make(map[int32]*seasongrpc.CardInfoProto) |
|
lm := make(map[int64]*livemdl.RoomInfo) |
|
si.FromChannel(v, avm, bangumis, lm, nil) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Items: items} |
|
return |
|
} |
|
|
|
// RecommendPre search at pre-page |
|
func (d *Dao) RecommendPre(c context.Context, platform, mobiApp, device, buvid string, build, ps int, mid int64) (res *search.RecommendPreResult, err error) { |
|
ip := metadata.String(c, metadata.RemoteIP) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("clientip", ip) |
|
params.Set("device", device) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("search_type", "discover_page") |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
req, err := d.client.NewRequest("GET", d.pre, ip, params) |
|
if err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var ( |
|
resTmp *search.RecommendPre |
|
avids []int64 |
|
avm map[int64]*api.Arc |
|
seasonIDs []int32 |
|
bangumis map[int32]*seasongrpc.CardInfoProto |
|
) |
|
if err = d.client.Do(c, req, &resTmp); err != nil { |
|
return |
|
} |
|
if resTmp.Code != ecode.OK.Code() { |
|
if resTmp.Code != model.ForbidCode { |
|
err = errors.Wrap(ecode.Int(resTmp.Code), d.pre+"?"+params.Encode()) |
|
} |
|
return |
|
} |
|
for _, v := range resTmp.Result { |
|
for _, vv := range v.List { |
|
if vv.Type == "video" { |
|
avids = append(avids, vv.ID) |
|
} else if vv.Type == "pgc" { |
|
seasonIDs = append(seasonIDs, int32(vv.ID)) |
|
} |
|
} |
|
} |
|
g, ctx := errgroup.WithContext(c) |
|
if len(avids) != 0 { |
|
g.Go(func() (err error) { |
|
if avm, err = d.arcDao.Archives2(ctx, avids); err != nil { |
|
log.Error("RecommendPre avids(%v) error(%v)", avids, err) |
|
err = nil |
|
} |
|
return |
|
}) |
|
} |
|
if len(seasonIDs) > 0 { |
|
g.Go(func() (err error) { |
|
if bangumis, err = d.bangumiDao.Cards(c, seasonIDs); err != nil { |
|
log.Error("RecommendPre seasonIDs(%v) error(%v)", seasonIDs, err) |
|
err = nil |
|
} |
|
return |
|
}) |
|
} |
|
if err = g.Wait(); err != nil { |
|
log.Error("%+v", err) |
|
return |
|
} |
|
res = &search.RecommendPreResult{TrackID: resTmp.Trackid, Total: resTmp.NumResult} |
|
items := make([]*search.Item, 0, len(resTmp.Result)) |
|
for _, v := range resTmp.Result { |
|
rs := &search.Item{Title: v.Query} |
|
for _, vv := range v.List { |
|
if vv.Type == "video" { |
|
if a, ok := avm[vv.ID]; ok { |
|
r := &search.Item{} |
|
r.FromRcmdPre(vv.ID, a, nil) |
|
rs.Item = append(rs.Item, r) |
|
} |
|
} else if vv.Type == "pgc" { |
|
if b, ok := bangumis[int32(vv.ID)]; ok { |
|
r := &search.Item{} |
|
r.FromRcmdPre(vv.ID, nil, b) |
|
rs.Item = append(rs.Item, r) |
|
} |
|
} |
|
} |
|
items = append(items, rs) |
|
} |
|
res.Items = items |
|
return |
|
} |
|
|
|
// Video search new archive data. |
|
func (d *Dao) Video(c context.Context, mid int64, keyword, mobiApp, device, platform, buvid string, highlight, build, pn, ps int) (st *search.TypeSearch, err error) { |
|
var ( |
|
req *http.Request |
|
ip = metadata.String(c, metadata.RemoteIP) |
|
plat = model.Plat(mobiApp, device) |
|
avids []int64 |
|
avm map[int64]*api.Arc |
|
cooperation bool |
|
) |
|
params := url.Values{} |
|
params.Set("main_ver", "v3") |
|
params.Set("platform", platform) |
|
params.Set("build", strconv.Itoa(build)) |
|
params.Set("keyword", keyword) |
|
params.Set("userid", strconv.FormatInt(mid, 10)) |
|
params.Set("mobi_app", mobiApp) |
|
params.Set("device", device) |
|
params.Set("page", strconv.Itoa(pn)) |
|
params.Set("pagesize", strconv.Itoa(ps)) |
|
params.Set("search_type", "video") |
|
params.Set("order", "totalrank") |
|
params.Set("highlight", strconv.Itoa(highlight)) |
|
if (model.IsAndroid(plat) && build > d.c.SearchBuildLimit.SpecialerGuideAndroid) || (model.IsIPhone(plat) && build > d.c.SearchBuildLimit.SpecialerGuideIOS) { |
|
params.Set("is_special_guide", "1") |
|
} |
|
if req, err = d.client.NewRequest("GET", d.main, ip, params); err != nil { |
|
return |
|
} |
|
req.Header.Set("Buvid", buvid) |
|
var res struct { |
|
Code int `json:"code"` |
|
SeID string `json:"seid"` |
|
Total int `json:"numResults"` |
|
Pages int `json:"numPages"` |
|
List []*search.Video `json:"result"` |
|
} |
|
if err = d.client.Do(c, req, &res); err != nil { |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrap(ecode.Int(res.Code), d.main+"?"+params.Encode()) |
|
return |
|
} |
|
for _, v := range res.List { |
|
avids = append(avids, v.ID) |
|
} |
|
if len(avids) > 0 { |
|
if avm, err = d.arcDao.Archives2(c, avids); err != nil { |
|
log.Error("Upper %+v", err) |
|
err = nil |
|
} |
|
} |
|
items := make([]*search.Item, 0, len(res.List)) |
|
for _, v := range res.List { |
|
si := &search.Item{} |
|
si.FromVideo(v, avm[v.ID], cooperation) |
|
items = append(items, si) |
|
} |
|
st = &search.TypeSearch{TrackID: res.SeID, Pages: res.Pages, Total: res.Total, Items: items} |
|
return |
|
}
|
|
|