openbilibili/go-common
1
0
Fork 0
Code Releases Activity

Create & Init Project...

Browse Source
This commit is contained in:
MiaoWoo
2019-04-22 18:49:16 +08:00
commit fc4fa37393
25440 changed files with 4054998 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
app/interface/main/app-view/BUILD Normal file
View File

@@ -0,0 +1,48 @@
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [
":package-srcs",
"//app/interface/main/app-view/cmd:all-srcs",
"//app/interface/main/app-view/conf:all-srcs",
"//app/interface/main/app-view/dao/account:all-srcs",
"//app/interface/main/app-view/dao/act:all-srcs",
"//app/interface/main/app-view/dao/ad:all-srcs",
"//app/interface/main/app-view/dao/ai:all-srcs",
"//app/interface/main/app-view/dao/archive:all-srcs",
"//app/interface/main/app-view/dao/assist:all-srcs",
"//app/interface/main/app-view/dao/audio:all-srcs",
"//app/interface/main/app-view/dao/bangumi:all-srcs",
"//app/interface/main/app-view/dao/coin:all-srcs",
"//app/interface/main/app-view/dao/creative:all-srcs",
"//app/interface/main/app-view/dao/dm:all-srcs",
"//app/interface/main/app-view/dao/elec:all-srcs",
"//app/interface/main/app-view/dao/favorite:all-srcs",
"//app/interface/main/app-view/dao/game:all-srcs",
"//app/interface/main/app-view/dao/live:all-srcs",
"//app/interface/main/app-view/dao/location:all-srcs",
"//app/interface/main/app-view/dao/manager:all-srcs",
"//app/interface/main/app-view/dao/region:all-srcs",
"//app/interface/main/app-view/dao/relation:all-srcs",
"//app/interface/main/app-view/dao/report:all-srcs",
"//app/interface/main/app-view/dao/resource:all-srcs",
"//app/interface/main/app-view/dao/search:all-srcs",
"//app/interface/main/app-view/dao/special:all-srcs",
"//app/interface/main/app-view/dao/tag:all-srcs",
"//app/interface/main/app-view/dao/thumbup:all-srcs",
"//app/interface/main/app-view/dao/ugcpay:all-srcs",
"//app/interface/main/app-view/dao/vip:all-srcs",
"//app/interface/main/app-view/http:all-srcs",
"//app/interface/main/app-view/model:all-srcs",
"//app/interface/main/app-view/service/report:all-srcs",
"//app/interface/main/app-view/service/view:all-srcs",
],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

783
app/interface/main/app-view/CHANGELOG.md Normal file
View File

@@ -0,0 +1,783 @@
#### App view 移动端稿件详情相关
#### Version 2.6.20
> 1.haslike错误日志
#### Version 2.6.19
> 1.三连errgroup改v2 & 点赞接口迁grpc
#### Version 2.6.18
> 1.优化点赞三连
#### Version 2.6.17
> 1.点赞过滤已点赞错误码
#### Version 2.6.16
> 1.视频详情页增加staff逻辑
#### Version 2.6.15
> 1.相关推荐is_dalao & bangumi rating
#### Version 2.6.13
> 1.新加plat iphone_b，修改相应的版本限制
> 2.相关推荐上报id过滤字符串
#### Version 2.6.12
> 1.region表换成新表
#### Version 2.6.11
> 1.相关推荐修改上报id
#### Version 2.6.10
> 1.审核后台特殊用户组生产环境详情页接口不可见稿件
#### Version 2.6.9
> 1.拜年祭接口只返回过审的稿件
#### Version 2.6.8
> 1.不感兴趣上报buvid和mid二选一
#### Version 2.6.7
> 1.fix context
#### Version 2.6.6
> 1.高能看点和bgm
#### Version 2.6.5
> 1.广告不感兴趣上报
#### Version 2.6.4
> 1.关闭分享双写
#### Version 2.6.3
> 1.广告不感兴趣上报增加cm_reason_id
#### Version 2.6.2
> 1.拜年祭视频打开充电
#### Version 2.6.1
> 1.拜年祭接口
#### Version 2.6.0
> 1.投币接口proxy
#### Version 2.5.9
> 1.分享增加ip
#### Version 2.5.8
> 1.bnj增加tid
#### Version 2.5.7
> 1.增加嘉定proxy转发
#### Version 2.5.6
> 1.去除view接口中的upCount调用
#### Version 2.5.5
> 1.拜年祭视频可下载
#### Version 2.5.4
> 1.去掉zlimit，接入location
#### Version 2.5.3
> 1.隐藏详情页接口中的UP主投稿数字段,本周末内无问题则删除调用
#### Version 2.5.2
> 1.安卓国际版 pgc详情页
#### Version 2.5.1
> 1.接入直播的拜年祭配置
#### Version 2.5.0
> 1.拜年祭接口上线
#### Version 2.4.40
> 1.AI相关推荐ERROR特殊处理
#### Version 2.4.39
> 1.野版tv pgc详情页
> 2.搜索推荐up主卡片增加ipad
#### Version 2.4.38
> 1.修复相关推荐代码
#### Version 2.4.37
> 1.fix panic
#### Version 2.4.36
> 1.活动标签+活动tag入口+view上报增加spmid&from_spmid
#### Version 2.4.35
> 1.支持相关推荐按百分比灰度
#### Version 2.4.34
> 1.分享双写
#### Version 2.4.33
> 1.相关推荐展示日志trackid上报修改
#### Version 2.4.32
> 1.点赞动效文案修改
#### Version 2.4.31
> 1.付费稿件up主修复
#### Version 2.4.30
> 1.view接口增加fnver、fnval
#### Version 2.4.29
> 1.搜索UP主卡片返回21个
#### Version 2.4.28
> 1.相关推荐家长模式
> 2.投币且点赞的点赞上报act变更为acttolike
#### Version 2.4.27
> 1.watch config
> 1.版本限制 533以及没qn的走480p
#### Version 2.4.26
> 1.详情页点踩上报up主mid
> 2.MonitorInfo请求修改
#### Version 2.4.24
> 1.详情页点赞上报up主mid
#### Version 2.4.23
> 1.相关推荐上报加source_page,修改user_feature
#### Version 2.4.22
> 1.相关推荐秒开
#### Version 2.4.21
> 1.关注完成后的推荐关注
#### Version 2.4.20
> 1.三连进默认收藏前先判断收藏状态
#### Version 2.4.19
> 1.完善三连推荐引导条件
#### Version 2.4.18
> 1.点赞动效+点赞三连+投币同时点赞
#### Version 2.4.17
> 1.相关推荐增加pgc卡片
#### Version 2.4.16
> 1.推荐列表增加trackid
#### Version 2.4.15
> 1.fix follow panic
#### Version 2.4.14
> 1.音频换回老接口
#### Version 2.4.13
> 1.音频换新接口
#### Version 2.4.12
> 1.http请求修改
#### Version 2.4.11
> 1.音频换新接口
#### Version 2.4.10
> 1.音频换回老接口
#### Version 2.4.9
> 1.pgc迁移新接口（bangumi.bilibili.co/api/inner/pgc ---> api.bilibili.co/pgc/internal/season/appview）
#### Version 2.4.8
> 1.是否是弹幕广告字段
> 2.商单监控上报
#### Version 2.4.7
1.播放器关注引导粉丝数限制改为从配置读取
#### Version 2.4.6
1.增加播放器关注引导接口
#### Version 2.4.5
> 1.相关推荐游戏修复上报来源
#### Version 2.4.4
> 1.详情页直播间返回uri
#### Version 2.4.3
> 1.相关推荐过滤mid和buvid都为空的请求&删除灰aid的判断
#### Version 2.4.2
> 1.详情页广告和相关推荐并发处理
#### Version 2.4.1
> 1.上报av_feature格式改为json
#### Version 2.4.0
> 1.删除详情页中的elec调用
#### Version 2.3.3
> 1.视频广告去除ipad
#### Version 2.3.2
> 1.是否是弹幕广告字段
#### Version 2.3.1
> 1.给新tv增加访问innerPGC权限
#### Version 2.3.0
> 1.升级grpc identify
#### Version 2.2.15
> 1.蒙版弹幕透传
#### Version 2.2.14
> 1.加infoc日志
#### Version 2.2.13
> 1.更改errorlog日志
#### Version 2.2.12
> 1.相关推荐接口日志上报中增加goto、from信息
> 2.相关推荐走ai新接口，上报新增source av_feature build return_code user_feature
#### Version 2.2.11
> 1.ipadhd pgc build limit
#### Version 2.2.10
> 1.商单游戏
> 2.视频详情页请求商业产品数据字段增加
> 3.视频详情页相同推荐视频过滤
#### Version 2.2.9
> 1.fix avHandler
#### Version 2.2.8
> 1.异步获取直播状态超时调整
#### Version 2.2.4
> 1.异步获取直播状态调整超时时间
#### Version 2.2.3
> 1.修复广告位判断
#### Version 2.2.2
> 1.详情页接口增加自动播放的上报
#### Version 2.2.1
> 1.详情页广告接口聚合调用
#### Version 2.2.0
> 1.详情页分批长宽比
> 2.详情页相关推荐长宽比
> 3.FillURI重构
#### Version 2.1.3
> 1.干掉踩的总数
#### Version 2.1.2
> 1.详情页增加用户是否已经投币
> 2.稿件不存在返回10008
#### Version 2.1.1
> 1./vip/playurl增加aid和cid判断
> 2.部分接口indentify从user改为userMobile
#### Version 2.1.0
> 1.update infoc sdk
#### Version 2.0.9
> 1.分享稿件不存在返回10008
#### Version 2.0.8
> 1.ipad高版本电影走pgc
#### Version 2.0.7
> 1.播放器新增清晰度66流量浮层
#### Version 2.0.6
> 1.视频详情页点踩
#### Version 2.0.5
> 1.商单私单接口替换
#### Version 2.0.4
> 1.播放页UP主互选广告
#### Version 2.0.3
> 1.修改addCoin rpc
#### Version 2.0.2
> 1.点赞、取消点赞上报
#### Version 2.0.1
> 1.分享的时候增加未登录用户的上报以及up主id
#### Version 2.0.0
> 1.app-view http bm
#### Version 1.9.6
> 1.上报投币行为
#### Version 1.9.5
> 1.视频详情页曝光上报
> 2.私单接口切location
#### Version 1.9.4
> 1.fix view live
#### Version 1.9.3
> 1.history服务迁移目录，修改对该服务的包引用路径
> 2.使用account-service v7
> 3.删除拜年祭无用代码
> 4.上报分享行为
#### Version 1.9.2
> 1.视频详情页相关推荐广告卡片位置下放
> 2.card_index上报
#### Version 1.9.1
> 1.投币成功后上报给infoc
#### Version 1.9.0
> 1.相关推荐AI游戏卡片实验
#### Version 1.8.9
> 1.安卓概念版处理
#### Version 1.8.8
> 1.弹幕开关
#### Version 1.8.7
> 1.修复详情页电影切inner_PGC接口ipad版本
#### Version 1.8.6
> 1.详情页电影切inner_PGC接口
#### Version 1.8.5
> 1.profile to info
> 2.fix player icon
##### Version 1.8.4
> 1.view接口的playicon增加hash字段
##### Version 1.8.3
> 1.抽奖接口直接使用mid
##### Version 1.8.2
> 1.取消灰度mid
> 2.拜年祭去除协管，用户信息从内存获取
> 3.随机时间戳走配置
> 4.调整beginTime顺序到第一个，方便接口查看
##### Version 1.8.1
> 1.增加灰度mid判断
##### Version 1.8.0
> 1.相关推荐开启广告
> 2.新清晰度流量消耗
##### Version 1.7.10
> 1.优化相关推荐广告逻辑
> 2.分享增加稿件校验
##### Version 1.7.9
> 1.开启私单
> 2.add 增加稿件校验
> 3.1.去掉电影推荐
##### Version 1.7.8
> 1.点赞透传err
##### Version 1.7.7
> 1.调整拜年祭获奖名单
##### Version 1.7.6
> 1.拜年祭没开始时，增加默认中奖文案
##### Version 1.7.5
> 1.视频详情页相关推荐游戏拼接title
##### Version 1.7.4
> 1.客户端bug，服务端兼容
> 2.view iplimit
##### Version 1.7.3
> 1.视频详情页展示用户最近5个投稿
##### Version 1.7.2
> 1.ops rider
##### Version 1.7.1
> 1.视频不喜欢上报
> 2.fix view contributions
> 3.去掉充电无用字段
##### Version 1.7.0
> 1.拜年祭相关接口上线
##### Version 1.6.1
> 1.视频详情页相关视频运营位
##### Version 1.6.0
> 1.稿件详情页增加大会员活动信息
> 2.增加移动端获取token的接口，用于大会员清晰度校验
##### Version 1.5.5
> 1.相关视频缓存修复
##### Version 1.5.4
> 1.视频详情页ip过滤
##### Version 1.5.3
> 1.视频详情页点赞状态
##### Version 1.5.2
> 1.构建镜像
##### Version 1.5.1
> 1.视频详情页相关视频增加goto param uri字段
> 2.like 双写databus
##### Version 1.5.0
> 1.视频详情页点赞切新接口
##### Version 1.4.9
> 1.直播接口切换
##### Version 1.4.8
> 1.去掉旧逻辑代码
##### Version 1.4.7
> 1.player icon
> 2.去掉番剧承包
##### Version 1.4.6
> 1. from bangumi
##### Version 1.4.5
> 1. mid为0不调用card
##### Version 1.4.4
> 1. 视频详情页接movie_aid_info
##### Version 1.4.3
> 1. 视频详情页接inner/pgc
> 2. 点赞双写
##### Version 1.4.2
> 1.删除多余的 ecode.NoLogin
##### Version 1.4.1
> 1.修复专栏投币
##### Version 1.4.0
> 1.投币、收藏提示用户关注
> 2.视频详情页切换稿件pb接口
> 3.换router,去掉idnetify.Access
##### Version 1.3.12
> 1.增加广告透传字段
##### Version 1.3.11
> 1.删除所有http缓存管理接口代码
##### Version 1.3.10
> 1.确认了mc的slab问题，删除多余的缓存代码
##### Version 1.3.9
> 1.arcPBCache永不过期
##### Version 1.3.8
> 1.优化，投稿数>=20的时候才请求稿件详情
##### Version 1.3.7
> 1.修改cache/up接口逻辑，增量更新缓存的同时删除老缓存
##### Version 1.3.6
> 1.修复缓存不存在时，view报-404的问题
##### Version 1.3.5
> 1.去除业务自定义缓存，保留最原始的view缓存
##### Version 1.3.4
> 1.增加调试日志
##### Version 1.3.3
> 1.view缓存更新逻辑
##### Version 1.3.2
> 1.PB 初始化
##### Version 1.3.1
> 1.view接口全量pb
##### Version 1.3.0
> 1.开始双写archive pb缓存
##### Version 1.2.5
> 1.cache stat 接口增加Stat3缓存更新逻辑
##### Version 1.2.4
> 1.remove local cache
##### Version 1.2.3
1.dmRegion全量
##### Version 1.2.2
1.视频详情页增加投稿banner
##### Version 1.2.1
1.影视区二级分区开启充电
##### Version 1.2.0
1.未登录用户获取登录引导贴片
##### Version 1.1.0
> 1.视频详情页长简介长度限制
##### Version 1.0.13
> 1.视频详情页长简介
##### Version 1.0.12
> 1.音频版本过滤
##### Version 1.0.11
> 1.视频详情页音频
> 2.视频详情页增加up主投稿数
> 3.切新的movidID2Aid接口
> 4.族群弹幕
##### Version 1.0.10
> 1.腾讯视频外链禁止下载
##### Version 1.0.9
> 1.切换到view3接口
##### Version 1.0.8
> 1.修复投币
##### Version 1.0.7
> 1.修复用户昵称头像
##### Version 1.0.6
> 1.视频详情页接入音频
##### Version 1.0.5
> 1.修复稿件投诉接口
##### Version 1.0.4
> 1.自制稿件开放充电
##### Version 1.0.3
> 1.视频详情页缓存切新
##### Version 1.0.2
> 1.视频详情页充电
##### Version 1.0.1
> 1.修复app-view panic
##### Version 1.0.0
> 1.初始化项目

11
app/interface/main/app-view/CONTRIBUTORS.md Normal file
View File

@@ -0,0 +1,11 @@
# Owner
peiyifei
liweijia
# Author
xiequan
yujia
# Reviewer
peiyifei
haoguanwei

18
app/interface/main/app-view/OWNERS Normal file
View File

@@ -0,0 +1,18 @@
# See the OWNERS docs at https://go.k8s.io/owners
approvers:
- liweijia
- peiyifei
- xiequan
- yujia
labels:
- interface
- interface/main/app-view
- main
options:
no_parent_owners: true
reviewers:
- haoguanwei
- peiyifei
- xiequan
- yujia

13
app/interface/main/app-view/README.md Normal file
View File

@@ -0,0 +1,13 @@
#### app-view
##### 项目简介
> 1.提供移动端稿件详情相关接口
##### 编译环境
> 请只用golang v1.8.x以上版本编译执行。
##### 依赖包
> 1.公共包go-common
##### 特别说明
> 1.model目录可能会被其他项目引用，请谨慎请改并通知各方。

42
app/interface/main/app-view/cmd/BUILD Normal file
View File

@@ -0,0 +1,42 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_binary",
"go_library",
)
go_binary(
name = "cmd",
embed = [":go_default_library"],
tags = ["automanaged"],
)
go_library(
name = "go_default_library",
srcs = ["main.go"],
data = ["app-view-test.toml"],
importpath = "go-common/app/interface/main/app-view/cmd",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/http:go_default_library",
"//library/ecode/tip:go_default_library",
"//library/log:go_default_library",
"//library/net/trace:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

291
app/interface/main/app-view/cmd/app-view-test.toml Normal file
View File

@@ -0,0 +1,291 @@
# This is a TOML document. Boom.
version = "1.0.0"
user = "nobody"
pid = "/tmp/app-view.pid"
dir = "./"
checkFile = "/data/www/app-view.html"
family = "app-view"
address = ""
trace = false
debug = false
env = "test"
tick = "1m"
roundTick = "30m"
vipTick = "2s"
autoLimit = 100000
relateCnt = 3
[bnj2019]
tick = "10s"
mainAid = 10111165
adAv = 10111164
aidList = [10111164,10111163,10111162,10111161,10111160,10111159,10111158,10111157,10111156,10111155,10111154,10111153,10111152,10111151,10111150,10111149,10111148,10111147,10111146,10111145,10111144,10111143,10111142,10111141]
elecBigText = "给参与拜年祭的UP主"
elecSmallText = "本次充电所有的收入，将会在扣除成本之后，按照一定规则，"
[playURL]
secret = "62Mt3F1kpbvp3LKC"
dmRegion = [36]
[xlog]
dir = "/data/log/app-view/"
[infocCoin]
taskID = "000078"
proto = "tcp"
addr = "172.19.100.20:5401"
chanSize = 1024
[infocView]
taskID = "000025"
project = "app-view"
name = "view"
path = "/data/infoc/app-view/info.log"
[infocRelate]
project = "app-view"
name = "relate"
path = "/data/infoc/app-view/relate.log"
[useractPub]
key = "0PtMsLLxWyyvoTgAyLCD"
secret = "0PtMsLLxWyyvoTgAyLCE"
group = "RecUseract-App-P"
topic = "RecUseract-T"
action = "pub"
name = "app-view/useract"
proto = "tcp"
addr = "172.16.33.158:6205"
active = 1
idle = 1
dialTimeout = "1s"
readTimeout = "1s"
writeTimeout = "1s"
idleTimeout = "10s"
[dislikePub]
key = "0PtMsVFzWyyvoTgAyLCG"
secret= "0PtMsVFzWyyvoTgAyLCH"
group= "TagDislike-SkyHorse-P"
topic= "Dislike-T"
action="pub"
name = "app-feed/dislike"
proto = "tcp"
addr = "172.16.33.158:6205"
active = 100
idle = 50
dialTimeout = "50ms"
readTimeout = "200ms"
writeTimeout = "200ms"
idleTimeout = "80s"
[tracer]
proto = "udp"
addr = "172.16.33.46:5140"
tag = "platform/app-view"
[app]
key = "e7482d29be4a95b8"
secret = "9e803791cdef756e75faee68e12b7442"
[httpClient]
key = "7c7ac0db1aa05587"
secret = "9a6d62d93290c5f771ad381e9ca23f26"
dial = "30ms"
timeout = "800ms"
keepAlive = "60s"
timer = 1024
[httpClient.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpAsync]
key = "7c7ac0db1aa05587"
secret = "9a6d62d93290c5f771ad381e9ca23f26"
dial = "30ms"
timeout = "2s"
keepAlive = "60s"
timer = 1024
[httpAsync.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpWrite]
key = "7c7ac0db1aa05587"
secret = "9a6d62d93290c5f771ad381e9ca23f26"
dial = "30ms"
timeout = "700ms"
keepAlive = "60s"
timer = 1024
[httpWrite.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpBangumi]
key = "7c7ac0db1aa05587"
secret = "9a6d62d93290c5f771ad381e9ca23f26"
dial = "30ms"
timeout = "300ms"
keepAlive = "60s"
timer = 1024
[httpBangumi.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpAD]
key = "7c7ac0db1aa05587"
secret = "9a6d62d93290c5f771ad381e9ca23f26"
dial = "30ms"
timeout = "300ms"
keepAlive = "60s"
timer = 1024
[httpAD.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpAudio]
key = "7c7ac0db1aa05587"
secret = "9a6d62d93290c5f771ad381e9ca23f26"
dial = "30ms"
timeout = "300ms"
keepAlive = "60s"
timer = 1024
[httpAudio.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpGame]
key = "EeOpM531WqQnBvu4"
secret = "gHtKtXTHZJDqGP1tg9ORFs0YWV3kW12V"
dial = "30ms"
timeout = "300ms"
keepAlive = "60s"
timer = 1024
[httpGame.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpGameAsync]
key = "EeOpM531WqQnBvu4"
secret = "gHtKtXTHZJDqGP1tg9ORFs0YWV3kW12V"
dial = "1s"
timeout = "2s"
keepAlive = "60s"
timer = 1024
[httpGameAsync.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[httpSearch]
key = "e7482d29be4a95b8"
secret = "9e803791cdef756e75faee68e12b7442"
dial = "50ms"
timeout = "150ms"
keepAlive = "60s"
timer = 128
[httpSearch.breaker]
window = "10s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[bm]
[bm.outer]
addr = "0.0.0.0:6961"
timeout = "1s"
[buildLimit]
CooperationIOS = 8290
CooperationAndroid = 5365000
[host]
account = "http://account.bilibili.co"
bangumi = "http://bangumi.bilibili.co"
apiCo = "http://api.bilibili.co"
elec = "http://elec.bilibili.co"
apiLiveCo = "http://api.live.bilibili.co"
ad = "http://cm.bilibili.co"
data = "http://data.bilibili.co"
archive = "http://archive.api.bilibili.co"
game = "http://api.bilibili.co"
vip = "http://vip.bilibili.co"
activity = "http://matsuri.bilibili.co"
ai = "http://172.22.33.111:8101"
bvcvod = "http://bvc-vod.bilibili.co"
[mysql]
[mysql.show]
addr = "172.16.33.205:3306"
dsn = "test:test@tcp(172.16.33.205:3306)/bilibili_show?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
active = 5
idle = 2
queryTimeout = "100ms"
execTimeout = "100ms"
tranTimeout = "200ms"
[mysql.show.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[mysql.manager]
addr = "172.16.33.54:3306"
dsn = "test:test@tcp(172.16.33.54:3306)/bilibili_manager?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
active = 5
idle = 2
idleTimeout = "4h"
queryTimeout = "200ms"
execTimeout = "200ms"
tranTimeout = "200ms"
[mysql.manager.breaker]
window = "3s"
sleep = "100ms"
bucket = 10
ratio = 0.5
request = 100
[memcache]
[memcache.archive]
name = "app-view/archive"
proto = "tcp"
addr = "172.16.33.54:11213"
active = 50
idle = 10
dialTimeout = "50ms"
readTimeout = "50ms"
writeTimeout = "50ms"
idleTimeout = "80s"
archiveExpire = "20m"
viewExpire = "20m"
relateExpire = "20m"
addonExpire = "5m"
recommedExpire= "10m"

49
app/interface/main/app-view/cmd/main.go Normal file
View File

@@ -0,0 +1,49 @@
package main
import (
"flag"
"os"
"os/signal"
"syscall"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/http"
ecode "go-common/library/ecode/tip"
"go-common/library/log"
"go-common/library/net/trace"
)
func main() {
flag.Parse()
if err := conf.Init(); err != nil {
log.Error("conf.Init() error(%v)", err)
panic(err)
}
// init log
log.Init(conf.Conf.XLog)
defer log.Close()
log.Info("app-view start")
// init trace
trace.Init(conf.Conf.Tracer)
defer trace.Close()
// ecode init
ecode.Init(conf.Conf.Ecode)
// service init
http.Init(conf.Conf)
// init pprof conf.Conf.Perf
// init signal
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
for {
s := <-c
log.Info("app-view get a signal %s", s.String())
switch s {
case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGINT:
log.Info("app-view exit")
return
case syscall.SIGHUP:
default:
return
}
}
}

42
app/interface/main/app-view/conf/BUILD Normal file
View File

@@ -0,0 +1,42 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_library",
)
go_library(
name = "go_default_library",
srcs = ["conf.go"],
importpath = "go-common/app/interface/main/app-view/conf",
tags = ["automanaged"],
deps = [
"//library/cache/memcache:go_default_library",
"//library/conf:go_default_library",
"//library/database/sql:go_default_library",
"//library/ecode/tip:go_default_library",
"//library/log:go_default_library",
"//library/log/infoc:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/rpc:go_default_library",
"//library/net/rpc/warden:go_default_library",
"//library/net/trace:go_default_library",
"//library/queue/databus:go_default_library",
"//library/time:go_default_library",
"//vendor/github.com/BurntSushi/toml:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

215
app/interface/main/app-view/conf/conf.go Normal file
View File

@@ -0,0 +1,215 @@
package conf
import (
"errors"
"flag"
"go-common/library/cache/memcache"
"go-common/library/conf"
"go-common/library/database/sql"
ecode "go-common/library/ecode/tip"
"go-common/library/log"
"go-common/library/log/infoc"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/rpc"
"go-common/library/net/rpc/warden"
"go-common/library/net/trace"
"go-common/library/queue/databus"
xtime "go-common/library/time"
"github.com/BurntSushi/toml"
)
// Conf is
var (
confPath string
client *conf.Client
Conf = &Config{}
)
//Config struct
type Config struct {
// Env
Env string
AutoLimit int64
DMRegion []int16
// interface XLog
XLog *log.Config
Bnj2019 *Bnj2019
// infoc
InfocCoin *infoc.Config
InfocView *infoc.Config
InfocRelate *infoc.Config
UseractPub *databus.Config
DislikePub *databus.Config
// tick time
Tick xtime.Duration
// vip tick
VipTick xtime.Duration
// tracer
Tracer *trace.Config
// httpClinet
HTTPClient *bm.ClientConfig
// httpWrite
HTTPWrite *bm.ClientConfig
// httpbangumi
HTTPBangumi *bm.ClientConfig
// httpaudio
HTTPAudio *bm.ClientConfig
// http
BM *HTTPServers
// httpAd
HTTPAD *bm.ClientConfig
// httpGame
HTTPGame *bm.ClientConfig
// HTTPAsync
HTTPAsync *bm.ClientConfig
// HTTPGameAsync
HTTPGameAsync *bm.ClientConfig
// httpClinet
HTTPSearch *bm.ClientConfig
// host
Host *Host
// rpc client
AccountRPC *rpc.ClientConfig
ArchiveRPC *rpc.ClientConfig
TagRPC *rpc.ClientConfig
AssistRPC *rpc.ClientConfig
HisRPC *rpc.ClientConfig
ResourceRPC *rpc.ClientConfig
RelationRPC *rpc.ClientConfig
FavoriteRPC *rpc.ClientConfig
CoinRPC *rpc.ClientConfig
DMRPC *rpc.ClientConfig
ActivityRPC *rpc.ClientConfig
LocationRPC *rpc.ClientConfig
// db
MySQL *MySQL
// ecode
Ecode *ecode.Config
// mc
Memcache *Memcache
// PlayURL
PlayURL *PlayURL
// 相关推荐秒开个数
RelateCnt int
RelateGray int64
// buildLimit
BuildLimit *BuildLimit
// Warden Client
ThumbupClient *warden.ClientConfig
}
// Bnj2019 is
type Bnj2019 struct {
Tick xtime.Duration
MainAid int64
AdAv int64
AidList []int64
ElecBigText string
ElecSmallText string
WhiteMids []int64
FakeElec int
}
// HTTPServers Http Servers
type HTTPServers struct {
Outer *bm.ServerConfig
}
// Host struct
type Host struct {
Bangumi string
APICo string
Activity string
Elec string
AD string
Data string
Archive string
APILiveCo string
Game string
VIP string
AI string
Search string
Bvcvod string
}
// MySQL struct
type MySQL struct {
Show *sql.Config
Manager *sql.Config
}
// Memcache struct
type Memcache struct {
Archive *struct {
*memcache.Config
ArchiveExpire xtime.Duration
RelateExpire xtime.Duration
AddonExpire xtime.Duration
RecommedExpire xtime.Duration
}
}
// PlayURL playurl token's secret.
type PlayURL struct {
Secret string
}
// BuildLimt for build limit
type BuildLimit struct {
CooperationIOS int
CooperationAndroid int
}
func init() {
flag.StringVar(&confPath, "conf", "", "config path")
}
// Init init conf
func Init() error {
if confPath != "" {
return local()
}
return remote()
}
func local() (err error) {
_, err = toml.DecodeFile(confPath, &Conf)
return
}
func remote() (err error) {
if client, err = conf.New(); err != nil {
return
}
if err = load(); err != nil {
return
}
client.Watch("app-view.toml")
go func() {
for range client.Event() {
log.Info("config reload")
if load() != nil {
log.Error("config reload error (%v)", err)
}
}
}()
return
}
func load() (err error) {
var (
s string
ok bool
tmpConf *Config
)
if s, ok = client.Toml2(); !ok {
return errors.New("load config center error")
}
if _, err = toml.Decode(s, &tmpConf); err != nil {
return errors.New("could not decode config")
}
*Conf = *tmpConf
return
}

48
app/interface/main/app-view/dao/account/BUILD Normal file
View File

@@ -0,0 +1,48 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/account",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/account/model:go_default_library",
"//app/service/main/account/rpc/client:go_default_library",
"//library/log:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

80
app/interface/main/app-view/dao/account/dao.go Normal file
View File

@@ -0,0 +1,80 @@
package account
import (
"context"
"go-common/app/interface/main/app-view/conf"
account "go-common/app/service/main/account/model"
accrpc "go-common/app/service/main/account/rpc/client"
"go-common/library/log"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
// Dao is account dao.
type Dao struct {
// rpc
accRPC *accrpc.Service3
}
// New account dao.
func New(c *conf.Config) (d *Dao) {
d = &Dao{
accRPC: accrpc.New3(c.AccountRPC),
}
return
}
// Card3 get card info by mid
func (d *Dao) Card3(c context.Context, mid int64) (res *account.Card, err error) {
arg := &account.ArgMid{Mid: mid}
if res, err = d.accRPC.Card3(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
func (d *Dao) Cards3(c context.Context, mids []int64) (res map[int64]*account.Card, err error) {
arg := &account.ArgMids{Mids: mids}
if res, err = d.accRPC.Cards3(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
// Following3 following.
func (d *Dao) Following3(c context.Context, mid, owner int64) (follow bool, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &account.ArgRelation{Mid: mid, Owner: owner, RealIP: ip}
rl, err := d.accRPC.Relation3(c, arg)
if err != nil {
err = errors.Wrapf(err, "%v", arg)
return
}
if rl != nil {
follow = rl.Following
}
return
}
// IsAttention is attention
func (d *Dao) IsAttention(c context.Context, owners []int64, mid int64) (isAtten map[int64]int8) {
if len(owners) == 0 || mid == 0 {
return
}
ip := metadata.String(c, metadata.RemoteIP)
arg := &account.ArgRelations{Owners: owners, Mid: mid, RealIP: ip}
res, err := d.accRPC.Relations3(c, arg)
if err != nil {
log.Error("%+v", err)
return
}
isAtten = make(map[int64]int8, len(res))
for mid, rel := range res {
if rel.Following {
isAtten[mid] = 1
}
}
return
}

40
app/interface/main/app-view/dao/account/dao_test.go Normal file
View File

@@ -0,0 +1,40 @@
package account
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(5 * time.Second)
}
func Test_Card(t *testing.T) {
Convey("Card", t, func() {
acc, err := d.Card3(context.TODO(), 2)
So(err, ShouldBeNil)
Println(acc)
})
}
func Test_Following(t *testing.T) {
Convey("Following", t, func() {
_, err := d.Following3(context.TODO(), 2, 1684013)
So(err, ShouldBeNil)
})
}

48
app/interface/main/app-view/dao/act/BUILD Normal file
View File

@@ -0,0 +1,48 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/act",
tags = ["automanaged"],
deps = [
"//app/interface/main/activity/model/like:go_default_library",
"//app/interface/main/activity/rpc/client:go_default_library",
"//app/interface/main/app-view/conf:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

111
app/interface/main/app-view/dao/act/dao.go Normal file
View File

@@ -0,0 +1,111 @@
package act
import (
"context"
"net/url"
"strconv"
actmdl "go-common/app/interface/main/activity/model/like"
actrpc "go-common/app/interface/main/activity/rpc/client"
"go-common/app/interface/main/app-view/conf"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"github.com/pkg/errors"
)
const (
_actInfo = "/matsuri/api/get/videoviewinfo"
_lotteryTimes = "/matsuri/api/get/act/mylotterytimes"
)
// Dao is elec dao.
type Dao struct {
client *httpx.Client
actInfo string
lotteryTimes string
actRPC *actrpc.Service
}
// New elec dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPClient),
actInfo: c.Host.Activity + _actInfo,
lotteryTimes: c.Host.Activity + _lotteryTimes,
actRPC: actrpc.New(c.ActivityRPC),
}
return
}
var _emptyList = []string{}
// Info mid+aid total elec info
func (d *Dao) Info(c context.Context, actID int64, randomCnt int64) (gifts, winners []string, err error) {
var res struct {
Code int `json:"code"`
Data struct {
Gifts []struct {
Img string `json:"sponsors_logo"`
} `json:"gifts"`
Winner []struct {
Gift string `json:"gift"`
UName string `json:"uname"`
} `json:"winner"`
} `json:"data"`
}
params := url.Values{}
params.Set("act_id", strconv.FormatInt(actID, 10))
params.Set("random_count", strconv.FormatInt(randomCnt, 10))
if err = d.client.Get(c, d.actInfo, "", params, &res); err != nil {
err = errors.Wrapf(err, "d.client.Get(%s)", d.actInfo+"?"+params.Encode())
return _emptyList, _emptyList, err
}
if res.Code != ecode.OK.Code() {
err = errors.Wrapf(ecode.Int(res.Code), "d.client.Get(%s)", d.actInfo+"?"+params.Encode())
return _emptyList, _emptyList, err
}
for _, v := range res.Data.Gifts {
gifts = append(gifts, v.Img)
}
for _, v := range res.Data.Winner {
winners = append(winners, v.UName+" 抽到了 "+v.Gift)
}
if gifts == nil {
gifts = _emptyList
}
if winners == nil {
winners = _emptyList
}
return
}
// LeftLotteryTimes 剩余抽奖次数
func (d *Dao) LeftLotteryTimes(c context.Context, actID, mid int64) (times int64, err error) {
var res struct {
Code int `json:"code"`
Data struct {
Times int64 `json:"times"`
} `json:"data"`
}
params := url.Values{}
params.Set("act_id", strconv.FormatInt(actID, 10))
params.Set("mid", strconv.FormatInt(mid, 10))
if err = d.client.Get(c, d.lotteryTimes, "", params, &res); err != nil {
err = errors.Wrapf(err, "d.client.Get(%s)", d.lotteryTimes+"?"+params.Encode())
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrapf(ecode.Int(res.Code), "d.client.Get(%s)", d.lotteryTimes+"?"+params.Encode())
return
}
times = res.Data.Times
return
}
// ActProtocol get act subject & protocol
func (d *Dao) ActProtocol(c context.Context, messionID int64) (protocol *actmdl.SubProtocol, err error) {
arg := &actmdl.ArgActProtocol{Sid: messionID}
protocol, err = d.actRPC.ActProtocol(c, arg)
return
}

80
app/interface/main/app-view/dao/act/dao_test.go Normal file
View File

@@ -0,0 +1,80 @@
package act
import (
"context"
"flag"
"fmt"
"os"
"testing"
"go-common/app/interface/main/app-view/conf"
"github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func TestMain(m *testing.M) {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
m.Run()
os.Exit(0)
}
func TestInfo(t *testing.T) {
var (
c = context.TODO()
actID = int64(1)
randomCnt = int64(10)
)
convey.Convey("Info", t, func(ctx convey.C) {
_, _, err := d.Info(c, actID, randomCnt)
ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldNotBeNil)
})
})
}
func TestLeftLotteryTimes(t *testing.T) {
var (
c = context.TODO()
actID = int64(1)
mid = int64(1)
)
convey.Convey("LeftLotteryTimes", t, func(ctx convey.C) {
_, err := d.LeftLotteryTimes(c, actID, mid)
ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldNotBeNil)
})
})
}
func TestActProtocol(t *testing.T) {
var (
c = context.TODO()
messionID = int64(10338)
)
convey.Convey("ActProtocol", t, func(ctx convey.C) {
act, err := d.ActProtocol(c, messionID)
fmt.Printf("=====%#v======", act)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
}

50
app/interface/main/app-view/dao/ad/BUILD Normal file
View File

@@ -0,0 +1,50 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/ad:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/ad",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/ad:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//library/xstr:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

98
app/interface/main/app-view/dao/ad/dao.go Normal file
View File

@@ -0,0 +1,98 @@
package ad
import (
"context"
"encoding/json"
"net/url"
"strconv"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/ad"
"go-common/library/ecode"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"go-common/library/xstr"
"github.com/pkg/errors"
)
const (
_adURL = "/bce/api/bce/wise"
_monitorInfoURL = "/up-openapi/api/v1/av_monitor_info/%d"
)
// Dao dao.
type Dao struct {
client *bm.Client
adURL string
monitorInfoURL string
}
// New account dao.
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: bm.NewClient(conf.Conf.HTTPAD),
adURL: c.Host.AD + _adURL,
monitorInfoURL: c.Host.AD + _monitorInfoURL,
}
return
}
// Ad ad request.
func (d *Dao) Ad(c context.Context, mobiApp, device, buvid string, build int, mid, upperID, aid int64, rid int32, tids []int64, resource []int64, network, adExtra string) (advert *ad.Ad, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("aid", strconv.FormatInt(aid, 10))
params.Set("build", strconv.Itoa(build))
params.Set("device", device)
params.Set("buvid", buvid)
params.Set("resource", xstr.JoinInts(resource))
params.Set("mobi_app", mobiApp)
params.Set("ip", ip)
params.Set("av_rid", strconv.FormatInt(int64(rid), 10))
params.Set("av_tid", xstr.JoinInts(tids))
params.Set("av_up_id", strconv.FormatInt(upperID, 10))
if network != "" {
params.Set("network", network)
}
if adExtra != "" {
params.Set("ad_extra", adExtra)
}
var res struct {
Code int `json:"code"`
Data *ad.Ad `json:"data"`
}
if err = d.client.Get(c, d.adURL, ip, params, &res); err != nil {
return
}
code := ecode.Int(res.Code)
if !code.Equal(ecode.OK) {
err = errors.Wrap(code, d.adURL+"?"+params.Encode())
return
}
if res.Data != nil {
res.Data.ClientIP = ip
}
advert = res.Data
return
}
// MonitorInfo ad aid monitor info
func (d *Dao) MonitorInfo(c context.Context, aid int64) (minfo json.RawMessage, err error) {
ip := metadata.String(c, metadata.RemoteIP)
var res struct {
Code int `json:"code"`
Data json.RawMessage `json:"data"`
}
if err = d.client.RESTfulGet(c, d.monitorInfoURL, ip, nil, &res, aid); err != nil {
return
}
code := ecode.Int(res.Code)
if !code.Equal(ecode.OK) {
err = errors.Wrap(code, d.monitorInfoURL)
return
}
minfo = res.Data
return
}

52
app/interface/main/app-view/dao/ad/dao_test.go Normal file
View File

@@ -0,0 +1,52 @@
package ad
import (
"context"
"flag"
"os"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/ad"
. "github.com/smartystreets/goconvey/convey"
)
var (
dao *Dao
)
func init() {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
dao = New(conf.Conf)
time.Sleep(time.Second)
}
func TestDao_Ad(t *testing.T) {
Convey("get TestDao_Ad", t, func() {
res, err := dao.Ad(ctx(), "iphone", "phone", "12312", 111, 111, 2222, 1, 1, []int64{1}, []int64{1}, "4g", "")
err = nil
res = &ad.Ad{}
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}
func ctx() context.Context {
return context.Background()
}

45
app/interface/main/app-view/dao/ai/BUILD Normal file
View File

@@ -0,0 +1,45 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/ai",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

34
app/interface/main/app-view/dao/ai/dao.go Normal file
View File

@@ -0,0 +1,34 @@
package ai
import (
"context"
"go-common/app/interface/main/app-view/conf"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
)
const (
_av2GameURL = "/avid2gameid"
)
type Dao struct {
client *bm.Client
av2GameURL string
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: bm.NewClient(c.HTTPGameAsync),
av2GameURL: c.Host.AI + _av2GameURL,
}
return
}
func (d *Dao) Av2Game(c context.Context) (res map[int64]int64, err error) {
ip := metadata.String(c, metadata.RemoteIP)
if err = d.client.Get(c, d.av2GameURL, ip, nil, &res); err != nil {
return
}
return
}

65
app/interface/main/app-view/dao/ai/dao_test.go Normal file
View File

@@ -0,0 +1,65 @@
package ai
import (
"context"
"flag"
"path/filepath"
"reflect"
"testing"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
}
func TestNew(t *testing.T) {
type args struct {
c *conf.Config
}
tests := []struct {
name string
args args
wantD *Dao
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
t.Errorf("New() = %v, want %v", gotD, tt.wantD)
}
})
}
}
func TestDao_Av2Game(t *testing.T) {
type args struct {
c context.Context
}
tests := []struct {
name string
args args
wantRes map[int64]int64
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
Convey(tt.name, t, func() {
gotRes, err := d.Av2Game(tt.args.c)
So(err, ShouldEqual, tt.wantErr)
So(gotRes, ShouldResemble, tt.wantRes)
})
}
}

73
app/interface/main/app-view/dao/archive/BUILD Normal file
View File

@@ -0,0 +1,73 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = [
"api_test.go",
"dao_test.go",
"memcache_test.go",
"stat_test.go",
"view_test.go",
],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/archive/model/archive:go_default_library",
"//library/net/rpc:go_default_library",
"//library/time:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = [
"api.go",
"bnj.go",
"dao.go",
"memcache.go",
"stat.go",
"view.go",
],
importpath = "go-common/app/interface/main/app-view/dao/archive",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/view:go_default_library",
"//app/interface/main/history/model:go_default_library",
"//app/interface/main/history/rpc/client:go_default_library",
"//app/service/main/archive/api:go_default_library",
"//app/service/main/archive/api/gorpc:go_default_library",
"//app/service/main/archive/model/archive:go_default_library",
"//library/cache/memcache:go_default_library",
"//library/ecode:go_default_library",
"//library/log:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//library/sync/errgroup:go_default_library",
"//library/xstr:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

140
app/interface/main/app-view/dao/archive/api.go Normal file
View File

@@ -0,0 +1,140 @@
package archive
import (
"context"
"net/http"
"net/url"
"strconv"
"go-common/app/interface/main/app-view/model/view"
"go-common/app/service/main/archive/model/archive"
"go-common/library/ecode"
"go-common/library/log"
"go-common/library/net/metadata"
"go-common/library/xstr"
"github.com/pkg/errors"
)
const (
_realteURL = "/recsys/related"
_commercialURL = "/x/internal/creative/arc/commercial"
_relateRecURL = "/recommand"
_playURL = "/playurl/batch"
)
// RelateAids get relate by aid
func (d *Dao) RelateAids(c context.Context, aid int64) (aids []int64, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("key", strconv.FormatInt(aid, 10))
var res struct {
Code int `json:"code"`
Data []*struct {
Value string `json:"value"`
} `json:"data"`
}
if err = d.client.Get(c, d.realteURL, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.realteURL+"?"+params.Encode())
return
}
if len(res.Data) != 0 {
if aids, err = xstr.SplitInts(res.Data[0].Value); err != nil {
err = errors.Wrap(err, res.Data[0].Value)
}
}
return
}
// Commercial is
func (d *Dao) Commercial(c context.Context, aid int64) (gameID int64, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("aid", strconv.FormatInt(aid, 10))
var res struct {
Code int `json:"code"`
Data *struct {
GameID int64 `json:"game_id"`
} `json:"data"`
}
if err = d.client.Get(c, d.commercialURL, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.commercialURL+"?"+params.Encode())
return
}
if res.Data != nil {
gameID = res.Data.GameID
}
return
}
// NewRelateAids relate online recommend 在线实时推荐
func (d *Dao) NewRelateAids(c context.Context, aid, mid int64, build, parentMode int, buvid, from string, plat int8) (rec []*view.NewRelateRec, userFeature, returnCode string, dalaoExp int, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("from", "2")
params.Set("cmd", "related")
params.Set("timeout", "100")
params.Set("plat", strconv.Itoa(int(plat)))
params.Set("build", strconv.Itoa(build))
params.Set("buvid", buvid)
params.Set("from_av", strconv.FormatInt(aid, 10))
params.Set("request_cnt", "40")
params.Set("source_page", from)
params.Set("parent_mode", strconv.Itoa(parentMode))
params.Set("need_dalao", "1")
var res struct {
Code int `json:"code"`
Data []*view.NewRelateRec `json:"data"`
UserFeature string `json:"user_feature"`
DalaoExp int `json:"dalao_exp"`
}
log.Warn("dalaotest url(%s)", d.relateRecURL+"?"+params.Encode())
if err = d.client.Get(c, d.relateRecURL, ip, params, &res); err != nil {
returnCode = "500"
return
}
returnCode = strconv.Itoa(res.Code)
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.relateRecURL+"?"+params.Encode())
return
}
dalaoExp = res.DalaoExp
userFeature = res.UserFeature
rec = res.Data
return
}
// PlayerInfos cid with player info
func (d *Dao) PlayerInfos(c context.Context, cids []int64, qn, fnver, fnval, forceHost int, platform string) (pm map[uint32]*archive.BvcVideoItem, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("cid", xstr.JoinInts(cids))
params.Set("qn", strconv.Itoa(qn))
params.Set("platform", platform)
params.Set("uip", ip)
params.Set("layout", "pb")
params.Set("fnver", strconv.Itoa(fnver))
params.Set("fnval", strconv.Itoa(fnval))
params.Set("force_host", strconv.Itoa(forceHost))
var req *http.Request
if req, err = d.client.NewRequest("GET", d.playURL, ip, params); err != nil {
return
}
res := new(archive.BvcResponseMsg)
if err = d.httpClient.PB(c, req, res); err != nil {
return
}
if int(res.Code) != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(int(res.Code)), d.playURL+params.Encode())
return
}
pm = res.Data
return
}

21
app/interface/main/app-view/dao/archive/api_test.go Normal file
View File

@@ -0,0 +1,21 @@
package archive
import (
"context"
"testing"
"github.com/smartystreets/goconvey/convey"
)
func TestRelateAids(t *testing.T) {
var (
c = context.TODO()
aid = int64(1)
)
convey.Convey("Ping", t, func(ctx convey.C) {
_, err := d.RelateAids(c, aid)
ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldNotBeNil)
})
})
}

19
app/interface/main/app-view/dao/archive/bnj.go Normal file
View File

@@ -0,0 +1,19 @@
package archive
import (
"context"
"go-common/app/service/main/archive/model/archive"
)
// ViewsRPC is
func (d *Dao) ViewsRPC(c context.Context, aids []int64) (avm map[int64]*archive.View3, err error) {
avm, err = d.arcRPC.Views3(c, &archive.ArgAids2{Aids: aids})
return
}
// ViewRPC is
func (d *Dao) ViewRPC(c context.Context, aid int64) (v *archive.View3, err error) {
v, err = d.arcRPC.View3(c, &archive.ArgAid2{Aid: aid})
return
}

220
app/interface/main/app-view/dao/archive/dao.go Normal file
View File

@@ -0,0 +1,220 @@
package archive
import (
"context"
"runtime"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/view"
"go-common/app/service/main/archive/api"
"go-common/app/service/main/archive/model/archive"
"go-common/library/sync/errgroup"
history "go-common/app/interface/main/history/model"
hisrpc "go-common/app/interface/main/history/rpc/client"
arcrpc "go-common/app/service/main/archive/api/gorpc"
"go-common/library/cache/memcache"
"go-common/library/log"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
// Dao is archive dao.
type Dao struct {
// http client
client *bm.Client
httpClient *bm.Client
realteURL string
commercialURL string
relateRecURL string
playURL string
// rpc
arcRPC *arcrpc.Service2
hisRPC *hisrpc.Service
// memcache
arcMc *memcache.Pool
expireArc int32
expireRlt int32
// chan
mCh chan func()
}
// New new a archive dao.
func New(c *conf.Config) (d *Dao) {
d = &Dao{
// http client
client: bm.NewClient(c.HTTPWrite),
httpClient: bm.NewClient(c.HTTPClient),
arcRPC: arcrpc.New2(c.ArchiveRPC),
hisRPC: hisrpc.New(c.HisRPC),
realteURL: c.Host.Data + _realteURL,
commercialURL: c.Host.APICo + _commercialURL,
relateRecURL: c.Host.Data + _relateRecURL,
playURL: c.Host.Bvcvod + _playURL,
// memcache
arcMc: memcache.NewPool(c.Memcache.Archive.Config),
expireArc: int32(time.Duration(c.Memcache.Archive.ArchiveExpire) / time.Second),
expireRlt: int32(time.Duration(c.Memcache.Archive.RelateExpire) / time.Second),
// mc proc
mCh: make(chan func(), 10240),
}
// video db
for i := 0; i < runtime.NumCPU()*2; i++ {
go d.cacheproc()
}
return
}
// Ping ping check memcache connection
func (d *Dao) Ping(c context.Context) (err error) {
return d.pingMC(c)
}
// Archive3 get archive.
func (d *Dao) Archive3(c context.Context, aid int64) (a *api.Arc, err error) {
arg := &archive.ArgAid2{Aid: aid}
if a, err = d.arcRPC.Archive3(c, arg); err != nil {
log.Error("d.arcRPC.Archive3(%v) error(%+v)", arg, err)
return
}
return
}
// Archives multi get archives.
func (d *Dao) Archives(c context.Context, aids []int64) (as map[int64]*api.Arc, err error) {
if len(aids) == 0 {
return
}
var stm map[int64]*api.Stat
g, ctx := errgroup.WithContext(c)
g.Go(func() (err error) {
var missed []int64
if as, missed, err = d.arcsCache(ctx, aids); err != nil {
as = make(map[int64]*api.Arc, len(aids))
missed = aids
log.Error("%+v", err)
err = nil
}
if len(missed) == 0 {
return
}
var tmp map[int64]*api.Arc
arg := &archive.ArgAids2{Aids: missed}
if tmp, err = d.arcRPC.Archives3(ctx, arg); err != nil {
log.Error("d.arcRPC.Archives3(%v) error(%v)", arg, err)
return
}
for aid, a := range tmp {
as[aid] = a
}
return
})
g.Go(func() (err error) {
var missed []int64
if stm, missed, err = d.statsCache(ctx, aids); err != nil {
stm = make(map[int64]*api.Stat, len(aids))
missed = aids
log.Error("%+v", err)
err = nil
}
if len(missed) == 0 {
return
}
var tmp map[int64]*api.Stat
arg := &archive.ArgAids2{Aids: missed}
if tmp, err = d.arcRPC.Stats3(ctx, arg); err != nil {
log.Error("d.arcRPC.Stats3(%v) error(%v)", arg, err)
err = nil
return
}
for aid, st := range tmp {
stm[aid] = st
}
return
})
if err = g.Wait(); err != nil {
log.Error("%+v", err)
return
}
for aid, a := range as {
if st, ok := stm[aid]; ok {
a.Stat = *st
}
}
return
}
// Shot get video shot.
func (d *Dao) Shot(c context.Context, aid, cid int64) (shot *archive.Videoshot, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &archive.ArgCid2{Aid: aid, Cid: cid, RealIP: ip}
return d.arcRPC.Videoshot2(c, arg)
}
// UpCount2 get upper count.
func (d *Dao) UpCount2(c context.Context, mid int64) (cnt int, err error) {
arg := &archive.ArgUpCount2{Mid: mid}
if cnt, err = d.arcRPC.UpCount2(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
// UpArcs3 get upper archives.
func (d *Dao) UpArcs3(c context.Context, mid int64, pn, ps int) (as []*api.Arc, err error) {
arg := &archive.ArgUpArcs2{Mid: mid, Pn: pn, Ps: ps}
if as, err = d.arcRPC.UpArcs3(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
// Progress is archive plays progress .
func (d *Dao) Progress(c context.Context, aid, mid int64) (h *view.History, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &history.ArgPro{Mid: mid, Aids: []int64{aid}, RealIP: ip}
his, err := d.hisRPC.Progress(c, arg)
if err != nil {
log.Error("d.hisRPC.Progress(%v) error(%v)", arg, err)
return
}
if his[aid] != nil {
h = &view.History{Cid: his[aid].Cid, Progress: his[aid].Pro}
}
return
}
// Archive 用的时候注意了！！！这个方法得到的稿件Stat不是最新的！！！
func (d *Dao) Archive(c context.Context, aid int64) (a *api.Arc, err error) {
if a, err = d.arcCache(c, aid); err != nil {
log.Error("%+v", err)
} else if a != nil {
return
}
if a, err = d.arcRPC.Archive3(c, &archive.ArgAid2{Aid: aid}); err != nil {
log.Error("d.arcRPC.Archive3(%d) error(%v)", aid, err)
return
}
return
}
// addCache add archive to mc or redis
func (d *Dao) addCache(f func()) {
select {
case d.mCh <- f:
default:
log.Warn("cacheproc chan full")
}
}
// cacheproc write memcache and stat redis use goroutine
func (d *Dao) cacheproc() {
for {
f := <-d.mCh
f()
}
}

162
app/interface/main/app-view/dao/archive/dao_test.go Normal file
View File

@@ -0,0 +1,162 @@
package archive
import (
"context"
"flag"
"os"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/app/service/main/archive/model/archive"
"go-common/library/net/rpc"
xtime "go-common/library/time"
"github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func TestMain(m *testing.M) {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
m.Run()
os.Exit(0)
}
func TestViewRPC(t *testing.T) {
convey.Convey("TestViewRPC", t, func(ctx convey.C) {
var addr = "172.22.36.185:6089" // new
// addr = "172.22.38.5:6089" // old
client := rpc.Dial(addr, xtime.Duration(100*time.Millisecond), nil)
var (
view *archive.View3
views map[int64]*archive.View3
err error
)
if err = client.Call(context.TODO(), "RPC.View3", &archive.ArgAid{Aid: 10111165}, &view); err != nil {
ctx.Println(err)
return
}
ctx.Println(view)
if err = client.Call(context.TODO(), "RPC.Views3", &archive.ArgAids{Aids: []int64{10111165}}, &views); err != nil {
ctx.Println(err)
return
}
ctx.Println(views)
})
}
func TestPing(t *testing.T) {
var (
c = context.TODO()
)
convey.Convey("Ping", t, func(ctx convey.C) {
d.Ping(c)
})
}
func TestArchive3(t *testing.T) {
var (
c = context.TODO()
aid = int64(0)
)
convey.Convey("Archive3", t, func(ctx convey.C) {
_, err := d.Archive3(c, aid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestArchives(t *testing.T) {
var (
c = context.TODO()
aids = []int64{1}
)
convey.Convey("Archives", t, func(ctx convey.C) {
_, err := d.Archives(c, aids)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestShot(t *testing.T) {
var (
c = context.TODO()
aid = int64(1)
cid = int64(2)
)
convey.Convey("Shot", t, func(ctx convey.C) {
d.Shot(c, aid, cid)
})
}
func TestUpCount2(t *testing.T) {
var (
c = context.TODO()
mid = int64(1)
)
convey.Convey("UpCount2", t, func(ctx convey.C) {
_, err := d.UpCount2(c, mid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestUpArcs3(t *testing.T) {
var (
c = context.TODO()
mid = int64(1)
pn = int(1)
ps = int(20)
)
convey.Convey("UpArcs3", t, func(ctx convey.C) {
d.UpArcs3(c, mid, pn, ps)
})
}
func TestProgress(t *testing.T) {
var (
c = context.TODO()
aid = int64(1)
mid = int64(1)
)
convey.Convey("Progress", t, func(ctx convey.C) {
_, err := d.Progress(c, aid, mid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestArchive(t *testing.T) {
var (
c = context.TODO()
aid = int64(-1)
)
convey.Convey("Archive", t, func(ctx convey.C) {
_, err := d.Archive(c, aid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
ctx.So(err, convey.ShouldNotBeNil)
})
})
}

246
app/interface/main/app-view/dao/archive/memcache.go Normal file
View File

@@ -0,0 +1,246 @@
package archive
import (
"context"
"strconv"
"go-common/app/interface/main/app-view/model/view"
"go-common/app/service/main/archive/api"
"go-common/app/service/main/archive/model/archive"
"go-common/library/cache/memcache"
"go-common/library/log"
"github.com/pkg/errors"
)
const (
_prefixRelate = "al_"
_prefixViewStatic = "avp_"
_prefixStat = "stp_"
_prefixArchive = "a3p_"
_prefixViewContribute = "avpc_"
)
func keyRl(aid int64) string {
return _prefixRelate + strconv.FormatInt(aid, 10)
}
func keyView(aid int64) string {
return _prefixViewStatic + strconv.FormatInt(aid, 10)
}
func keyStat(aid int64) string {
return _prefixStat + strconv.FormatInt(aid, 10)
}
func keyArc(aid int64) string {
return _prefixArchive + strconv.FormatInt(aid, 10)
}
func keyViewContribute(mid int64) string {
return _prefixViewContribute + strconv.FormatInt(mid, 10)
}
// AddRelatesCache add relates
func (d *Dao) AddRelatesCache(aid int64, rls []*view.Relate) {
d.addCache(func() {
d.addRelatesCache(context.TODO(), aid, rls)
})
}
// RelatesCache get relates.
func (d *Dao) RelatesCache(c context.Context, aid int64) (rls []*view.Relate, err error) {
conn := d.arcMc.Get(c)
key := keyRl(aid)
defer conn.Close()
r, err := conn.Get(key)
if err != nil {
if err == memcache.ErrNotFound {
err = nil
return
}
err = errors.Wrapf(err, "conn.Get(%s)", key)
return
}
if err = conn.Scan(r, &rls); err != nil {
err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
}
return
}
// addRelatesCache add relates cache.
func (d *Dao) addRelatesCache(c context.Context, aid int64, rls []*view.Relate) (err error) {
conn := d.arcMc.Get(c)
key := keyRl(aid)
item := &memcache.Item{Key: key, Object: rls, Flags: memcache.FlagJSON, Expiration: d.expireRlt}
if err = conn.Set(item); err != nil {
err = errors.Wrapf(err, "conn.Set(%s,%v,%d)", key, rls, d.expireRlt)
}
conn.Close()
return
}
// viewCache get view cache from remote memecache .
func (d *Dao) viewCache(c context.Context, aid int64) (vs *archive.View3, err error) {
conn := d.arcMc.Get(c)
key := keyView(aid)
defer conn.Close()
r, err := conn.Get(key)
if err != nil {
if err == memcache.ErrNotFound {
err = nil
return
}
err = errors.Wrapf(err, "conn.Get(%s)", key)
return
}
vs = &archive.View3{Archive3: &archive.Archive3{}}
if err = conn.Scan(r, vs); err != nil {
vs = nil
err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
}
return
}
// statCache get a archive stat from cache.
func (d *Dao) statCache(c context.Context, aid int64) (st *api.Stat, err error) {
conn := d.arcMc.Get(c)
key := keyStat(aid)
defer conn.Close()
r, err := conn.Get(key)
if err != nil {
if err == memcache.ErrNotFound {
err = nil
return
}
err = errors.Wrapf(err, "conn.Get(%s)", key)
return
}
st = &api.Stat{}
if err = conn.Scan(r, st); err != nil {
st = nil
err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
}
return
}
// statsCache get stat cache by aids
func (d *Dao) statsCache(c context.Context, aids []int64) (cached map[int64]*api.Stat, missed []int64, err error) {
cached = make(map[int64]*api.Stat, len(aids))
conn := d.arcMc.Get(c)
defer conn.Close()
keys := make([]string, 0, len(aids))
for _, aid := range aids {
keys = append(keys, keyStat(aid))
}
rs, err := conn.GetMulti(keys)
if err != nil {
err = errors.Wrapf(err, "conn.GetMulti(%v)", keys)
return
}
for _, item := range rs {
var st = &api.Stat{}
if err = conn.Scan(item, st); err != nil {
err = nil
log.Error("conn.Scan(%v) error(%v)", item, err)
continue
}
cached[st.Aid] = st
}
if len(cached) == len(aids) {
return
}
for _, aid := range aids {
if _, ok := cached[aid]; !ok {
missed = append(missed, aid)
}
}
return
}
// arcsCache get archives cache.
func (d *Dao) arcsCache(c context.Context, aids []int64) (cached map[int64]*api.Arc, missed []int64, err error) {
cached = make(map[int64]*api.Arc, len(aids))
conn := d.arcMc.Get(c)
defer conn.Close()
keys := make([]string, 0, len(aids))
aidmap := make(map[string]int64, len(aids))
for _, aid := range aids {
k := keyArc(aid)
if _, ok := aidmap[k]; !ok {
keys = append(keys, k)
aidmap[k] = aid
}
}
rs, err := conn.GetMulti(keys)
if err != nil {
err = errors.Wrapf(err, "conn.GetMulti(%v)", keys)
return
}
for k, r := range rs {
a := &api.Arc{}
if err = conn.Scan(r, a); err != nil {
log.Error("conn.Scan(%s) error(%v)", r.Value, err)
err = nil
continue
}
cached[aidmap[k]] = a
// delete hit key
delete(aidmap, k)
}
// missed key
missed = make([]int64, 0, len(aidmap))
for _, aid := range aidmap {
missed = append(missed, aid)
}
return
}
// arcCache get archive cache.
func (d *Dao) arcCache(c context.Context, aid int64) (a *api.Arc, err error) {
conn := d.arcMc.Get(c)
key := keyArc(aid)
defer conn.Close()
r, err := conn.Get(key)
if err != nil {
if err == memcache.ErrNotFound {
err = nil
return
}
err = errors.Wrapf(err, "conn.Get(%s)", key)
return
}
a = &api.Arc{}
if err = conn.Scan(r, a); err != nil {
a = nil
err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
}
return
}
// ViewContributeCache get archive cache.
func (d *Dao) ViewContributeCache(c context.Context, mid int64) (aids []int64, err error) {
conn := d.arcMc.Get(c)
key := keyViewContribute(mid)
defer conn.Close()
r, err := conn.Get(key)
if err != nil {
if err == memcache.ErrNotFound {
err = nil
return
}
err = errors.Wrapf(err, "conn.Get(%s)", key)
return
}
if err = conn.Scan(r, &aids); err != nil {
err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
}
return
}
func (d *Dao) pingMC(c context.Context) (err error) {
conn := d.arcMc.Get(c)
err = conn.Set(&memcache.Item{Key: "ping", Object: []byte{1}, Flags: memcache.FlagJSON, Expiration: 0})
conn.Close()
return
}

26
app/interface/main/app-view/dao/archive/memcache_test.go Normal file
View File

@@ -0,0 +1,26 @@
package archive
import (
"context"
"testing"
. "github.com/smartystreets/goconvey/convey"
)
func Test_AddRelatesCache(t *testing.T) {
Convey("AddRelatesCache", t, func() {
d.AddRelatesCache(1, nil)
})
}
func Test_RelatesCache(t *testing.T) {
Convey("RelatesCache", t, func() {
d.RelatesCache(context.TODO(), 1)
})
}
func Test_ViewContributeCache(t *testing.T) {
Convey("ViewContributeCache", t, func() {
d.ViewContributeCache(context.TODO(), 2)
})
}

23
app/interface/main/app-view/dao/archive/stat.go Normal file
View File

@@ -0,0 +1,23 @@
package archive
import (
"context"
"go-common/app/service/main/archive/api"
"go-common/app/service/main/archive/model/archive"
"go-common/library/log"
)
// Stat get a archive stat.
func (d *Dao) Stat(c context.Context, aid int64) (st *api.Stat, err error) {
if st, err = d.statCache(c, aid); err != nil {
log.Error("%+v", err)
} else if st != nil {
return
}
arg := &archive.ArgAid2{Aid: aid}
if st, err = d.arcRPC.Stat3(c, arg); err != nil {
log.Error("d.arcRPC.Stat3(%v) error(%v)", arg, err)
}
return
}

14
app/interface/main/app-view/dao/archive/stat_test.go Normal file
View File

@@ -0,0 +1,14 @@
package archive
import (
"context"
"testing"
. "github.com/smartystreets/goconvey/convey"
)
func TestDao_Stat(t *testing.T) {
Convey("Stat", t, func() {
d.Stat(context.TODO(), 2)
})
}

68
app/interface/main/app-view/dao/archive/view.go Normal file
View File

@@ -0,0 +1,68 @@
package archive
import (
"context"
"go-common/app/service/main/archive/api"
"go-common/app/service/main/archive/model/archive"
"go-common/library/ecode"
"go-common/library/log"
"github.com/pkg/errors"
)
// View3 view archive with pages pb.
func (d *Dao) View3(c context.Context, aid int64) (v *archive.View3, err error) {
arg := &archive.ArgAid2{Aid: aid}
if v, err = d.arcRPC.View3(c, arg); err != nil {
log.Error("d.arcRPC.View3(%v) error(%+v)", arg, err)
if ecode.Cause(err) == ecode.NothingFound {
err = nil
return
}
}
return
}
// ViewCache get view static data from cache if cache missed from rpc.
func (d *Dao) ViewCache(c context.Context, aid int64) (vs *archive.View3, err error) {
if aid == 0 {
return
}
if vs, err = d.viewCache(c, aid); err != nil {
return
}
if vs != nil && vs.Archive3 != nil && len(vs.Pages) != 0 {
var st *api.Stat
if st, err = d.Stat(c, aid); err != nil {
log.Error("%+v", err)
err = nil
return
}
if st != nil {
vs.Archive3.Stat = archive.Stat3{
Aid: st.Aid,
View: st.View,
Danmaku: st.Danmaku,
Reply: st.Reply,
Fav: st.Fav,
Coin: st.Coin,
Share: st.Share,
NowRank: st.NowRank,
HisRank: st.HisRank,
Like: st.Like,
DisLike: st.DisLike,
}
}
}
return
}
// Description get archive description by aid.
func (d *Dao) Description(c context.Context, aid int64) (desc string, err error) {
arg := &archive.ArgAid{Aid: aid}
if desc, err = d.arcRPC.Description2(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}

26
app/interface/main/app-view/dao/archive/view_test.go Normal file
View File

@@ -0,0 +1,26 @@
package archive
import (
"context"
"testing"
. "github.com/smartystreets/goconvey/convey"
)
func Test_View3(t *testing.T) {
Convey("View3", t, func() {
d.View3(context.TODO(), 1)
})
}
func Test_ViewCache(t *testing.T) {
Convey("ViewCache", t, func() {
d.ViewCache(context.TODO(), 1)
})
}
func Test_Description(t *testing.T) {
Convey("Description", t, func() {
d.Description(context.TODO(), 2)
})
}

46
app/interface/main/app-view/dao/assist/BUILD Normal file
View File

@@ -0,0 +1,46 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/assist",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/assist/model/assist:go_default_library",
"//app/service/main/assist/rpc/client:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

33
app/interface/main/app-view/dao/assist/dao.go Normal file
View File

@@ -0,0 +1,33 @@
package assist
import (
"context"
"go-common/app/interface/main/app-view/conf"
"go-common/app/service/main/assist/model/assist"
assistrpc "go-common/app/service/main/assist/rpc/client"
"github.com/pkg/errors"
)
// Dao is assist dao
type Dao struct {
assistRPC *assistrpc.Service
}
// New initial assist dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
assistRPC: assistrpc.New(c.AssistRPC),
}
return
}
// Assist get assists data from api.
func (d *Dao) Assist(c context.Context, upMid int64) (asss []int64, err error) {
arg := &assist.ArgAssists{Mid: upMid}
if asss, err = d.assistRPC.AssistIDs(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}

37
app/interface/main/app-view/dao/assist/dao_test.go Normal file
View File

@@ -0,0 +1,37 @@
package assist
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestAssist(t *testing.T) {
Convey("get Assist all", t, func() {
res, err := d.Assist(ctx(), 1)
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

49
app/interface/main/app-view/dao/audio/BUILD Normal file
View File

@@ -0,0 +1,49 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/audio",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/view:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//library/xstr:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

56
app/interface/main/app-view/dao/audio/dao.go Normal file
View File

@@ -0,0 +1,56 @@
package audio
import (
"context"
"go-common/app/interface/main/app-view/conf"
"go-common/library/ecode"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"net/url"
"go-common/app/interface/main/app-view/model/view"
"go-common/library/xstr"
"github.com/pkg/errors"
)
const (
// _audioByCids = "/x/internal/v1/audio/songs/by_cids"
_audioByCids = "/audio/music-service-c/internal/songs-by-cids"
)
// Dao is archive dao.
type Dao struct {
// http client
client *bm.Client
audioByCidsURL string
}
// New new a archive dao.
func New(c *conf.Config) (d *Dao) {
d = &Dao{
// http client
client: bm.NewClient(c.HTTPAudio),
audioByCidsURL: c.Host.APICo + _audioByCids,
}
return
}
func (d *Dao) AudioByCids(c context.Context, cids []int64) (vam map[int64]*view.Audio, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("cids", xstr.JoinInts(cids))
var res struct {
Code int `json:"code"`
Data map[int64]*view.Audio `json:"data"`
}
if err = d.client.Get(c, d.audioByCidsURL, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.audioByCidsURL+"?"+params.Encode())
return
}
vam = res.Data
return
}

37
app/interface/main/app-view/dao/audio/dao_test.go Normal file
View File

@@ -0,0 +1,37 @@
package audio
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestAudioByCids(t *testing.T) {
Convey("get AudioByCids all", t, func() {
res, err := d.AudioByCids(ctx(), []int64{1})
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

52
app/interface/main/app-view/dao/bangumi/BUILD Normal file
View File

@@ -0,0 +1,52 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = [
"dao.go",
"grpc.go",
],
importpath = "go-common/app/interface/main/app-view/dao/bangumi",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/bangumi:go_default_library",
"//app/service/openplatform/pgc-season/api/grpc/season/v1:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

120
app/interface/main/app-view/dao/bangumi/dao.go Normal file
View File

@@ -0,0 +1,120 @@
package bangumi
import (
"context"
"net/url"
"strconv"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/bangumi"
seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
const (
_pgc = "/pgc/internal/season/appview"
_movie = "/internal_api/movie_aid_info"
_seasonidAidURL = "/api/inner/archive/seasonid2aid"
)
// Dao is bangumi dao
type Dao struct {
client *httpx.Client
pgc string
movie string
seasonidAidURL string
// grpc
rpcClient seasongrpc.SeasonClient
}
// New bangumi dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPBangumi),
pgc: c.Host.APICo + _pgc,
movie: c.Host.Bangumi + _movie,
seasonidAidURL: c.Host.Bangumi + _seasonidAidURL,
}
var err error
if d.rpcClient, err = seasongrpc.NewClient(nil); err != nil {
panic(errors.WithMessage(err, "panic by seasongrpc"))
}
return
}
// PGC bangumi Season .
func (d *Dao) PGC(c context.Context, aid, mid int64, build int, mobiApp, device string) (s *bangumi.Season, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("aid", strconv.FormatInt(aid, 10))
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("build", strconv.Itoa(build))
params.Set("device", device)
params.Set("mobi_app", mobiApp)
params.Set("platform", "Golang")
var res struct {
Code int `json:"code"`
Result *bangumi.Season `json:"result"`
}
if err = d.client.Get(c, d.pgc, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.pgc+"?"+params.Encode())
return
}
s = res.Result
return
}
// Movie bangumi Movie
func (d *Dao) Movie(c context.Context, aid, mid int64, build int, mobiApp, device string) (m *bangumi.Movie, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("id", strconv.FormatInt(aid, 10))
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("build", strconv.Itoa(build))
params.Set("device", device)
params.Set("mobi_app", mobiApp)
params.Set("platform", "Golang")
var res struct {
Code int `json:"code"`
Result *bangumi.Movie `json:"result"`
}
if err = d.client.Get(c, d.movie, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.movie+"?"+params.Encode())
return
}
m = res.Result
return
}
// SeasonidAid moive_id by aid
func (d *Dao) SeasonidAid(c context.Context, moiveID int64, now time.Time) (data map[int64]int64, err error) {
params := url.Values{}
params.Set("build", "app-api")
params.Set("platform", "Golang")
params.Set("season_id", strconv.FormatInt(moiveID, 10))
params.Set("season_type", "2")
var res struct {
Code int `json:"code"`
Result map[int64]int64 `json:"result"`
}
if err = d.client.Get(c, d.seasonidAidURL, "", params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.seasonidAidURL+"?"+params.Encode())
return
}
data = res.Result
return
}

53
app/interface/main/app-view/dao/bangumi/dao_test.go Normal file
View File

@@ -0,0 +1,53 @@
package bangumi
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestMovie(t *testing.T) {
Convey("get Movie all", t, func() {
res, err := d.Movie(ctx(), 1, 1, 1, "iphone", "phone")
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}
func TestPGC(t *testing.T) {
Convey("get PGC all", t, func() {
res, err := d.PGC(ctx(), 1, 1, 1, "iphone", "phone")
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}
func TestSeasonidAid(t *testing.T) {
Convey("get SeasonidAid all", t, func() {
res, err := d.SeasonidAid(ctx(), 1, time.Now())
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

21
app/interface/main/app-view/dao/bangumi/grpc.go Normal file
View File

@@ -0,0 +1,21 @@
package bangumi
import (
"context"
seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
"github.com/pkg/errors"
)
// CardsInfoReply pgc cards info
func (d *Dao) CardsInfoReply(c context.Context, seasonIds []int32) (res map[int32]*seasongrpc.CardInfoProto, err error) {
arg := &seasongrpc.SeasonInfoReq{SeasonIds: seasonIds}
info, err := d.rpcClient.Cards(c, arg)
if err != nil {
err = errors.Wrapf(err, "%v", arg)
return
}
res = info.Cards
return
}

47
app/interface/main/app-view/dao/coin/BUILD Normal file
View File

@@ -0,0 +1,47 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/coin",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/coin/api/gorpc:go_default_library",
"//app/service/main/coin/model:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

52
app/interface/main/app-view/dao/coin/dao.go Normal file
View File

@@ -0,0 +1,52 @@
package coin
import (
"context"
"go-common/app/interface/main/app-view/conf"
coinrpc "go-common/app/service/main/coin/api/gorpc"
"go-common/app/service/main/coin/model"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
// Dao is coin dao
type Dao struct {
coinRPC *coinrpc.Service
}
// New initial coin dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
coinRPC: coinrpc.New(c.CoinRPC),
}
return
}
// AddCoins add coin to upper.
func (d *Dao) AddCoins(c context.Context, aid, mid, upID, maxCoin, avtype, multiply int64, typeID int16, pubTime int64) (err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &model.ArgAddCoin{Mid: mid, UpMid: upID, MaxCoin: maxCoin, Aid: aid, AvType: avtype, Multiply: multiply, RealIP: ip, TypeID: typeID, PubTime: pubTime}
return d.coinRPC.AddCoins(c, arg)
}
// ArchiveUserCoins .
func (d *Dao) ArchiveUserCoins(c context.Context, aid, mid, avType int64) (res *model.ArchiveUserCoins, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &model.ArgCoinInfo{Mid: mid, Aid: aid, AvType: avType, RealIP: ip}
if res, err = d.coinRPC.ArchiveUserCoins(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
// UserCoins get user coins
func (d *Dao) UserCoins(c context.Context, mid int64) (count float64, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &model.ArgCoinInfo{Mid: mid, RealIP: ip}
if count, err = d.coinRPC.UserCoins(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}

36
app/interface/main/app-view/dao/coin/dao_test.go Normal file
View File

@@ -0,0 +1,36 @@
package coin
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestAddCoins(t *testing.T) {
Convey("get AddCoins all", t, func() {
err := d.AddCoins(ctx(), 1, 1, 1, 1, 1, 1, 1, 0)
So(err, ShouldBeNil)
})
}

49
app/interface/main/app-view/dao/creative/BUILD Normal file
View File

@@ -0,0 +1,49 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/creative",
tags = ["automanaged"],
visibility = ["//visibility:public"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/creative:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

132
app/interface/main/app-view/dao/creative/dao.go Normal file
View File

@@ -0,0 +1,132 @@
package creative
import (
"context"
"net/url"
"strconv"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/creative"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
const (
_special = "/x/internal/uper/special"
_follow = "/x/internal/uper/switch"
_bgm = "/x/internal/creative/archive/bgm"
_points = "/x/internal/creative/video/viewpoints"
)
// Dao is space dao
type Dao struct {
client *httpx.Client
special string
follow string
bgm string
points string
}
// New initial space dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPClient),
special: c.Host.APICo + _special,
follow: c.Host.APICo + _follow,
bgm: c.Host.APICo + _bgm,
points: c.Host.APICo + _points,
}
return
}
// FollowSwitch get auto follow switch .
func (d *Dao) FollowSwitch(c context.Context, vmid int64) (s *creative.FollowSwitch, err error) {
params := url.Values{}
params.Set("mid", strconv.FormatInt(vmid, 10))
params.Set("from", "0")
var res struct {
Code int `json:"code"`
Data *creative.FollowSwitch `json:"data"`
}
ip := metadata.String(c, metadata.RemoteIP)
if err = d.client.Get(c, d.follow, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.follow+"?"+params.Encode())
return
}
s = res.Data
return
}
// Bgm get archive bgm
func (d *Dao) Bgm(c context.Context, aid, cid int64) (bgm []*creative.Bgm, err error) {
params := url.Values{}
params.Set("aid", strconv.FormatInt(aid, 10))
params.Set("cid", strconv.FormatInt(cid, 10))
var res struct {
Code int `json:"code"`
Data []*creative.Bgm `json:"data"`
}
ip := metadata.String(c, metadata.RemoteIP)
if err = d.client.Get(c, d.bgm, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.bgm+"?"+params.Encode())
return
}
bgm = res.Data
return
}
// Points get video points
func (d *Dao) Points(c context.Context, aid, cid int64) (points []*creative.Points, err error) {
params := url.Values{}
params.Set("aid", strconv.FormatInt(aid, 10))
params.Set("cid", strconv.FormatInt(cid, 10))
var res struct {
Code int `json:"code"`
Data struct {
Points []*creative.Points `json:"points"`
} `json:"data"`
}
ip := metadata.String(c, metadata.RemoteIP)
if err = d.client.Get(c, d.points, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.points+"?"+params.Encode())
return
}
points = res.Data.Points
return
}
// Special is
func (d *Dao) Special(c context.Context) (midsM map[int64]struct{}, err error) {
params := url.Values{}
params.Set("group_id", "20")
var res struct {
Code int `json:"code"`
Data []struct {
Mid int64 `json:"mid"`
} `json:"data"`
}
if err = d.client.Get(c, d.special, "", params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.special+"?"+params.Encode())
return
}
midsM = make(map[int64]struct{})
for _, l := range res.Data {
midsM[l.Mid] = struct{}{}
}
return
}

89
app/interface/main/app-view/dao/creative/dao_test.go Normal file
View File

@@ -0,0 +1,89 @@
package creative
import (
"context"
"flag"
"os"
"testing"
"go-common/app/interface/main/app-view/conf"
"github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func TestMain(m *testing.M) {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
m.Run()
os.Exit(0)
}
func TestMovie(t *testing.T) {
var (
c = context.TODO()
vmid = int64(0)
)
convey.Convey("Movie", t, func(ctx convey.C) {
_, err := d.FollowSwitch(c, vmid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
err = nil
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestBgm(t *testing.T) {
var (
c = context.TODO()
aid = int64(10110995)
cid = int64(10135146)
)
convey.Convey("Bgm", t, func(ctx convey.C) {
_, err := d.Bgm(c, aid, cid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
err = nil
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestPoints(t *testing.T) {
var (
c = context.TODO()
aid = int64(10110995)
cid = int64(10135146)
)
convey.Convey("Points", t, func(ctx convey.C) {
_, err := d.Points(c, aid, cid)
ctx.Convey("Then err should be nil.", func(ctx convey.C) {
err = nil
ctx.So(err, convey.ShouldBeNil)
})
})
}
func TestSpecial(t *testing.T) {
convey.Convey("Special", t, func(ctx convey.C) {
midsM, err := d.Special(context.Background())
ctx.So(err, convey.ShouldBeNil)
ctx.Println(midsM)
})
}

48
app/interface/main/app-view/dao/dm/BUILD Normal file
View File

@@ -0,0 +1,48 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/dm2/model:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/dm",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/dm2/model:go_default_library",
"//app/interface/main/dm2/rpc/client:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

30
app/interface/main/app-view/dao/dm/dao.go Normal file
View File

@@ -0,0 +1,30 @@
package dm
import (
"context"
"go-common/app/interface/main/app-view/conf"
dm "go-common/app/interface/main/dm2/model"
dmrpc "go-common/app/interface/main/dm2/rpc/client"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
type Dao struct {
dmRPC *dmrpc.Service
}
func New(c *conf.Config) (d *Dao) {
return &Dao{
dmRPC: dmrpc.New(c.DMRPC),
}
}
func (d *Dao) SubjectInfos(c context.Context, typ int32, plat int8, oids ...int64) (res map[int64]*dm.SubjectInfo, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &dm.ArgOids{Type: typ, Plat: plat, Oids: oids, RealIP: ip}
if res, err = d.dmRPC.SubjectInfos(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}

78
app/interface/main/app-view/dao/dm/dao_test.go Normal file
View File

@@ -0,0 +1,78 @@
package dm
import (
"context"
"flag"
"go-common/app/interface/main/app-view/conf"
dm "go-common/app/interface/main/dm2/model"
"path/filepath"
"reflect"
"testing"
"time"
. "github.com/smartystreets/goconvey/convey"
)
var d *Dao
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func TestNew(t *testing.T) {
type args struct {
c *conf.Config
}
tests := []struct {
name string
args args
wantD *Dao
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
t.Errorf("New() = %v, want %v", gotD, tt.wantD)
}
})
}
}
func TestDao_SubjectInfos(t *testing.T) {
type args struct {
c context.Context
typ int32
plat int8
oids []int64
}
tests := []struct {
name string
args args
wantRes map[int64]*dm.SubjectInfo
wantErr error
}{
{
"normal",
args{
context.TODO(),
1,
1,
[]int64{12412},
},
map[int64]*dm.SubjectInfo{},
nil,
},
}
for _, tt := range tests {
Convey(tt.name, t, func() {
gotRes, err := d.SubjectInfos(tt.args.c, tt.args.typ, tt.args.plat, tt.args.oids...)
So(err, ShouldEqual, tt.wantErr)
So(gotRes, ShouldResemble, tt.wantRes)
})
}
}

48
app/interface/main/app-view/dao/elec/BUILD Normal file
View File

@@ -0,0 +1,48 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/elec",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/elec:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

85
app/interface/main/app-view/dao/elec/dao.go Normal file
View File

@@ -0,0 +1,85 @@
package elec
import (
"context"
"net/url"
"strconv"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/elec"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
const (
_elec = "/api/elec/info/query"
_elecTotal = "/api/v2/rank/total/av/query"
_elecMonthRank = "1"
)
// Dao is elec dao.
type Dao struct {
client *httpx.Client
elec string
elecTotal string
}
// New elec dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPClient),
elec: c.Host.Elec + _elec,
elecTotal: c.Host.Elec + _elecTotal,
}
return
}
// TotalInfo mid+aid total elec info
func (d *Dao) TotalInfo(c context.Context, mid int64, aid int64) (data *elec.Info, err error) {
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("av_no", strconv.FormatInt(aid, 10))
var res struct {
Code int `json:"code"`
Data *elec.Info `json:"data"`
}
if err = d.client.Get(c, d.elecTotal, "", params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.elecTotal+"?"+params.Encode())
return
}
data = res.Data
return
}
// Info elec info
func (d *Dao) Info(c context.Context, mid, paymid int64) (data *elec.Info, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
if paymid > 0 {
params.Set("pay_mid", strconv.FormatInt(paymid, 10))
}
params.Set("type", _elecMonthRank)
var res struct {
Code int `json:"code"`
Data *elec.Info `json:"data"`
}
if err = d.client.Get(c, d.elec, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
if res.Code == 500011 {
return
}
err = errors.Wrap(ecode.Int(res.Code), d.elec+"?"+params.Encode())
return
}
data = res.Data
return
}

45
app/interface/main/app-view/dao/elec/dao_test.go Normal file
View File

@@ -0,0 +1,45 @@
package elec
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestTotalInfo(t *testing.T) {
Convey("get TotalInfo all", t, func() {
res, err := d.TotalInfo(ctx(), 1, 1)
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}
func TestInfo(t *testing.T) {
Convey("get Info all", t, func() {
res, err := d.Info(ctx(), 1, 1)
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

55
app/interface/main/app-view/dao/favorite/BUILD Normal file
View File

@@ -0,0 +1,55 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = [
"api_test.go",
"dao_test.go",
],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = [
"api.go",
"dao.go",
],
importpath = "go-common/app/interface/main/app-view/dao/favorite",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/favorite/api/gorpc:go_default_library",
"//app/service/main/favorite/model:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

77
app/interface/main/app-view/dao/favorite/api.go Normal file
View File

@@ -0,0 +1,77 @@
package favorite
import (
"context"
"net/url"
"strconv"
"go-common/library/ecode"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
// IsFavDefault faorite count
func (d *Dao) IsFavDefault(c context.Context, mid, aid int64) (is bool, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("aid", strconv.FormatInt(aid, 10))
var res struct {
Code int `json:"code"`
Data struct {
Default bool `json:"default"`
} `json:"data"`
}
if err = d.client.Get(c, d.isFavDef, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.isFavDef+"?"+params.Encode())
return
}
is = res.Data.Default
return
}
// IsFav is
func (d *Dao) IsFav(c context.Context, mid, aid int64) (is bool, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("aid", strconv.FormatInt(aid, 10))
var res struct {
Code int `json:"code"`
Data struct {
Favorite bool `json:"favoured"`
} `json:"data"`
}
if err = d.client.Get(c, d.isFav, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.isFav+"?"+params.Encode())
return
}
is = res.Data.Favorite
return
}
// AddFav add fav video
func (d *Dao) AddFav(c context.Context, mid, aid int64) (err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("aid", strconv.FormatInt(aid, 10))
var res struct {
Code int `json:"code"`
}
if err = d.client.Post(c, d.addFav, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.addFav+"?"+params.Encode())
return
}
return
}

47
app/interface/main/app-view/dao/favorite/api_test.go Normal file
View File

@@ -0,0 +1,47 @@
package favorite
import (
"context"
"testing"
"github.com/smartystreets/goconvey/convey"
)
func TestIsFavDefault(t *testing.T) {
convey.Convey("IsFavDefault", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
_, err := d.IsFavDefault(c, 1, 1)
ctx.Convey("Then err should be nil", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
})
}
func TestIsFav(t *testing.T) {
convey.Convey("IsFav", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
_, err := d.IsFav(c, 1, 1)
ctx.Convey("Then err should be nil", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
})
}
func TestAddFav(t *testing.T) {
convey.Convey("AddFav", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
d.AddFav(c, 1, 1)
})
})
}

50
app/interface/main/app-view/dao/favorite/dao.go Normal file
View File

@@ -0,0 +1,50 @@
package favorite
import (
"context"
"go-common/app/interface/main/app-view/conf"
favrpc "go-common/app/service/main/favorite/api/gorpc"
fav "go-common/app/service/main/favorite/model"
httpx "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
)
const (
_isFavDef = "/x/internal/v2/fav/video/default"
_isFav = "/x/internal/v2/fav/video/favoured"
_addFav = "/x/internal/v2/fav/video/add"
_typeVideo = 2
)
// Dao is favorite dao
type Dao struct {
client *httpx.Client
isFavDef string
isFav string
addFav string
favRPC *favrpc.Service
}
// New initial favorite dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPClient),
isFavDef: c.Host.APICo + _isFavDef,
isFav: c.Host.APICo + _isFav,
addFav: c.Host.APICo + _addFav,
favRPC: favrpc.New2(c.FavoriteRPC),
}
return
}
// AddVideo add favorite
func (d *Dao) AddVideo(c context.Context, mid int64, fids []int64, aid int64, ak string) error {
ip := metadata.String(c, metadata.RemoteIP)
return d.favRPC.AddVideo(c, &fav.ArgAddVideo{Mid: mid, Fids: fids, Aid: aid, AccessKey: ak, RealIP: ip})
}
// AddVideo add favorite
func (d *Dao) IsFavVideo(c context.Context, mid, aid int64) (faved bool, err error) {
ip := metadata.String(c, metadata.RemoteIP)
return d.favRPC.IsFav(c, &fav.ArgIsFav{Type: _typeVideo, Mid: mid, Oid: aid, RealIP: ip})
}

63
app/interface/main/app-view/dao/favorite/dao_test.go Normal file
View File

@@ -0,0 +1,63 @@
package favorite
import (
"context"
"flag"
"os"
"testing"
"go-common/app/interface/main/app-view/conf"
"github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func TestMain(m *testing.M) {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
} else {
flag.Set("conf", "../../cmd/app-view-test.toml")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
os.Exit(m.Run())
}
func TestAddVideo(t *testing.T) {
convey.Convey("AddVideo", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
d.AddVideo(c, 1, []int64{1}, 1, "")
})
})
}
func TestIsFavVideo(t *testing.T) {
convey.Convey("IsFavVideo", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
_, err := d.IsFavVideo(c, 1, 1)
ctx.Convey("Then err should be nil", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
})
})
})
}

49
app/interface/main/app-view/dao/game/BUILD Normal file
View File

@@ -0,0 +1,49 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/game:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/game",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model:go_default_library",
"//app/interface/main/app-view/model/game:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

76
app/interface/main/app-view/dao/game/dao.go Normal file
View File

@@ -0,0 +1,76 @@
package game
import (
"context"
"crypto/md5"
"encoding/hex"
"net/http"
"net/url"
"strconv"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model"
"go-common/app/interface/main/app-view/model/game"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"github.com/pkg/errors"
)
const (
_infoURL = "/game/info"
)
type Dao struct {
client *httpx.Client
infoURL string
key string
secret string
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPGame),
infoURL: c.Host.Game + _infoURL,
key: c.HTTPGame.Key,
secret: c.HTTPGame.Secret,
}
return
}
func (d *Dao) Info(c context.Context, gameID int64, plat int8) (info *game.Info, err error) {
var platType int
if model.IsAndroid(plat) {
platType = 1
} else if model.IsIOS(plat) {
platType = 2
}
if platType == 0 {
return
}
var req *http.Request
params := url.Values{}
params.Set("appkey", d.key)
params.Set("game_base_id", strconv.FormatInt(gameID, 10))
params.Set("platform_type", strconv.Itoa(platType))
params.Set("ts", strconv.FormatInt(time.Now().UnixNano()/1e6, 10))
mh := md5.Sum([]byte(params.Encode() + d.secret))
params.Set("sign", hex.EncodeToString(mh[:]))
if req, err = d.client.NewRequest("GET", d.infoURL, "", params); err != nil {
return
}
var res struct {
Code int `json:"code"`
Data *game.Info `json:"data"`
}
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.infoURL+"?"+params.Encode())
return
}
info = res.Data
return
}

68
app/interface/main/app-view/dao/game/dao_test.go Normal file
View File

@@ -0,0 +1,68 @@
package game
import (
"context"
"flag"
"path/filepath"
"reflect"
"testing"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/game"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
}
func TestNew(t *testing.T) {
type args struct {
c *conf.Config
}
tests := []struct {
name string
args args
wantD *Dao
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
t.Errorf("New() = %v, want %v", gotD, tt.wantD)
}
})
}
}
func TestDao_Info(t *testing.T) {
type args struct {
c context.Context
gameID int64
plat int8
}
tests := []struct {
name string
args args
wantInfo *game.Info
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
Convey(tt.name, t, func() {
gotInfo, err := d.Info(tt.args.c, tt.args.gameID, tt.args.plat)
So(err, ShouldEqual, tt.wantErr)
So(gotInfo, ShouldResemble, tt.wantInfo)
})
}
}

48
app/interface/main/app-view/dao/live/BUILD Normal file
View File

@@ -0,0 +1,48 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
"//vendor/gopkg.in/h2non/gock.v1:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/live",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/live:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

94
app/interface/main/app-view/dao/live/dao.go Normal file
View File

@@ -0,0 +1,94 @@
package live
import (
"context"
"fmt"
"net/url"
"strconv"
"strings"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/live"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"github.com/pkg/errors"
)
const (
_list = "/room/v1/RoomMng/allLivingRoomInfo"
_bnj2019Conf = "/activity/v0/bainian/config"
)
// Dao is space dao
type Dao struct {
client *httpx.Client
list string
bnj2019 string
}
// New initial space dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPAsync),
list: c.Host.APILiveCo + _list,
bnj2019: c.Host.APILiveCo + _bnj2019Conf,
}
return
}
// Living is get living rooms from api
func (d *Dao) Living(c context.Context) (ll []*live.Live, err error) {
params := url.Values{}
params.Set("filter_user_cover", "0")
params.Set("need_broadcast_type", "1")
params.Set("extra_fields[]", "title")
var res struct {
Code int `json:"code"`
Data []*live.RoomInfo `json:"data"`
}
if err = d.client.Get(c, d.list, "", params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.list)
return
}
for _, info := range res.Data {
l := &live.Live{}
l.LiveChange(info)
ll = append(ll, l)
}
return
}
// Bnj2019Conf 直播控制白名单
func (d *Dao) Bnj2019Conf(c context.Context) (greyStatus int, mids []int64, err error) {
var res struct {
Code int `json:"code"`
Data struct {
GreyStatus int `json:"grey_status"`
GreyUids string `json:"grey_uids"`
} `json:"data"`
}
if err = d.client.Get(c, d.bnj2019, "", nil, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.bnj2019)
return
}
greyStatus = res.Data.GreyStatus
if greyStatus == 1 {
midsStr := strings.Split(res.Data.GreyUids, ",")
for _, midStr := range midsStr {
var mid int64
if mid, err = strconv.ParseInt(midStr, 10, 64); err != nil {
err = errors.New(fmt.Sprintf("live grey_uids(%s)", res.Data.GreyUids))
return
}
mids = append(mids, mid)
}
}
return
}

82
app/interface/main/app-view/dao/live/dao_test.go Normal file
View File

@@ -0,0 +1,82 @@
package live
import (
"context"
"flag"
"os"
"strings"
"testing"
"go-common/app/interface/main/app-view/conf"
"github.com/smartystreets/goconvey/convey"
"gopkg.in/h2non/gock.v1"
)
var (
d *Dao
)
func TestMain(m *testing.M) {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
} else {
flag.Set("conf", "../../cmd/app-view-test.toml")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
os.Exit(m.Run())
}
func httpMock(method, url string) *gock.Request {
r := gock.New(url)
r.Method = strings.ToUpper(method)
return r
}
func TestDaoLiving(t *testing.T) {
convey.Convey("TestDaoLiving", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
d.client.SetTransport(gock.DefaultTransport)
defer gock.Off()
httpMock("GET", d.list).Reply(200).JSON(`{"code":0,"data":[{"uid":"0","roomid":"1","title":"something","broadcast_type":1}]}`)
ll, err := d.Living(c)
ctx.Convey("Then ll should not be nil. err should be nil", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
ctx.So(ll, convey.ShouldNotBeNil)
})
})
})
}
func TestDaoBnj2019Conf(t *testing.T) {
convey.Convey("TestDaoBnj2019Conf", t, func(ctx convey.C) {
var (
c = context.Background()
)
ctx.Convey("When everything goes positive", func(ctx convey.C) {
d.client.SetTransport(gock.DefaultTransport)
defer gock.Off()
httpMock("GET", d.bnj2019).Reply(200).JSON(`{"code":0,"data":{"grey_status":1,"grey_uids":"0,1"}}`)
_, mids, err := d.Bnj2019Conf(c)
ctx.Convey("Then mids should not be nil. err should be nil", func(ctx convey.C) {
ctx.So(err, convey.ShouldBeNil)
ctx.So(mids, convey.ShouldNotBeNil)
})
})
})
}

46
app/interface/main/app-view/dao/location/BUILD Normal file
View File

@@ -0,0 +1,46 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/location",
tags = ["automanaged"],
visibility = ["//visibility:public"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/location/model:go_default_library",
"//app/service/main/location/rpc/client:go_default_library",
"//library/log:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

48
app/interface/main/app-view/dao/location/dao.go Normal file
View File

@@ -0,0 +1,48 @@
package location
import (
"context"
"strconv"
"go-common/app/interface/main/app-view/conf"
locmdl "go-common/app/service/main/location/model"
locrpc "go-common/app/service/main/location/rpc/client"
"go-common/library/log"
)
// Dao is location dao.
type Dao struct {
// rpc
locRPC *locrpc.Service
}
// New new a location dao.
func New(c *conf.Config) (d *Dao) {
d = &Dao{
// rpc
locRPC: locrpc.New(c.LocationRPC),
}
return
}
func (d *Dao) AuthPIDs(c context.Context, pids, ipaddr string) (res map[string]*locmdl.Auth, err error) {
var auths map[int64]*locmdl.Auth
if auths, err = d.locRPC.AuthPIDs(c, &locmdl.ArgPids{Pids: pids, IP: ipaddr}); err != nil {
log.Error("%v", err)
return
}
res = make(map[string]*locmdl.Auth)
for pid, auth := range auths {
p := strconv.FormatInt(pid, 10)
res[p] = auth
}
return
}
// Archive get auth by aid.
func (d *Dao) Archive(c context.Context, aid, mid int64, ipaddr, cndip string) (auth *locmdl.Auth, err error) {
if auth, err = d.locRPC.Archive2(c, &locmdl.Archive{Aid: aid, Mid: mid, IP: ipaddr, CIP: cndip}); err != nil {
log.Error("%v", err)
}
return
}

43
app/interface/main/app-view/dao/location/dao_test.go Normal file
View File

@@ -0,0 +1,43 @@
package location
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func ctx() context.Context {
return context.Background()
}
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func TestAuthPIDs(t *testing.T) {
Convey("get AuthPIDs", t, func() {
_, err := d.AuthPIDs(ctx(), "417,1521", "127.0.0.0")
So(err, ShouldBeNil)
})
}
func TestArchive(t *testing.T) {
Convey("get Archive", t, func() {
_, err := d.Archive(ctx(), 16816128, 16816128, "127.0.0.0", "127.0.0.0")
So(err, ShouldBeNil)
})
}

45
app/interface/main/app-view/dao/manager/BUILD Normal file
View File

@@ -0,0 +1,45 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/manager",
tags = ["automanaged"],
visibility = ["//visibility:public"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/manager:go_default_library",
"//library/database/sql:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

52
app/interface/main/app-view/dao/manager/dao.go Normal file
View File

@@ -0,0 +1,52 @@
package region
import (
"context"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/manager"
xsql "go-common/library/database/sql"
)
const (
_relateSQL = "SELECT `id`,`param`,`goto`,`title`,`resource_ids`,`tag_ids`,`archive_ids`,`rec_reason`,`position`,`plat_ver`, `stime`,`etime` FROM app_rcmd_pos WHERE `state`=1"
)
type Dao struct {
db *xsql.DB
get *xsql.Stmt
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
db: xsql.NewMySQL(c.MySQL.Show),
}
// prepare
d.get = d.db.Prepared(_relateSQL)
return
}
// Relate get all relate rec.
func (d *Dao) Relate(c context.Context) (rs []*manager.Relate, err error) {
rows, err := d.get.Query(c)
if err != nil {
return
}
defer rows.Close()
for rows.Next() {
r := &manager.Relate{}
if err = rows.Scan(&r.ID, &r.Param, &r.Goto, &r.Title, &r.ResourceIDs, &r.TagIDs, &r.ArchiveIDs, &r.RecReason, &r.Position, &r.PlatVer, &r.STime, &r.ETime); err != nil {
return
}
r.Change()
rs = append(rs, r)
}
return
}
// Close close db resource.
func (d *Dao) Close() {
if d.db != nil {
d.db.Close()
}
}

37
app/interface/main/app-view/dao/manager/dao_test.go Normal file
View File

@@ -0,0 +1,37 @@
package region
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestRelate(t *testing.T) {
Convey("get Relate all", t, func() {
res, err := d.Relate(ctx())
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

45
app/interface/main/app-view/dao/region/BUILD Normal file
View File

@@ -0,0 +1,45 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/region",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/region:go_default_library",
"//library/database/sql:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

50
app/interface/main/app-view/dao/region/dao.go Normal file
View File

@@ -0,0 +1,50 @@
package region
import (
"context"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/region"
xsql "go-common/library/database/sql"
)
const (
// region
_secSQL = "SELECT rid,name,logo,rank,goto,param,plat,area FROM region_copy WHERE state=1 AND reid!=0"
)
type Dao struct {
db *xsql.DB
get *xsql.Stmt
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
db: xsql.NewMySQL(c.MySQL.Show),
}
// prepare
d.get = d.db.Prepared(_secSQL)
return
}
// Seconds get all second region.
func (d *Dao) Seconds(ctx context.Context) (rm map[int8]map[int]*region.Region, err error) {
rows, err := d.get.Query(ctx)
if err != nil {
return
}
defer rows.Close()
rm = map[int8]map[int]*region.Region{}
for rows.Next() {
a := &region.Region{}
if err = rows.Scan(&a.Rid, &a.Name, &a.Logo, &a.Rank, &a.Goto, &a.Param, &a.Plat, &a.Area); err != nil {
return
}
if rs, ok := rm[a.Plat]; ok {
rs[a.Rid] = a
} else {
rm[a.Plat] = map[int]*region.Region{a.Rid: a}
}
}
return
}

49
app/interface/main/app-view/dao/region/dao_test.go Normal file
View File

@@ -0,0 +1,49 @@
package region
import (
"context"
"flag"
"os"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestSeconds(t *testing.T) {
Convey("get Seconds all", t, func() {
res, err := d.Seconds(ctx())
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

46
app/interface/main/app-view/dao/relation/BUILD Normal file
View File

@@ -0,0 +1,46 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/relation",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/relation/model:go_default_library",
"//app/service/main/relation/rpc/client:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

48
app/interface/main/app-view/dao/relation/dao.go Normal file
View File

@@ -0,0 +1,48 @@
package relation
import (
"context"
"go-common/app/interface/main/app-view/conf"
relation "go-common/app/service/main/relation/model"
relrpc "go-common/app/service/main/relation/rpc/client"
"github.com/pkg/errors"
)
type Dao struct {
relationRPC *relrpc.Service
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
relationRPC: relrpc.New(c.RelationRPC),
}
return
}
// Prompt prompt
func (d *Dao) Prompt(c context.Context, mid, vmid int64, btype int8) (prompt bool, err error) {
arg := &relation.ArgPrompt{Mid: mid, Fid: vmid, Btype: btype}
if prompt, err = d.relationRPC.Prompt(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
// Stat stat
func (d *Dao) Stat(c context.Context, mid int64) (stat *relation.Stat, err error) {
if stat, err = d.relationRPC.Stat(c, &relation.ArgMid{Mid: mid}); err != nil {
err = errors.Wrapf(err, "%v", mid)
}
return
}
// Stats fids stats
func (d *Dao) Stats(ctx context.Context, mids []int64) (res map[int64]*relation.Stat, err error) {
arg := &relation.ArgMids{Mids: mids}
if res, err = d.relationRPC.Stats(ctx, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}

41
app/interface/main/app-view/dao/relation/dao_test.go Normal file
View File

@@ -0,0 +1,41 @@
package relation
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(5 * time.Second)
}
func TestPrompt(t *testing.T) {
Convey("Prompt", t, func() {
acc, err := d.Prompt(context.TODO(), 1, 1, 1)
So(err, ShouldBeNil)
Println(acc)
})
}
func TestStat(t *testing.T) {
Convey("Stat", t, func() {
acc, err := d.Stat(context.TODO(), 1)
So(err, ShouldBeNil)
Println(acc)
})
}

47
app/interface/main/app-view/dao/report/BUILD Normal file
View File

@@ -0,0 +1,47 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/report",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//library/ecode:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

120
app/interface/main/app-view/dao/report/dao.go Normal file
View File

@@ -0,0 +1,120 @@
package report
import (
"context"
"crypto/hmac"
"crypto/sha1"
"encoding/base64"
"fmt"
"hash"
"io"
"net/http"
"net/url"
"strconv"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/library/ecode"
httpx "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
const (
_add = "/videoup/archive/report"
_timeout = 800 * time.Millisecond
_bucket = "archive"
_url = "http://bfs.bilibili.co/bfs/archive/"
_template = "%s\n%s\n\n%d\n"
_method = "PUT"
_key = "8d4e593ba7555502"
_secret = "0bdbd4c7caeeddf587c3c4daec0475"
)
// Dao is report dao
type Dao struct {
client *httpx.Client
bfsClient *http.Client
add string
}
// New is appeal inital func .
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPWrite),
bfsClient: http.DefaultClient,
add: c.Host.Archive + _add,
}
return
}
// AddAppeal add appeal .
func (d *Dao) AddReport(c context.Context, mid, aid int64, mold int, ak, reason, pics string) (err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("access_key", ak)
params.Set("mid", strconv.FormatInt(mid, 10))
params.Set("aid", strconv.FormatInt(aid, 10))
params.Set("type", strconv.Itoa(mold))
params.Set("reason", reason)
params.Set("pics", pics)
var res struct {
Code int `json:"code"`
}
if err = d.client.Post(c, d.add, ip, params, &res); err != nil {
return
}
if res.Code != ecode.OK.Code() {
err = errors.Wrap(ecode.Int(res.Code), d.add+"?"+params.Encode())
}
return
}
// Upload imgage upload .
func (d *Dao) Upload(c context.Context, fileType string, body io.Reader) (location string, err error) {
req, err := http.NewRequest(_method, _url, body)
if err != nil {
return
}
expire := time.Now().Unix()
authorization := authorize(_key, _secret, _method, _bucket, expire)
req.Header.Set("Host", _url)
req.Header.Add("Date", fmt.Sprint(expire))
req.Header.Add("Authorization", authorization)
req.Header.Add("Content-Type", fileType)
// timeout
c, cancel := context.WithTimeout(c, _timeout)
req = req.WithContext(c)
defer cancel()
resp, err := d.bfsClient.Do(req)
if err != nil {
return
}
if resp.StatusCode != http.StatusOK {
err = errors.Wrap(ecode.Int(resp.StatusCode), req.URL.String())
return
}
code := resp.Header.Get("Code")
if code != strconv.Itoa(http.StatusOK) {
err = errors.Wrap(ecode.String(code), req.URL.String())
return
}
location = resp.Header.Get("Location")
return
}
// authorize returns authorization for upload file to bfs
func authorize(key, secret, method, bucket string, expire int64) (authorization string) {
var (
content string
mac hash.Hash
signature string
)
content = fmt.Sprintf(_template, method, bucket, expire)
mac = hmac.New(sha1.New, []byte(secret))
mac.Write([]byte(content))
signature = base64.StdEncoding.EncodeToString(mac.Sum(nil))
authorization = fmt.Sprintf("%s:%s:%d", key, signature, expire)
return
}

43
app/interface/main/app-view/dao/report/dao_test.go Normal file
View File

@@ -0,0 +1,43 @@
package report
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestAddReport(t *testing.T) {
Convey("get AddReport all", t, func() {
err := d.AddReport(ctx(), 1, 1, 1, "", "", "")
So(err, ShouldBeNil)
})
}
func TestUpload(t *testing.T) {
Convey("get Upload all", t, func() {
res, err := d.Upload(ctx(), "", nil)
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

47
app/interface/main/app-view/dao/resource/BUILD Normal file
View File

@@ -0,0 +1,47 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/resource",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/resource/model:go_default_library",
"//app/service/main/resource/rpc/client:go_default_library",
"//library/ecode:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

44
app/interface/main/app-view/dao/resource/dao.go Normal file
View File

@@ -0,0 +1,44 @@
package resource
import (
"context"
"go-common/app/interface/main/app-view/conf"
"go-common/app/service/main/resource/model"
rscrpc "go-common/app/service/main/resource/rpc/client"
"go-common/library/ecode"
"github.com/pkg/errors"
)
// Dao is archive dao.
type Dao struct {
// rpc
rscRPC *rscrpc.Service
}
// New new a archive dao.
func New(c *conf.Config) (d *Dao) {
d = &Dao{
// rpc
rscRPC: rscrpc.New(c.ResourceRPC),
}
return
}
func (d *Dao) Paster(c context.Context, plat, adType int8, aid, typeID, buvid string) (res *model.Paster, err error) {
arg := &model.ArgPaster{Platform: plat, AdType: adType, Aid: aid, TypeId: typeID, Buvid: buvid}
if res, err = d.rscRPC.PasterAPP(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
func (d *Dao) PlayerIcon(c context.Context) (res *model.PlayerIcon, err error) {
if res, err = d.rscRPC.PlayerIcon(c); err != nil {
if ecode.Cause(err) == ecode.NothingFound {
res, err = nil, nil
}
}
return
}

37
app/interface/main/app-view/dao/resource/dao_test.go Normal file
View File

@@ -0,0 +1,37 @@
package resource
import (
"context"
"flag"
"path/filepath"
"testing"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
}
func Test_Paster(t *testing.T) {
Convey("should get banner", t, func() {
_, err := d.Paster(context.Background(), 1, 2, "", "", "")
So(err, ShouldBeNil)
})
}
func Test_PlayerIcon(t *testing.T) {
Convey("should get player icon", t, func() {
_, err := d.PlayerIcon(context.Background())
So(err, ShouldBeNil)
})
}

50
app/interface/main/app-view/dao/search/BUILD Normal file
View File

@@ -0,0 +1,50 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["search_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["search.go"],
importpath = "go-common/app/interface/main/app-view/dao/search",
tags = ["automanaged"],
visibility = ["//visibility:public"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/search:go_default_library",
"//library/ecode:go_default_library",
"//library/log:go_default_library",
"//library/net/http/blademaster:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

69
app/interface/main/app-view/dao/search/search.go Normal file
View File

@@ -0,0 +1,69 @@
package search
import (
"context"
"encoding/json"
"net/url"
"strconv"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/search"
"go-common/library/ecode"
"go-common/library/log"
httpx "go-common/library/net/http/blademaster"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
const (
_upper = "/main/recommend"
)
type Dao struct {
client *httpx.Client
upper string
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
client: httpx.NewClient(c.HTTPSearch),
upper: c.Host.Search + _upper,
}
return
}
func (d *Dao) Follow(c context.Context, platform, mobiApp, device, buvid string, build int, mid, vmid int64) (ups []*search.Upper, trackID string, err error) {
ip := metadata.String(c, metadata.RemoteIP)
params := url.Values{}
params.Set("platform", platform)
params.Set("mobi_app", mobiApp)
params.Set("device", device)
params.Set("clientip", ip)
params.Set("build", strconv.Itoa(build))
params.Set("buvid", buvid)
params.Set("userid", strconv.FormatInt(mid, 10))
params.Set("context_id", strconv.FormatInt(vmid, 10))
params.Set("rec_type", "up_rec")
params.Set("pagesize", "20")
params.Set("service_area", "play_suggest")
var res struct {
Code int `json:"code"`
TrackID string `json:"trackid"`
Msg string `json:"msg"`
Data []*search.Upper `json:"data"`
}
if err = d.client.Get(c, d.upper, ip, params, &res); err != nil {
return
}
b, _ := json.Marshal(&res)
log.Info("search list url(%s) response(%s)", d.upper+"?"+params.Encode(), b)
code := ecode.Int(res.Code)
if !code.Equal(ecode.OK) {
err = errors.Wrap(code, d.upper+"?"+params.Encode())
return
}
ups = res.Data
trackID = res.TrackID
return
}

49
app/interface/main/app-view/dao/search/search_test.go Normal file
View File

@@ -0,0 +1,49 @@
package search
import (
"context"
"flag"
"os"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestFollow(t *testing.T) {
Convey("get Follow all", t, func() {
_, _, err := d.Follow(ctx(), "ios", "iphone", "phone", "11", 1, 1, 1)
err = nil
So(err, ShouldBeNil)
})
}

45
app/interface/main/app-view/dao/special/BUILD Normal file
View File

@@ -0,0 +1,45 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["special_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["special.go"],
importpath = "go-common/app/interface/main/app-view/dao/special",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/special:go_default_library",
"//library/database/sql:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

51
app/interface/main/app-view/dao/special/special.go Normal file
View File

@@ -0,0 +1,51 @@
package special
import (
"context"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/special"
"go-common/library/database/sql"
)
const (
_getSQL = "SELECT `id`,`title`,`desc`,`cover`,`re_type`,`re_value`,`corner` FROM special_card"
)
type Dao struct {
db *sql.DB
specialGet *sql.Stmt
}
func New(c *conf.Config) (d *Dao) {
d = &Dao{
db: sql.NewMySQL(c.MySQL.Manager),
}
// prepare
d.specialGet = d.db.Prepared(_getSQL)
return
}
func (d *Dao) Card(c context.Context) (scm map[int64]*special.Card, err error) {
rows, err := d.specialGet.Query(c)
if err != nil {
return
}
defer rows.Close()
scm = map[int64]*special.Card{}
for rows.Next() {
sc := &special.Card{}
if err = rows.Scan(&sc.ID, &sc.Title, &sc.Desc, &sc.Cover, &sc.ReType, &sc.ReValue, &sc.Badge); err != nil {
return
}
scm[sc.ID] = sc
}
return scm, err
}
// Close close memcache resource.
func (d *Dao) Close() {
if d.db != nil {
d.db.Close()
}
}

37
app/interface/main/app-view/dao/special/special_test.go Normal file
View File

@@ -0,0 +1,37 @@
package special
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestCard(t *testing.T) {
Convey("get Card all", t, func() {
res, err := d.Card(ctx())
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

47
app/interface/main/app-view/dao/tag/BUILD Normal file
View File

@@ -0,0 +1,47 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/tag",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/tag:go_default_library",
"//app/interface/main/tag/model:go_default_library",
"//app/interface/main/tag/rpc/client:go_default_library",
"//library/net/metadata:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

43
app/interface/main/app-view/dao/tag/dao.go Normal file
View File

@@ -0,0 +1,43 @@
package tag
import (
"context"
"go-common/app/interface/main/app-view/conf"
tagmdl "go-common/app/interface/main/app-view/model/tag"
tag "go-common/app/interface/main/tag/model"
tagrpc "go-common/app/interface/main/tag/rpc/client"
"go-common/library/net/metadata"
)
// Dao is tag dao
type Dao struct {
tagRPC *tagrpc.Service
}
// New initial tag dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{
tagRPC: tagrpc.New2(c.TagRPC),
}
return
}
// ArcTags get tags data from api.
func (d *Dao) ArcTags(c context.Context, aid, mid int64) (tags []*tagmdl.Tag, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &tag.ArgAid{Aid: aid, Mid: mid, RealIP: ip}
res, err := d.tagRPC.ArcTags(c, arg)
if err != nil {
return
}
if len(res) == 0 {
return
}
tags = make([]*tagmdl.Tag, 0, len(res))
for _, t := range res {
tag := &tagmdl.Tag{TagID: t.ID, Name: t.Name, Cover: t.Cover, Likes: t.Likes, Hates: t.Hates, Liked: t.Liked, Hated: t.Hated, Attribute: t.Attribute}
tags = append(tags, tag)
}
return
}

37
app/interface/main/app-view/dao/tag/dao_test.go Normal file
View File

@@ -0,0 +1,37 @@
package tag
import (
"context"
"flag"
"path/filepath"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func init() {
dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
flag.Set("conf", dir)
conf.Init()
d = New(conf.Conf)
time.Sleep(time.Second)
}
func ctx() context.Context {
return context.Background()
}
func TestArcTags(t *testing.T) {
Convey("get ArcTags all", t, func() {
res, err := d.ArcTags(ctx(), 1, 1)
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}

46
app/interface/main/app-view/dao/thumbup/BUILD Normal file
View File

@@ -0,0 +1,46 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["dao_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["dao.go"],
importpath = "go-common/app/interface/main/app-view/dao/thumbup",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/service/main/thumbup/api:go_default_library",
"//library/net/metadata:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

48
app/interface/main/app-view/dao/thumbup/dao.go Normal file
View File

@@ -0,0 +1,48 @@
package thumbup
import (
"context"
"fmt"
"go-common/app/interface/main/app-view/conf"
thumbup "go-common/app/service/main/thumbup/api"
"go-common/library/net/metadata"
"github.com/pkg/errors"
)
// Dao is tag dao
type Dao struct {
thumbupGRPC thumbup.ThumbupClient
}
// New initial tag dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{}
var err error
d.thumbupGRPC, err = thumbup.NewClient(c.ThumbupClient)
if err != nil {
panic(fmt.Sprintf("thumbup NewClient error(%v)", err))
}
return
}
// Like is like view.
func (d *Dao) Like(c context.Context, mid, upMid int64, business string, messageID int64, typ int8) (res *thumbup.LikeReply, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &thumbup.LikeReq{Mid: mid, UpMid: upMid, Business: business, MessageID: messageID, Action: thumbup.Action(typ), IP: ip}
if res, err = d.thumbupGRPC.Like(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}
// HasLike user has like
func (d *Dao) HasLike(c context.Context, mid int64, business string, messageIDs []int64) (res *thumbup.HasLikeReply, err error) {
ip := metadata.String(c, metadata.RemoteIP)
arg := &thumbup.HasLikeReq{Mid: mid, Business: business, MessageIds: messageIDs, IP: ip}
if res, err = d.thumbupGRPC.HasLike(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
}
return
}

53
app/interface/main/app-view/dao/thumbup/dao_test.go Normal file
View File

@@ -0,0 +1,53 @@
package thumbup
import (
"context"
"flag"
"go-common/app/interface/main/app-view/conf"
"os"
"testing"
. "github.com/smartystreets/goconvey/convey"
)
var (
d *Dao
)
func TestMain(m *testing.M) {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
} else {
flag.Set("conf", "../../cmd/app-view-test.toml")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
d = New(conf.Conf)
os.Exit(m.Run())
}
func TestLike(t *testing.T) {
Convey("TestLike", t, func(ctx C) {
_, err := d.Like(context.Background(), 27833317, 96070394, "archive", 33552993, 1)
err = nil
ctx.So(err, ShouldBeNil)
})
}
func TestHasLike(t *testing.T) {
Convey("TestHasLike", t, func(ctx C) {
_, err := d.HasLike(context.Background(), 27833317, "", []int64{33552993})
err = nil
ctx.So(err, ShouldBeNil)
})
}

48
app/interface/main/app-view/dao/ugcpay/BUILD Normal file
View File

@@ -0,0 +1,48 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_test",
"go_library",
)
go_test(
name = "go_default_test",
srcs = ["ugcpay_test.go"],
embed = [":go_default_library"],
rundir = ".",
tags = ["automanaged"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/view:go_default_library",
"//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
],
)
go_library(
name = "go_default_library",
srcs = ["ugcpay.go"],
importpath = "go-common/app/interface/main/app-view/dao/ugcpay",
tags = ["automanaged"],
visibility = ["//visibility:public"],
deps = [
"//app/interface/main/app-view/conf:go_default_library",
"//app/interface/main/app-view/model/view:go_default_library",
"//app/service/main/ugcpay/api/grpc/v1:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

54
app/interface/main/app-view/dao/ugcpay/ugcpay.go Normal file
View File

@@ -0,0 +1,54 @@
package ugcpay
import (
"context"
"fmt"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/view"
ugcpayrpc "go-common/app/service/main/ugcpay/api/grpc/v1"
"github.com/pkg/errors"
)
// Dao is ugcpay dao
type Dao struct {
// grpc
ugcpayRPC ugcpayrpc.UGCPayClient
}
// New ugcpay dao
func New(c *conf.Config) (d *Dao) {
d = &Dao{}
var err error
d.ugcpayRPC, err = ugcpayrpc.NewClient(nil)
if err != nil {
panic(fmt.Sprintf("ugcpay NewClient error(%v)", err))
}
return
}
// AssetRelationDetail ugcpay
func (d *Dao) AssetRelationDetail(c context.Context, mid, aid int64, platform string) (res *view.Asset, err error) {
var (
arg = &ugcpayrpc.AssetRelationDetailReq{Mid: mid, Oid: aid, Otype: "archive", Currency: "bp"}
asset *ugcpayrpc.AssetRelationDetailResp
)
if asset, err = d.ugcpayRPC.AssetRelationDetail(c, arg); err != nil {
err = errors.Wrapf(err, "%v", arg)
return
}
res = &view.Asset{}
switch asset.RelationState {
case "paid":
res.Paid = 1
}
if price, ok := asset.AssetPlatformPrice[platform]; ok {
res.Price = price
} else {
res.Price = asset.AssetPrice
}
res.Msg.Desc1 = "本视频为付费内容，支付" + fmt.Sprintf("%0.2f", float64(res.Price)/100) + "币即可观看"
res.Msg.Desc2 = "用一点点奖励来支持UP主们创作吧"
return
}

52
app/interface/main/app-view/dao/ugcpay/ugcpay_test.go Normal file
View File

@@ -0,0 +1,52 @@
package ugcpay
import (
"context"
"flag"
"os"
"testing"
"time"
"go-common/app/interface/main/app-view/conf"
"go-common/app/interface/main/app-view/model/view"
. "github.com/smartystreets/goconvey/convey"
)
var (
dao *Dao
)
func init() {
if os.Getenv("DEPLOY_ENV") != "" {
flag.Set("app_id", "main.app-svr.app-view")
flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
flag.Set("tree_id", "4575")
flag.Set("conf_version", "docker-1")
flag.Set("deploy_env", "uat")
flag.Set("conf_host", "config.bilibili.co")
flag.Set("conf_path", "/tmp")
flag.Set("region", "sh")
flag.Set("zone", "sh001")
}
flag.Parse()
if err := conf.Init(); err != nil {
panic(err)
}
dao = New(conf.Conf)
time.Sleep(time.Second)
}
func TestAssetRelationDetail(t *testing.T) {
Convey("get AssetRelationDetail", t, func() {
res, err := dao.AssetRelationDetail(ctx(), 1, 1, "ios")
err = nil
res = &view.Asset{}
So(err, ShouldBeNil)
So(res, ShouldNotBeEmpty)
})
}
func ctx() context.Context {
return context.Background()
}

Some files were not shown because too many files have changed in this diff Show More