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.
215 lines
6.9 KiB
215 lines
6.9 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"time" |
|
|
|
"go-common/app/admin/main/mcn/model" |
|
dtmdl "go-common/app/interface/main/mcn/model/datamodel" |
|
accgrpc "go-common/app/service/main/account/api" |
|
arcgrpc "go-common/app/service/main/archive/api" |
|
"go-common/library/log" |
|
"go-common/library/sync/errgroup" |
|
xtime "go-common/library/time" |
|
|
|
"github.com/pkg/errors" |
|
) |
|
|
|
// ArcTopDataStatistics . |
|
func (s *Service) ArcTopDataStatistics(c context.Context, arg *model.McnGetRankReq) (res *model.McnGetRankUpFansReply, err error) { |
|
return s.dao.ArcTopDataStatistics(c, arg) |
|
} |
|
|
|
// McnsTotalDatas . |
|
func (s *Service) McnsTotalDatas(c context.Context, arg *model.TotalMcnDataReq) (res *model.TotalMcnDataInfo, err error) { |
|
var ( |
|
signUpsTotal, FanTotal, videoupTotal, playTotal int64 |
|
mids, fansMids, ArcsMids, avids, tids, arcsTids, typeTids []int64 |
|
m *model.McnDataOverview |
|
mrf map[int8][]*model.McnRankFansOverview |
|
ras []*model.McnRankArchiveLikesOverview |
|
mmd map[string][]*model.McnDataTypeSummary |
|
) |
|
td := new(thirdDataMap) |
|
res = new(model.TotalMcnDataInfo) |
|
res.TopInfo = new(model.McnDataTopInfo) |
|
res.TypesInfo = new(model.McnDataTypesInfo) |
|
date := xtime.Time(time.Date(arg.Date.Time().Year(), arg.Date.Time().Month(), arg.Date.Time().Day()-1, 0, 0, 0, 0, time.Local).Unix()) |
|
if m, err = s.dao.McnDataOverview(c, date); err != nil { |
|
return |
|
} |
|
res.BaseInfo = m |
|
if mrf, fansMids, err = s.dao.McnRankFansOverview(c, model.DataTypeDay, date, model.TopDataLenth); err != nil { |
|
return |
|
} |
|
if ras, ArcsMids, avids, arcsTids, err = s.dao.McnRankArchiveLikesOverview(c, model.DataTypeDay, date, model.TopDataLenth); err != nil { |
|
return |
|
} |
|
if mmd, typeTids, err = s.dao.McnDataTypeSummary(c, date); err != nil { |
|
return |
|
} |
|
mids = append(mids, fansMids...) |
|
mids = append(mids, ArcsMids...) |
|
tids = append(tids, arcsTids...) |
|
tids = append(tids, typeTids...) |
|
if td.infosReply, err = s.accGRPC.Infos3(c, &accgrpc.MidsReq{Mids: mids}); err != nil { |
|
log.Error("s.accGRPC.Infos3(%+v) error(%+v)", mids, err) |
|
err = nil |
|
} |
|
if td.archivesReply, err = s.arcGRPC.Arcs(c, &arcgrpc.ArcsRequest{Aids: avids}); err != nil { |
|
log.Error("s.arcGRPC.Arcs(%+v) error(%+v)", avids, err) |
|
err = nil |
|
} |
|
td.tpNames = s.videoup.GetTidName(tids) |
|
for view, data := range mrf { |
|
for _, v := range data { |
|
var ( |
|
rateIncr int64 |
|
name, _, _, _ = td.getTypeName(v.Mid, 0, 0, 0) |
|
) |
|
if v.Fans != 0 { |
|
rateIncr = (10000 * v.FansIncr) / v.Fans |
|
} |
|
fr := &model.FansRankIncr{Mid: v.Mid, Name: name, Rank: v.Rank, FansIncr: v.FansIncr, Fans: v.Fans, RateIncr: rateIncr, SignID: v.SignID} |
|
switch model.DataViewFansTop(view) { |
|
case model.McnFansIncr: |
|
res.TopInfo.McnFansIncr = append(res.TopInfo.McnFansIncr, fr) |
|
case model.McnFansIncrRate: |
|
res.TopInfo.McnFansRateIncr = append(res.TopInfo.McnFansRateIncr, fr) |
|
case model.UpFansIncr: |
|
res.TopInfo.UpFansIncr = append(res.TopInfo.UpFansIncr, fr) |
|
case model.UpFansIncrRate: |
|
res.TopInfo.UpFansRateIncr = append(res.TopInfo.UpFansRateIncr, fr) |
|
} |
|
} |
|
} |
|
for _, v := range ras { |
|
var mcnName, upName, avTitle, tpName = td.getTypeName(v.McnMid, v.UpMid, v.Avid, int64(v.Tid)) |
|
lr := &model.LikesRankIncr{McnMid: v.McnMid, McnName: mcnName, |
|
UpMid: v.UpMid, UpName: upName, AVID: v.Avid, AVTitle: avTitle, |
|
TID: v.Tid, TypeName: tpName, LikesIncr: v.Likes, PlayIncr: v.Plays, SignID: v.SignID} |
|
res.TopInfo.ArcLikesIncr = append(res.TopInfo.ArcLikesIncr, lr) |
|
} |
|
for vt, data := range mmd { |
|
for _, v := range data { |
|
var _, _, _, tpName = td.getTypeName(0, 0, 0, int64(v.Tid)) |
|
dt := &model.DataTypes{TID: v.Tid, TypeName: tpName, Amount: v.Amount} |
|
switch vt { |
|
case fmt.Sprintf("%d-%d", model.SignUpsAccumulate, model.DataTypeAccumulate): |
|
signUpsTotal += v.Amount |
|
res.TypesInfo.SignUps = append(res.TypesInfo.SignUps, dt) |
|
case fmt.Sprintf("%d-%d", model.FansIncr, model.DataTypeDay): |
|
FanTotal += v.Amount |
|
res.TypesInfo.FansIncr = append(res.TypesInfo.FansIncr, dt) |
|
case fmt.Sprintf("%d-%d", model.VideoUpsIncr, model.DataTypeDay): |
|
videoupTotal += v.Amount |
|
res.TypesInfo.VideoupIncr = append(res.TypesInfo.VideoupIncr, dt) |
|
case fmt.Sprintf("%d-%d", model.PlaysIncr, model.DataTypeDay): |
|
playTotal += v.Amount |
|
res.TypesInfo.PlayIncr = append(res.TypesInfo.PlayIncr, dt) |
|
} |
|
} |
|
} |
|
statTypeRate(res.TypesInfo.SignUps, signUpsTotal) |
|
statTypeRate(res.TypesInfo.FansIncr, FanTotal) |
|
statTypeRate(res.TypesInfo.VideoupIncr, videoupTotal) |
|
statTypeRate(res.TypesInfo.PlayIncr, playTotal) |
|
return |
|
} |
|
|
|
type thirdDataMap struct { |
|
tpNames map[int64]string |
|
infosReply *accgrpc.InfosReply |
|
archivesReply *arcgrpc.ArcsReply |
|
} |
|
|
|
func (td *thirdDataMap) getTypeName(mcnMid, upMid, avid, tid int64) (mcnName, upName, avTitle, tpName string) { |
|
if td.infosReply != nil { |
|
infos := td.infosReply.Infos |
|
if info, ok := infos[mcnMid]; ok { |
|
mcnName = info.Name |
|
} |
|
if info, ok := infos[upMid]; ok { |
|
upName = info.Name |
|
} |
|
} |
|
if td.archivesReply != nil { |
|
archives := td.archivesReply.Arcs |
|
if archive, ok := archives[avid]; ok { |
|
avTitle = archive.Title |
|
} |
|
} |
|
tpName = td.tpNames[tid] |
|
return |
|
} |
|
|
|
func statTypeRate(dts []*model.DataTypes, total int64) { |
|
for _, v := range dts { |
|
if total != 0 { |
|
v.Rate = (10000 * v.Amount) / total |
|
} |
|
v.Total = total |
|
} |
|
} |
|
|
|
// McnFansAnalyze . |
|
func (s *Service) McnFansAnalyze(c context.Context, arg *model.McnCommonReq) (res *model.McnGetMcnFansReply, err error) { |
|
var ( |
|
f *dtmdl.DmConMcnFansD |
|
sex *dtmdl.DmConMcnFansSexW |
|
age *dtmdl.DmConMcnFansAgeW |
|
playWay *dtmdl.DmConMcnFansPlayWayW |
|
areas []*dtmdl.DmConMcnFansAreaW |
|
types []*dtmdl.DmConMcnFansTypeW |
|
tags []*dtmdl.DmConMcnFansTagW |
|
g errgroup.Group |
|
) |
|
res = new(model.McnGetMcnFansReply) |
|
g.Go(func() (err error) { |
|
if f, err = s.dao.DataFans(c, arg); err != nil { |
|
log.Error("s.dao.DataFans(%+v) error(%v)", arg, err) |
|
return |
|
} |
|
res.FansOverview = f |
|
return |
|
}) |
|
g.Go(func() (err error) { |
|
if sex, age, playWay, err = s.dao.DataFansBaseAttr(c, arg); err != nil { |
|
log.Error("s.dao.DataFansBaseAttr(%+v) error(%v)", arg, err) |
|
return |
|
} |
|
res.FansSex = sex |
|
res.FansAge = age |
|
res.FansPlayWay = playWay |
|
return |
|
}) |
|
g.Go(func() (err error) { |
|
if areas, err = s.dao.DataFansArea(c, arg); err != nil { |
|
log.Error("s.dao.DataFansArea(%+v) error(%v)", arg, err) |
|
return |
|
} |
|
res.FansArea = areas |
|
return |
|
}) |
|
g.Go(func() (err error) { |
|
if types, err = s.dao.DataFansType(c, arg); err != nil { |
|
log.Error("s.dao.DataFansType(%+v) error(%v)", arg, err) |
|
return |
|
} |
|
res.FansType = types |
|
return |
|
}) |
|
g.Go(func() (err error) { |
|
if tags, err = s.dao.DataFansTag(c, arg); err != nil { |
|
log.Error("s.dao.DataFansTag(%+v) error(%v)", arg, err) |
|
return |
|
} |
|
res.FansTag = tags |
|
return |
|
}) |
|
if err = g.Wait(); err != nil { |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
}
|
|
|