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.
301 lines
8.1 KiB
301 lines
8.1 KiB
package service |
|
|
|
import ( |
|
"bytes" |
|
"context" |
|
"encoding/json" |
|
"encoding/xml" |
|
"fmt" |
|
htemplate "html/template" |
|
"strconv" |
|
"strings" |
|
"text/template" |
|
"time" |
|
|
|
dmrpc "go-common/app/interface/main/dm2/rpc/client" |
|
hisrpc "go-common/app/interface/main/history/rpc/client" |
|
"go-common/app/interface/main/player/conf" |
|
"go-common/app/interface/main/player/dao" |
|
"go-common/app/interface/main/player/model" |
|
tagrpc "go-common/app/interface/main/tag/rpc/client" |
|
accclient "go-common/app/service/main/account/api" |
|
arcclient "go-common/app/service/main/archive/api" |
|
arcrpc "go-common/app/service/main/archive/api/gorpc" |
|
assrpc "go-common/app/service/main/assist/rpc/client" |
|
locrpc "go-common/app/service/main/location/rpc/client" |
|
resmdl "go-common/app/service/main/resource/model" |
|
resrpc "go-common/app/service/main/resource/rpc/client" |
|
ugcclient "go-common/app/service/main/ugcpay/api/grpc/v1" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
const ( |
|
_resourceID = 2319 |
|
_bgColor = "#000000" |
|
) |
|
|
|
// Service is a service. |
|
type Service struct { |
|
// config |
|
c *conf.Config |
|
// dao |
|
dao *dao.Dao |
|
// rpc |
|
arc *arcrpc.Service2 |
|
his *hisrpc.Service |
|
ass *assrpc.Service |
|
res *resrpc.Service |
|
dm2 *dmrpc.Service |
|
loc *locrpc.Service |
|
tag *tagrpc.Service |
|
// memory cache |
|
caItems []*model.Item |
|
params string |
|
icon htemplate.HTML |
|
// template |
|
tWithU *template.Template |
|
tNoU *template.Template |
|
// broadcast |
|
BrBegin time.Time |
|
BrEnd time.Time |
|
// 拜年祭相关 |
|
matOn bool |
|
matTime time.Time |
|
pastView *model.View |
|
matView *model.View |
|
// vipQn |
|
vipQn map[int]int |
|
// grpc client |
|
accClient accclient.AccountClient |
|
arcClient arcclient.ArchiveClient |
|
ugcPayClient ugcclient.UGCPayClient |
|
// playurl paths |
|
playURL string |
|
playURLV3 string |
|
h5PlayURL string |
|
highQaURL string |
|
// bnj2019 view map |
|
bnj2019ViewMap map[int64]*arcclient.ViewReply |
|
} |
|
|
|
// New new and return service. |
|
func New(c *conf.Config) (s *Service) { |
|
s = &Service{ |
|
c: c, |
|
dao: dao.New(c), |
|
arc: arcrpc.New2(c.ArchiveRPC), |
|
his: hisrpc.New(c.HistoryRPC), |
|
ass: assrpc.New(c.AssistRPC), |
|
res: resrpc.New(c.ResourceRPC), |
|
dm2: dmrpc.New(c.Dm2RPC), |
|
loc: locrpc.New(c.LocRPC), |
|
tag: tagrpc.New2(c.TagRPC), |
|
} |
|
s.playURL = c.Host.PlayurlCo + _playurlURI |
|
s.playURLV3 = c.Host.PlayurlCo + _playurlURIV3 |
|
s.h5PlayURL = c.Host.H5Playurl + _h5PlayURI |
|
s.highQaURL = c.Host.HighPlayurl + _highQaURI |
|
var err error |
|
if s.accClient, err = accclient.NewClient(c.AccClient); err != nil { |
|
panic(err) |
|
} |
|
if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil { |
|
panic(err) |
|
} |
|
if s.ugcPayClient, err = ugcclient.NewClient(c.UGCPayClient); err != nil { |
|
panic(err) |
|
} |
|
s.initVipQn() |
|
s.caItems = []*model.Item{} |
|
// 模板 |
|
s.tWithU, _ = template.New("with_user").Parse(model.TpWithUinfo) |
|
s.tNoU, _ = template.New("no_user").Parse(model.TpWithNoUinfo) |
|
// broadcast |
|
s.BrBegin, _ = time.Parse("2006-01-02 15:04:05", c.Broadcast.Begin) |
|
s.BrEnd, _ = time.Parse("2006-01-02 15:04:05", c.Broadcast.End) |
|
// 初始化播放器灰度配置项目 |
|
go s.policyproc() |
|
go s.resourceproc() |
|
go s.paramproc() |
|
go s.iconproc() |
|
// 拜年祭 |
|
s.matTime, _ = time.Parse(time.RFC3339, c.Matsuri.MatTime) |
|
s.matOn = true |
|
go s.matProc() |
|
go s.bnj2019Viewproc() |
|
return |
|
} |
|
|
|
// Ping check service health |
|
func (s *Service) Ping(c context.Context) (err error) { |
|
if err = s.dao.Ping(c); err != nil { |
|
log.Error("s.dao.Ping() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) matProc() { |
|
var ( |
|
ctx = context.Background() |
|
err error |
|
) |
|
for { |
|
var tmp *arcclient.ViewReply |
|
if tmp, err = s.arcClient.View(ctx, &arcclient.ViewRequest{Aid: s.c.Matsuri.PastID}); err != nil || tmp == nil { |
|
dao.PromError("View接口错误", "s.arcClientView3(%v) tmp(%v) error(%v) ", s.c.Matsuri.PastID, tmp, err) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
s.pastView = &model.View{Arc: tmp.Arc, Pages: tmp.Pages} |
|
if tmp, err = s.arcClient.View(ctx, &arcclient.ViewRequest{Aid: s.c.Matsuri.MatID}); err != nil || tmp == nil { |
|
dao.PromError("View接口错误", "s.arcClientView3(%v) tmp(%v) error(%v)", s.c.Matsuri.MatID, tmp, err) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
s.matView = &model.View{Arc: tmp.Arc, Pages: tmp.Pages} |
|
time.Sleep(time.Duration(s.c.Matsuri.Tick)) |
|
} |
|
} |
|
|
|
func (s *Service) resourceproc() { |
|
for { |
|
var ( |
|
items []*model.Item |
|
err error |
|
res *resmdl.Resource |
|
) |
|
if res, err = s.res.Resource(context.Background(), &resmdl.ArgRes{ResID: _resourceID}); err != nil { |
|
dao.PromError("Resource接口错误", "s.res.Resource(%d) error(%v)", _resourceID, err) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
if res == nil { |
|
dao.PromError("Resource接口数据为空", "s.res.Resource(%d) is nil", _resourceID) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
if len(res.Assignments) == 0 { |
|
dao.PromError("Resource接口Assignments数据为空", "s.res.Resource(%d) assignments is nil", _resourceID) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
for _, v := range res.Assignments { |
|
item := &model.Item{ |
|
Bgcolor: _bgColor, |
|
ResourceID: strconv.Itoa(_resourceID), |
|
SrcID: strconv.Itoa(v.ResID), |
|
ID: strconv.Itoa(v.ID), |
|
} |
|
if catalog, ok := model.Catalog[v.PlayerCategory]; ok { |
|
item.Catalog = catalog |
|
} |
|
item.Content = string(rune(10)) + string(rune(13)) + fmt.Sprintf(_content, v.URL, v.Name) + string(rune(10)) + string(rune(13)) |
|
items = append(items, item) |
|
} |
|
s.caItems = items |
|
time.Sleep(time.Duration(s.c.Tick.CarouselTick)) |
|
} |
|
} |
|
|
|
func (s *Service) paramproc() { |
|
for { |
|
var ( |
|
params []*model.Param |
|
items []string |
|
err error |
|
) |
|
c := context.Background() |
|
if params, err = s.dao.Param(c); err != nil { |
|
log.Error("s.dao.Param() error(%v)", err) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
if len(params) == 0 { |
|
time.Sleep(time.Duration(s.c.Tick.ParamTick)) |
|
continue |
|
} |
|
for _, pa := range params { |
|
nameBy := bytes.NewBuffer(nil) |
|
valueBy := bytes.NewBuffer(nil) |
|
if err = xml.EscapeText(nameBy, []byte(pa.Name)); err != nil { |
|
log.Error("xml.EscapeText(%s) error(%v)", pa.Name, err) |
|
continue |
|
} else { |
|
pa.Name = nameBy.String() |
|
} |
|
if err = xml.EscapeText(valueBy, []byte(pa.Value)); err != nil { |
|
log.Error("xml.EscapeText(%s) error(%v)", pa.Value, err) |
|
continue |
|
} else { |
|
pa.Value = valueBy.String() |
|
} |
|
item := "<" + pa.Name + ">" + pa.Value + "</" + pa.Name + ">" |
|
items = append(items, item) |
|
} |
|
if len(items) > 0 { |
|
s.params = strings.Join(items, "\n") |
|
} |
|
time.Sleep(time.Duration(s.c.Tick.ParamTick)) |
|
} |
|
} |
|
|
|
func (s *Service) policyproc() { |
|
s.c.Policy.StartTime, _ = time.Parse("2006-01-02 15:04:05", s.c.Policy.Start) |
|
s.c.Policy.EndTime, _ = time.Parse("2006-01-02 15:04:05", s.c.Policy.End) |
|
s.c.Policy.MtimeTime, _ = time.Parse("2006-01-02 15:04:05", s.c.Policy.Mtime) |
|
} |
|
|
|
func (s *Service) iconproc() { |
|
for { |
|
icon, err := s.res.PlayerIcon(context.Background()) |
|
if err != nil || icon == nil { |
|
log.Error("iconproc s.res.PlayerIcon error(%v) icon(%v)", err, icon) |
|
if ecode.Cause(err) == ecode.NothingFound { |
|
s.icon = "" |
|
} |
|
time.Sleep(time.Duration(s.c.Tick.IconTick)) |
|
continue |
|
} |
|
icon.URL1 = strings.Replace(icon.URL1, "http://", "//", 1) |
|
icon.URL2 = strings.Replace(icon.URL2, "http://", "//", 1) |
|
bs, err := json.Marshal(icon) |
|
if err != nil { |
|
log.Error("iconproc json.Marshal(%v) error(%v)", icon, err) |
|
time.Sleep(time.Second) |
|
continue |
|
} |
|
s.icon = htemplate.HTML(bs) |
|
time.Sleep(time.Duration(s.c.Tick.IconTick)) |
|
} |
|
} |
|
|
|
func (s *Service) initVipQn() { |
|
tmp := make(map[int]int, len(s.c.Rule.VipQn)) |
|
for _, qn := range s.c.Rule.VipQn { |
|
tmp[qn] = qn |
|
} |
|
s.vipQn = tmp |
|
} |
|
|
|
func (s *Service) bnj2019Viewproc() { |
|
for { |
|
time.Sleep(time.Duration(s.c.Bnj2019.BnjTick)) |
|
aids := append(s.c.Bnj2019.BnjListAids, s.c.Bnj2019.BnjMainAid) |
|
if len(aids) == 0 { |
|
continue |
|
} |
|
if views, err := s.arcClient.Views(context.Background(), &arcclient.ViewsRequest{Aids: aids}); err != nil || views == nil { |
|
log.Error("bnj2019Viewproc s.arcClient.Views(%v) error(%v)", aids, err) |
|
continue |
|
} else { |
|
tmp := make(map[int64]*arcclient.ViewReply, len(aids)) |
|
for _, aid := range aids { |
|
if view, ok := views.Views[aid]; ok && view.Arc.IsNormal() { |
|
tmp[aid] = view |
|
} |
|
} |
|
s.bnj2019ViewMap = tmp |
|
} |
|
} |
|
}
|
|
|