Initial commit

app/interface/main/app-resource/BUILD

@@ -0,0 +1,54 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/interface/main/app-resource/api/v1:all-srcs",
+        "//app/interface/main/app-resource/cmd:all-srcs",
+        "//app/interface/main/app-resource/conf:all-srcs",
+        "//app/interface/main/app-resource/dao/abtest:all-srcs",
+        "//app/interface/main/app-resource/dao/ad:all-srcs",
+        "//app/interface/main/app-resource/dao/audit:all-srcs",
+        "//app/interface/main/app-resource/dao/bplus:all-srcs",
+        "//app/interface/main/app-resource/dao/broadcast:all-srcs",
+        "//app/interface/main/app-resource/dao/egg:all-srcs",
+        "//app/interface/main/app-resource/dao/location:all-srcs",
+        "//app/interface/main/app-resource/dao/module:all-srcs",
+        "//app/interface/main/app-resource/dao/notice:all-srcs",
+        "//app/interface/main/app-resource/dao/param:all-srcs",
+        "//app/interface/main/app-resource/dao/plugin:all-srcs",
+        "//app/interface/main/app-resource/dao/resource:all-srcs",
+        "//app/interface/main/app-resource/dao/sidebar:all-srcs",
+        "//app/interface/main/app-resource/dao/splash:all-srcs",
+        "//app/interface/main/app-resource/dao/tab:all-srcs",
+        "//app/interface/main/app-resource/dao/version:all-srcs",
+        "//app/interface/main/app-resource/dao/white:all-srcs",
+        "//app/interface/main/app-resource/grpc:all-srcs",
+        "//app/interface/main/app-resource/http:all-srcs",
+        "//app/interface/main/app-resource/model:all-srcs",
+        "//app/interface/main/app-resource/service/abtest:all-srcs",
+        "//app/interface/main/app-resource/service/audit:all-srcs",
+        "//app/interface/main/app-resource/service/broadcast:all-srcs",
+        "//app/interface/main/app-resource/service/domain:all-srcs",
+        "//app/interface/main/app-resource/service/guide:all-srcs",
+        "//app/interface/main/app-resource/service/module:all-srcs",
+        "//app/interface/main/app-resource/service/notice:all-srcs",
+        "//app/interface/main/app-resource/service/param:all-srcs",
+        "//app/interface/main/app-resource/service/ping:all-srcs",
+        "//app/interface/main/app-resource/service/plugin:all-srcs",
+        "//app/interface/main/app-resource/service/show:all-srcs",
+        "//app/interface/main/app-resource/service/sidebar:all-srcs",
+        "//app/interface/main/app-resource/service/splash:all-srcs",
+        "//app/interface/main/app-resource/service/static:all-srcs",
+        "//app/interface/main/app-resource/service/version:all-srcs",
+        "//app/interface/main/app-resource/service/white:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-resource/CHANGELOG.md

@@ -0,0 +1,425 @@
+#### App Resource 移动端资源管理
+
+###Version 1.6.21
+
+> 1.静态资源增加日志
+
+###Version 1.6.19
+
+> 1.静态资源修复
+
+###Version 1.6.18
+
+> 1.静态资源GRPC接口通知更新缓存
+
+###Version 1.6.17
+
+> 1.热门abtest全量开关
+
+###Version 1.6.16
+
+> 1.运营tab蓝强转粉
+
+###Version 1.6.15
+
+> 1.在线参数修改
+
+###Version 1.6.14
+
+> 1.版本更新修改
+
+###Version 1.6.13
+
+> 1.兴趣选项下线
+
+###Version 1.6.12
+
+> 1.模块接口支持多语言
+
+###Version 1.6.11
+
+> 1.doamins接口增加bfs域名列表
+
+###Version 1.6.10
+
+> 1.兴趣选择实验组修改
+
+###Version 1.6.9
+
+> 1.兴趣选择实验组修改
+
+###Version 1.6.8
+
+> 1.兴趣选择反向实验 
+
+###Version 1.6.7
+
+> 1.去掉zlimit，接入location  
+
+###Version 1.6.6
+
+> 1.海外版闪屏直接返回-304
+
+###Version 1.6.5
+
+> 1.增加conf watch
+
+###Version 1.6.4
+
+> 1.GRPC Panic
+
+###Version 1.6.3
+
+> 1.静态资源下发IsWifi
+
+###Version 1.6.2
+
+> 1.在线参数iphone蓝
+
+###Version 1.6.1
+
+> 1.蓝版全部返回双列
+
+###Version 1.6.0
+> 1.广播接口灾备
+
+###Version 1.5.38
+
+> 1.新增用户单列5%
+
+###Version 1.5.37
+
+> 1.module增加新判断
+
+###Version 1.5.36
+
+> 1.在线参数加mobi_app=biliLink
+
+###Version 1.5.35
+
+> 1.broadcast
+
+### Version 1.5.34
+
+> 1.ip方法更换
+
+### Version 1.5.33
+
+> 1.彩蛋资源修改
+
+### Version 1.5.32
+
+> 1.在线参数去掉部门筛选
+
+### Version 1.5.31
+
+> 1.abtest修改策略组名字
+
+### Version 1.5.30
+
+> 1.abtest修改策略组名字
+
+### Version 1.5.29
+
+> 1.垃圾abtest策略组
+
+### Version 1.5.28
+
+> 1.垃圾白名单需求
+
+### Version 1.5.27
+
+> 1.default_selected
+
+### Version 1.5.26
+
+> 1.broadcast长连接
+
+### Version 1.5.25
+
+> 1.正则白名单接口
+
+### Version 1.5.24
+
+> 1.首页标签聚合接口，abtest
+> 2.侧边栏
+
+### Version 1.5.23
+
+> 1.使用grpc auth
+
+### Version 1.5.22
+
+> 1.在线参数增加安卓云试听
+
+### Version 1.5.21
+> 1.abserver增加mid
+
+### Version 1.5.20
+
+> 1.老兴趣接口去除灰度
+
+### Version 1.5.19
+
+> 1.老兴趣接口buvid灰度修改
+
+### Version 1.5.18
+
+> 1.buvid灰度修改
+
+### Version 1.5.17
+
+> 1.infoc上报修改
+> 2.buvid灰度修改
+
+### Version 1.5.16
+
+> 1.新增兴趣Infoc上报
+
+### Version 1.5.15
+> 1.新增兴趣&天马单双列接口
+
+### Version 1.5.14
+
+> 1.B+白名单限制
+
+### Version 1.5.13
+
+> 1.在线参数按部门区分
+
+### Version 1.5.12
+
+> 1.静态资源缓存修改
+
+### Version 1.5.11
+
+> 1.静态资源透传字段
+
+### Version 1.5.10
+
+> 1.静态资源https
+
+### Version 1.5.10
+
+> 1.彩蛋接口增加字段
+
+### Version 1.5.9
+> 1.增加大数据abserver接口
+
+### Version 1.5.8
+
+> 1.闪屏字段修改
+> 2.error修改
+
+### Version 1.5.7
+
+> 1.闪屏增加字段
+
+### Version 1.5.6
+
+> 1.增加资源包字段
+> 2.闪屏增加字段
+
+### Version 1.5.5
+
+> 1.增量包更新
+
+### Version 1.5.4
+
+> 1.增量包更新
+
+### Version 1.5.3
+
+> 1.审核版本BUG修复
+
+### Version 1.5.2
+
+> 1.http bm
+
+### Version 1.5.1
+
+> 1.静态资源逻辑修改
+
+### Version 1.5.0
+
+> 1.新增广告闪屏
+
+### Version 1.4.9
+
+> 1.安卓云试听默认渠道不转换
+
+### Version 1.4.8
+
+> 1.安卓云试听渠道强制判断
+
+### Version 1.4.7
+
+> 1.版本灰度按buvid来区分
+
+### Version 1.4.6
+
+> 1.修复静态资源单个查询问题
+
+### Version 1.4.5
+
+> 1.修改module/list接口的verlist参数结构  
+
+### Version 1.4.4
+
+> 1.版本更新逻辑修改
+
+### Version 1.4.3
+
+> 1.静态资源的db结构又双叒叕特么要求改、返回结果结构不变(虚拟一层pink临时顶替)  
+
+### Version 1.4.2
+
+> 1.module和list接口增加过滤条件和对应判断逻辑 
+
+### Version 1.4.1
+
+> 1.静态资源暂时返回为-304
+
+### Version 1.4.0
+
+> 1.module和list接口增加过滤条件和对应判断逻辑 
+
+### Version 1.3.8
+
+> 1.静态资源暂时返回为空数据
+
+### Version 1.3.7
+
+> 1.是否感兴趣按平台buvid灰度
+
+### Version 1.3.6
+
+> 1.是否感兴趣按平台灰度
+
+### Version 1.3.5
+
+> 1.drop statsd
+
+### Version 1.3.4
+
+> 1.增加abtest的autoplay接口
+
+### Version 1.3.3
+
+> 1.静态资源池
+
+### Version 1.3.2
+
+> 1.时间戳改成秒
+> 2.增加兴趣命中统计日志
+
+### Version 1.3.1
+
+> 1.多域名管理
+
+### Version 1.3.0
+
+> 1.增加android_tv_yst(安卓TV云视听版本)
+
+### Version 1.2.9
+
+> 1.abtest安卓添加默认值
+
+### Version 1.2.8
+
+> 1.随机开关修改
+
+### Version 1.2.7
+
+> 1.随机开关
+
+### Version 1.2.6
+
+> 1.增加AndroidTV版本升级
+
+### Version 1.2.5
+
+> 1.增加版本升级日志
+
+### Version 1.2.4
+
+> 1.增加冷启动兴趣列表
+
+### Version 1.2.3
+
+> 1.静态资源
+
+### Version 1.2.2
+
+> 1.版本升级为安卓蓝做兼容
+
+### Version 1.2.1
+
+> 1.增加版本升级日志
+
+### Version 1.2.0
+
+> 1.移动端部分接口蓝版强制转成粉版
+
+### Version 1.1.9
+
+> 1.增加bilistudio 
+
+### Version 1.1.8
+
+> 1.默认闪屏每日返回一张   
+
+### Version 1.1.7
+
+> 1.侧边栏特多版本判断    
+> 2.版本管理增加安卓创作姬    
+
+### Version 1.1.6
+
+> 1.侧边栏特殊数据限制    
+
+### Version 1.1.5
+
+> 1.abtest实验组    
+> 2.topbar增加ipad顶部位置  
+
+### Version 1.1.4
+
+> 1.闪屏异步更新缓存修改   
+
+### Version 1.1.3
+
+> 1.修复闪屏并发读写缓存的bug     
+
+### Version 1.0.7
+
+> 1.随机闪屏逻辑修改     
+
+### Version 1.0.6
+> 1.修改moudle参数  
+
+### Version 1.0.5 
+> 1.增加topbar  
+
+### Version 1.0.4
+
+> 1.增加Audit    
+
+### Version 1.0.3
+
+> 1.增加闪屏    
+> 2.公告管理    
+> 3.在线参数    
+> 4.版本管理     
+
+### Version 1.0.2 
+
+> 1.侧边栏  
+
+### Version 1.0.1 
+
+> 1.插件管理  
+
+### Version 1.0.0 
+
+> 1.android侧边栏管理  

app/interface/main/app-resource/CONTRIBUTORS.md

@@ -0,0 +1,9 @@
+# Owner
+peiyifei
+liweijia
+
+# Author 
+sunyu
+
+# Reviewer
+sunyu

app/interface/main/app-resource/OWNERS

@@ -0,0 +1,14 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- liweijia
+- peiyifei
+- sunyu
+labels:
+- interface
+- interface/main/app-resource
+- main
+options:
+  no_parent_owners: true
+reviewers:
+- sunyu

app/interface/main/app-resource/README.md

@@ -0,0 +1,10 @@
+#### app-resource
+
+##### 项目简介
+> 1.提供移动端端接口
+
+##### 编译环境
+> 请使用golang v1.7.x以上版本编译执行。  
+
+##### 依赖包
+> 1.公共包go-common  

app/interface/main/app-resource/api/v1/BUILD

@@ -0,0 +1,54 @@
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+proto_library(
+    name = "v1_proto",
+    srcs = ["api.proto"],
+    tags = ["automanaged"],
+)
+
+go_proto_library(
+    name = "v1_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:go_grpc"],
+    importpath = "go-common/app/interface/main/app-resource/api/v1",
+    proto = ":v1_proto",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["client.go"],
+    embed = [":v1_go_proto"],
+    importpath = "go-common/app/interface/main/app-resource/api/v1",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/rpc/warden:go_default_library",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_x_net//context: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"],
+)

app/interface/main/app-resource/api/v1/api.pb.go

@@ -0,0 +1,426 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: app/interface/main/app-resource/api/v1/api.proto
+
+/*
+Package v1 is a generated protocol buffer package.
+
+use {app_id}.{version} as package name
+
+It is generated from these files:
+	app/interface/main/app-resource/api/v1/api.proto
+
+It has these top-level messages:
+	NoArgRequest
+	NoReply
+*/
+package v1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import context "golang.org/x/net/context"
+import grpc "google.golang.org/grpc"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+// NoArgReq
+type NoArgRequest struct {
+}
+
+func (m *NoArgRequest) Reset()                    { *m = NoArgRequest{} }
+func (m *NoArgRequest) String() string            { return proto.CompactTextString(m) }
+func (*NoArgRequest) ProtoMessage()               {}
+func (*NoArgRequest) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} }
+
+// NoReply
+type NoReply struct {
+}
+
+func (m *NoReply) Reset()                    { *m = NoReply{} }
+func (m *NoReply) String() string            { return proto.CompactTextString(m) }
+func (*NoReply) ProtoMessage()               {}
+func (*NoReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }
+
+func init() {
+	proto.RegisterType((*NoArgRequest)(nil), "app.resource.v1.NoArgRequest")
+	proto.RegisterType((*NoReply)(nil), "app.resource.v1.NoReply")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for AppResource service
+
+type AppResourceClient interface {
+	// 更新静态资源所有缓存
+	ModuleUpdateCache(ctx context.Context, in *NoArgRequest, opts ...grpc.CallOption) (*NoReply, error)
+}
+
+type appResourceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewAppResourceClient(cc *grpc.ClientConn) AppResourceClient {
+	return &appResourceClient{cc}
+}
+
+func (c *appResourceClient) ModuleUpdateCache(ctx context.Context, in *NoArgRequest, opts ...grpc.CallOption) (*NoReply, error) {
+	out := new(NoReply)
+	err := grpc.Invoke(ctx, "/app.resource.v1.AppResource/ModuleUpdateCache", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for AppResource service
+
+type AppResourceServer interface {
+	// 更新静态资源所有缓存
+	ModuleUpdateCache(context.Context, *NoArgRequest) (*NoReply, error)
+}
+
+func RegisterAppResourceServer(s *grpc.Server, srv AppResourceServer) {
+	s.RegisterService(&_AppResource_serviceDesc, srv)
+}
+
+func _AppResource_ModuleUpdateCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NoArgRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AppResourceServer).ModuleUpdateCache(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/app.resource.v1.AppResource/ModuleUpdateCache",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AppResourceServer).ModuleUpdateCache(ctx, req.(*NoArgRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _AppResource_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "app.resource.v1.AppResource",
+	HandlerType: (*AppResourceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "ModuleUpdateCache",
+			Handler:    _AppResource_ModuleUpdateCache_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "app/interface/main/app-resource/api/v1/api.proto",
+}
+
+func (m *NoArgRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *NoArgRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *NoReply) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *NoReply) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *NoArgRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *NoReply) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func sovApi(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozApi(x uint64) (n int) {
+	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *NoArgRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: NoArgRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: NoArgRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipApi(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthApi
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *NoReply) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: NoReply: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: NoReply: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipApi(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthApi
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipApi(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowApi
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowApi
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthApi
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowApi
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipApi(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowApi   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("app/interface/main/app-resource/api/v1/api.proto", fileDescriptorApi) }
+
+var fileDescriptorApi = []byte{
+	// 179 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x48, 0x2c, 0x28, 0xd0,
+	0xcf, 0xcc, 0x2b, 0x49, 0x2d, 0x4a, 0x4b, 0x4c, 0x4e, 0xd5, 0xcf, 0x4d, 0xcc, 0xcc, 0xd3, 0x4f,
+	0x2c, 0x28, 0xd0, 0x2d, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4,
+	0x2f, 0x33, 0x04, 0x51, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xfc, 0x89, 0x05, 0x05, 0x7a,
+	0x30, 0x69, 0xbd, 0x32, 0x43, 0x25, 0x3e, 0x2e, 0x1e, 0xbf, 0x7c, 0xc7, 0xa2, 0xf4, 0xa0, 0xd4,
+	0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x25, 0x4e, 0x2e, 0x76, 0xbf, 0xfc, 0xa0, 0xd4, 0x82, 0x9c, 0x4a,
+	0xa3, 0x68, 0x2e, 0x6e, 0xc7, 0x82, 0x82, 0x20, 0xa8, 0x62, 0x21, 0x1f, 0x2e, 0x41, 0xdf, 0xfc,
+	0x94, 0xd2, 0x9c, 0xd4, 0xd0, 0x82, 0x94, 0xc4, 0x92, 0x54, 0xe7, 0xc4, 0xe4, 0x8c, 0x54, 0x21,
+	0x59, 0x3d, 0x34, 0x03, 0xf5, 0x90, 0x4d, 0x93, 0x92, 0xc0, 0x22, 0x0d, 0x36, 0xdc, 0x49, 0xe0,
+	0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x8c, 0x62, 0x2a, 0x33,
+	0x4c, 0x62, 0x03, 0xbb, 0xd0, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x84, 0x2d, 0x7f, 0x25, 0xd5,
+	0x00, 0x00, 0x00,
+}

app/interface/main/app-resource/api/v1/api.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+// use {app_id}.{version} as package name
+package app.resource.v1;
+
+// specify golang package name
+option go_package = "v1";
+
+service AppResource {
+    // 更新静态资源所有缓存
+    rpc ModuleUpdateCache(NoArgRequest) returns(NoReply);
+}
+
+// NoArgReq
+message NoArgRequest{}
+// NoReply
+message NoReply{}

app/interface/main/app-resource/api/v1/client.go

@@ -0,0 +1,25 @@
+package v1
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/net/rpc/warden"
+
+	"google.golang.org/grpc"
+)
+
+// AppID .
+const AppID = "app.resource"
+
+// NewClient new grpc client
+func NewClient(cfg *warden.ClientConfig, opts ...grpc.DialOption) (AppResourceClient, error) {
+	client := warden.NewClient(cfg, opts...)
+	cc, err := client.Dial(context.Background(), fmt.Sprintf("discovery://default/%s", AppID))
+	if err != nil {
+		return nil, err
+	}
+	return NewAppResourceClient(cc), nil
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/warden/protoc.sh

app/interface/main/app-resource/cmd/BUILD

@@ -0,0 +1,64 @@
+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-resource-example.toml",
+        "app-resource-test.toml",
+    ],
+    importpath = "go-common/app/interface/main/app-resource/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/grpc:go_default_library",
+        "//app/interface/main/app-resource/http:go_default_library",
+        "//app/interface/main/app-resource/service/abtest:go_default_library",
+        "//app/interface/main/app-resource/service/audit:go_default_library",
+        "//app/interface/main/app-resource/service/broadcast:go_default_library",
+        "//app/interface/main/app-resource/service/domain:go_default_library",
+        "//app/interface/main/app-resource/service/guide:go_default_library",
+        "//app/interface/main/app-resource/service/module:go_default_library",
+        "//app/interface/main/app-resource/service/notice:go_default_library",
+        "//app/interface/main/app-resource/service/param:go_default_library",
+        "//app/interface/main/app-resource/service/ping:go_default_library",
+        "//app/interface/main/app-resource/service/plugin:go_default_library",
+        "//app/interface/main/app-resource/service/show:go_default_library",
+        "//app/interface/main/app-resource/service/sidebar:go_default_library",
+        "//app/interface/main/app-resource/service/splash:go_default_library",
+        "//app/interface/main/app-resource/service/static:go_default_library",
+        "//app/interface/main/app-resource/service/version:go_default_library",
+        "//app/interface/main/app-resource/service/white:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster/middleware/auth: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"],
+)

app/interface/main/app-resource/cmd/app-resource-example.toml

@@ -0,0 +1,98 @@
+# This is a TOML document. Boom.
+
+version = "1.0.1"
+user    = "nobody"
+pid     = "/tmp/app-resource.pid"
+dir     = "./"
+perf    = "127.0.0.1:6850"
+checkFile = "/data/www/app-resource.html"
+family = "app-resource"
+trace   = false
+debug   = true
+
+env     = "dev"
+resourceLog = ""
+tick    = "30s"
+
+[identify]
+    WhiteAccessKey = ""
+    WhiteMid = 0
+    [identify.app]
+    key = "6a29f8ed87407c11"
+    secret = "d3c5a85f5b895a03735b5d20a273bc57"
+    [identify.memcache]
+    name = "go-business/identify"
+    proto = "tcp"
+    addr = "172.16.33.54:11211"
+    active = 5
+    idle = 10
+    dialTimeout = "1s"
+    readTimeout = "1s"
+    writeTimeout = "1s"
+    idleTimeout = "80s"
+    [identify.host]
+    auth = "http://passport.bilibili.com"
+    secret = "http://open.bilibili.com"
+    [identify.authHTTPClient]
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    timer = 1000
+    [identify.secretHTTPClient]
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    timer = 1000
+
+[tracer]
+proto = "udp"
+addr  = "172.16.33.46:5140"
+tag   = "platform/app-resource"
+
+[xlog]
+dir = "/data/log/app-resource/"
+    [xlog.elk]
+    project  = "app-resource"
+    addr     = "172.18.20.17:8520"
+    chanSize = 10240
+    [xlog.syslog]
+    project  = "app-resource"
+    chanSize = 10240
+
+[app]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+
+[multiHttp]
+    [multiHttp.outer]
+    addrs     = ["0.0.0.0:6851"]
+    maxListen = 100
+    [multiHttp.local]
+    addrs     = ["0.0.0.0:6853"]
+    maxListen = 100
+
+[ecode]
+    domain = "172.16.33.248:6401"
+    all = "1h"
+    diff = "5m"
+    [ecode.clientconfig]
+        dial      = "2000ms"
+        timeout   = "2s"
+        keepAlive = "10s"
+        timer     = 128
+        [ecode.clientconfig.breaker]
+            window  ="3s"
+            sleep   ="100ms"
+            bucket  = 10
+            ratio   = 0.5
+            request = 100
+    [ecode.app]
+         key = "test"
+         secret = "e6c4c252dc7e3d8a90805eecd7c73396"
+
+[mysql]
+    [mysql.show]
+    addr   = "172.16.0.148:3306"
+    dsn    = "test:test@tcp(172.16.0.148:3306)/bilibili_show?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8mb4,utf8"
+    active = 5
+    idle   = 2

app/interface/main/app-resource/cmd/app-resource-test.toml

@@ -0,0 +1,102 @@
+
+tick    = "5m"
+
+interestJSONFile="/data/conf/app-resource/interest.json"
+staticJsonFile="/data/conf/static/static.json"
+
+[guideRandom]
+    [guideRandom.random]
+        iphone = 2
+    [guideRandom.buvid]
+        iphone = 2
+
+[host]
+ad = "http://cm.bilibili.co"
+data = "http://172.18.33.162:6193"
+
+[white]
+[white.list]
+    regex=['^(http(s)?://)?(\w+\.)?(bilibili\.(com|tv|cn)|biligame\.(com|cn)|(bilibiliyoo|im9)\.com|b23\.tv)($|/|\\)']
+
+[ABTest]
+Range = 49
+
+[duration]
+splash = "2h"
+
+[interestInfoc]
+taskID = "001229"
+proto = "tcp"
+addr = "172.19.100.20:5501"
+chanSize = 10240
+
+[httpClient]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "80ms"
+timeout   = "500ms"
+keepAlive = "60s"
+timer = 10
+[httpClient.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[log]
+dir = "/data/log/app-resource/"
+
+[app]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+
+[bm]
+    [bm.Outer]
+    addr = "0.0.0.0:6851"
+    timeout = "1s"
+
+[mysql]
+    [mysql.show]
+    addr   = "172.16.33.205:3308"
+    dsn    = "test:test@tcp(172.16.33.205:3308)/bilibili_show?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8mb4,utf8"
+    active = 5
+    idle   = 2
+    idleTimeout ="4h"
+    queryTimeout = "1s"
+    execTimeout = "1s"
+    tranTimeout = "1s"
+    [mysql.show.breaker]
+        window = "3s"
+        sleep = "100ms"
+        bucket = 10
+        ratio = 0.5
+        request = 100
+    [mysql.resource]
+	addr   = "172.16.33.205:3308"
+	dsn    = "test:test@tcp(172.16.33.205:3308)/bilibili_resource?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+	active = 5
+	idle   = 2
+    idleTimeout ="4h"
+    queryTimeout = "1s"
+    execTimeout = "1s"
+    tranTimeout = "1s"
+    [mysql.resource.breaker]
+        window = "3s"
+        sleep = "100ms"
+        bucket = 10
+        ratio = 0.5
+        request = 100
+
+[splash]
+[splash.random]
+	iphone  = ["250", "249"]
+    ipad    = ["255", "254"]
+    android = ["275", "274"]
+
+[domain]
+    addr = [
+        "app.bilibili.com",
+        "app.biliapi.net",
+        "app.bilapi.com"
+    ]

app/interface/main/app-resource/cmd/main.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/grpc"
+	"go-common/app/interface/main/app-resource/http"
+	absvr "go-common/app/interface/main/app-resource/service/abtest"
+	auditsvr "go-common/app/interface/main/app-resource/service/audit"
+	broadcastsvr "go-common/app/interface/main/app-resource/service/broadcast"
+	domainsvr "go-common/app/interface/main/app-resource/service/domain"
+	guidesvc "go-common/app/interface/main/app-resource/service/guide"
+	modulesvr "go-common/app/interface/main/app-resource/service/module"
+	"go-common/app/interface/main/app-resource/service/notice"
+	"go-common/app/interface/main/app-resource/service/param"
+	pingsvr "go-common/app/interface/main/app-resource/service/ping"
+	pluginsvr "go-common/app/interface/main/app-resource/service/plugin"
+	showsvr "go-common/app/interface/main/app-resource/service/show"
+	sidesvr "go-common/app/interface/main/app-resource/service/sidebar"
+	"go-common/app/interface/main/app-resource/service/splash"
+	staticsvr "go-common/app/interface/main/app-resource/service/static"
+	"go-common/app/interface/main/app-resource/service/version"
+	whitesvr "go-common/app/interface/main/app-resource/service/white"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster/middleware/auth"
+	"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.Log)
+	defer log.Close()
+	log.Info("app-resource start")
+	// init trace
+	trace.Init(conf.Conf.Tracer)
+	defer trace.Close()
+	// ecode init
+	ecode.Init(conf.Conf.Ecode)
+	// service init
+	svr := initService(conf.Conf)
+	http.Init(conf.Conf, svr)
+	grpcSvr, err := grpc.New(nil, svr)
+	if err != nil {
+		panic(err)
+	}
+	// 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-resource get a signal %s", s.String())
+		switch s {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+			grpcSvr.Shutdown(context.TODO())
+			log.Info("app-resource exit")
+			return
+		case syscall.SIGHUP:
+		// TODO reload
+		default:
+			return
+		}
+	}
+}
+
+// initService init services.
+func initService(c *conf.Config) (svr *http.Server) {
+	svr = &http.Server{
+		AuthSvc: auth.New(nil),
+		// init self service,
+		PgSvr:        pluginsvr.New(c),
+		PingSvr:      pingsvr.New(c),
+		SideSvr:      sidesvr.New(c),
+		VerSvc:       version.New(c),
+		ParamSvc:     param.New(c),
+		NtcSvc:       notice.New(c),
+		SplashSvc:    splash.New(c),
+		AuditSvc:     auditsvr.New(c),
+		AbSvc:        absvr.New(c),
+		ModuleSvc:    modulesvr.New(c),
+		GuideSvc:     guidesvc.New(c),
+		StaticSvc:    staticsvr.New(c),
+		DomainSvc:    domainsvr.New(c),
+		BroadcastSvc: broadcastsvr.New(c),
+		WhiteSvc:     whitesvr.New(c),
+		ShowSvc:      showsvr.New(c),
+	}
+	return
+}

app/interface/main/app-resource/conf/BUILD

@@ -0,0 +1,41 @@
+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-resource/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//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/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"],
+)

app/interface/main/app-resource/conf/conf.go

@@ -0,0 +1,170 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"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"
+	xtime "go-common/library/time"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	confPath string
+	Conf     = &Config{}
+	client   *conf.Client
+)
+
+type Config struct {
+	// Env
+	Env string
+	// show  XLog
+	Log *log.Config
+	// tick time
+	Tick xtime.Duration
+	// tracer
+	Tracer *trace.Config
+	// httpClinet
+	HTTPClient *bm.ClientConfig
+	// bm http
+	BM *HTTPServers
+	// db
+	Ecode *ecode.Config
+	MySQL *MySQL
+	// duration
+	Duration *Duration
+	// Splash
+	Splash *Splash
+	// interestJSONFile
+	InterestJSONFile string
+	// StaticJsonFile
+	StaticJSONFile string
+	// guide rand
+	GuideRandom *GuideRandom
+	// domain
+	Domain *Domain
+	ABTest *ABTest
+	// host
+	Host *Host
+	// sideBar limit id
+	SideBarLimit []int64
+	// resource
+	ResourceRPC *rpc.ClientConfig
+	// infoc2
+	InterestInfoc *infoc.Config
+	// BroadcastRPC grpc
+	BroadcastRPC *warden.ClientConfig
+	// White
+	White *White
+	// 垃圾白名单
+	ShowTabMids []int64
+	// location rpc
+	LocationRPC *rpc.ClientConfig
+	// show hot all
+	ShowHotAll bool
+	// rpc server2
+	RPCServer *rpc.ServerConfig
+}
+
+type HTTPServers struct {
+	Outer *bm.ServerConfig
+}
+
+type Host struct {
+	Ad   string
+	Data string
+	VC   string
+}
+
+type White struct {
+	List map[string][]string
+}
+
+type ABTest struct {
+	Range int
+}
+
+type GuideRandom struct {
+	Random map[string]int
+	Buvid  map[string]int
+	Feed   uint32
+}
+
+type Duration struct {
+	// splash
+	Splash string
+}
+
+type Splash struct {
+	Random map[string][]string
+}
+
+type MySQL struct {
+	Show     *sql.Config
+	Resource *sql.Config
+}
+
+type Domain struct {
+	Addr      []string
+	ImageAddr []string
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "config path")
+}
+
+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-resource.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
+}

app/interface/main/app-resource/dao/abtest/BUILD

@@ -0,0 +1,51 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["abtest_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["abtest.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/abtest",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/experiment:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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"],
+)

app/interface/main/app-resource/dao/abtest/abtest.go

@@ -0,0 +1,110 @@
+package abtest
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/experiment"
+	"go-common/library/database/sql"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_selExpLimit = `SELECT experiment_id,build,conditions FROM experiment_limit`
+	_selExpByIDs = `SELECT id,name,plat,strategy,description,traffic_group FROM experiment WHERE state=1 AND id IN (%s) ORDER BY uptime DESC`
+)
+
+// Dao is notice dao.
+type Dao struct {
+	db       *sql.DB
+	limit    *sql.Stmt
+	dataPath string
+	client   *bm.Client
+}
+
+// New new a notice dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db:       sql.NewMySQL(c.MySQL.Show),
+		client:   bm.NewClient(conf.Conf.HTTPClient),
+		dataPath: c.Host.Data + "/abserver/v1/app/match-exp",
+	}
+	d.limit = d.db.Prepared(_selExpLimit)
+	return
+}
+
+func (d *Dao) ExperimentLimit(c context.Context) (lm map[int64][]*experiment.Limit, err error) {
+	rows, err := d.limit.Query(c)
+	if err != nil {
+		log.Error("d.limit.Query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	lm = map[int64][]*experiment.Limit{}
+	for rows.Next() {
+		limit := &experiment.Limit{}
+		if err = rows.Scan(&limit.ExperimentID, &limit.Build, &limit.Condition); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			continue
+		}
+		lm[limit.ExperimentID] = append(lm[limit.ExperimentID], limit)
+	}
+	return
+}
+
+func (d *Dao) ExperimentByIDs(c context.Context, ids []int64) (eps []*experiment.Experiment, err error) {
+	rows, err := d.db.Query(c, fmt.Sprintf(_selExpByIDs, xstr.JoinInts(ids)))
+	if err != nil {
+		log.Error("d.expByIDs.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		ep := &experiment.Experiment{}
+		if err = rows.Scan(&ep.ID, &ep.Name, &ep.Plat, &ep.Strategy, &ep.Desc, &ep.TrafficGroup); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			continue
+		}
+		eps = append(eps, ep)
+	}
+	return
+}
+
+// AbServer  http://info.bilibili.co/pages/viewpage.action?pageId=8741843 大数据abtest
+func (d *Dao) AbServer(c context.Context, buvid, device, mobiAPP, filteredStr string, build int, mid int64) (res json.RawMessage, err error) {
+	params := url.Values{}
+	params.Set("buvid", buvid)
+	params.Set("device", device)
+	params.Set("mobi_app", mobiAPP)
+	params.Set("build", strconv.Itoa(build))
+	if mid > 0 {
+		params.Set("mid", strconv.FormatInt(mid, 10))
+	}
+	if filteredStr != "" {
+		params.Set("filtered", filteredStr)
+	}
+	var data struct {
+		Code int `json:"errorCode"`
+	}
+	if err = d.client.Get(c, d.dataPath, "", params, &res); err != nil {
+		return
+	}
+	if err = json.Unmarshal(res, &data); err != nil {
+		err = errors.Wrap(err, "json.Unmarshal")
+		return
+	}
+	if data.Code != ecode.OK.Code() {
+		log.Warn("code(%d) path:(%s)", data.Code, d.dataPath+params.Encode())
+		return
+	}
+	return
+}

app/interface/main/app-resource/dao/abtest/abtest_test.go

@@ -0,0 +1,59 @@
+package abtest
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-resource-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestExperimentLimit(t *testing.T) {
+	Convey("get ExperimentLimit all", t, func() {
+		res, err := d.ExperimentLimit(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestExperimentByIDs(t *testing.T) {
+	Convey("get ExperimentByIDs all", t, func() {
+		res, err := d.ExperimentByIDs(ctx(), []int64{1})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAbServer(t *testing.T) {
+	Convey("TestAbServer", t, func() {
+		res, err := d.AbServer(context.TODO(),
+			"9902822F-DDD1-47BC-A08F-19F746C9CB8459220infoc",
+			"phone",
+			"iphone",
+			"",
+			6720,
+			1,
+		)
+		Println(string(res), err)
+	})
+}

app/interface/main/app-resource/dao/ad/BUILD

@@ -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 = ["ad_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["ad.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/ad",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/splash: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",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-resource/dao/ad/ad.go

@@ -0,0 +1,121 @@
+package ad
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/splash"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_splashListURL = "/bce/api/splash/list"
+	_splashShowURL = "/bce/api/splash/show"
+)
+
+// Dao is advertising dao.
+type Dao struct {
+	client        *httpx.Client
+	splashListURL string
+	splashShowURL string
+}
+
+// New advertising dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:        httpx.NewClient(conf.Conf.HTTPClient),
+		splashListURL: c.Host.Ad + _splashListURL,
+		splashShowURL: c.Host.Ad + _splashShowURL,
+	}
+	return
+}
+
+// SplashList ad splash list
+func (d *Dao) SplashList(c context.Context, mobiApp, device, buvid, birth, adExtra string, height, width, build int, mid int64) (res []*splash.List, config *splash.CmConfig, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("build", strconv.Itoa(build))
+	params.Set("buvid", buvid)
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("ip", ip)
+	params.Set("height", strconv.Itoa(height))
+	params.Set("width", strconv.Itoa(width))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	if birth != "" {
+		params.Set("birth", birth)
+	}
+	if adExtra != "" {
+		params.Set("ad_extra", adExtra)
+	}
+	var data struct {
+		Code int `json:"code"`
+		*splash.CmConfig
+		RequestID string         `json:"request_id"`
+		Data      []*splash.List `json:"data"`
+	}
+	if err = d.client.Get(c, d.splashListURL, ip, params, &data); err != nil {
+		log.Error("cpm splash url(%s) error(%v)", d.splashListURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&data)
+	log.Info("cpm splash list url(%s) response(%s)", d.splashListURL+"?"+params.Encode(), b)
+	if data.Code != 0 {
+		err = ecode.Int(data.Code)
+		log.Error("cpm splash url(%s) code(%d)", d.splashListURL+"?"+params.Encode(), data.Code)
+		return
+	}
+	for _, t := range data.Data {
+		s := &splash.List{}
+		*s = *t
+		s.RequestID = data.RequestID
+		s.ClientIP = ip
+		s.IsAdLoc = true
+		res = append(res, s)
+	}
+	config = data.CmConfig
+	return
+}
+
+// SplashShow ad splash show
+func (d *Dao) SplashShow(c context.Context, mobiApp, device, buvid, birth, adExtra string, height, width, build int, mid int64) (res []*splash.Show, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("build", strconv.Itoa(build))
+	params.Set("buvid", buvid)
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("ip", ip)
+	params.Set("height", strconv.Itoa(height))
+	params.Set("width", strconv.Itoa(width))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	if birth != "" {
+		params.Set("birth", birth)
+	}
+	if adExtra != "" {
+		params.Set("ad_extra", adExtra)
+	}
+	var data struct {
+		Code int            `json:"code"`
+		Data []*splash.Show `json:"data"`
+	}
+	if err = d.client.Get(c, d.splashShowURL, ip, params, &data); err != nil {
+		log.Error("cpm splash url(%s) error(%v)", d.splashShowURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&data)
+	log.Info("cpm splash show url(%s) response(%s)", d.splashShowURL+"?"+params.Encode(), b)
+	if data.Code != 0 {
+		err = ecode.Int(data.Code)
+		log.Error("cpm splash url(%s) code(%d)", d.splashShowURL+"?"+params.Encode(), data.Code)
+		return
+	}
+	res = data.Data
+	return
+}

app/interface/main/app-resource/dao/ad/ad_test.go

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

app/interface/main/app-resource/dao/audit/BUILD

@@ -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 = ["audit_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["audit.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/audit",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/audit/audit.go

@@ -0,0 +1,65 @@
+package audit
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_auditSQL = "SELECT mobi_app,build FROM audit"
+)
+
+// Dao is notice dao.
+type Dao struct {
+	db    *sql.DB
+	audit *sql.Stmt
+}
+
+// New new a notice dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	d.audit = d.db.Prepared(_auditSQL)
+	return
+}
+
+// Audits get all audit build.
+func (d *Dao) Audits(ctx context.Context) (res map[string]map[int]struct{}, err error) {
+	rows, err := d.audit.Query(ctx)
+	if err != nil {
+		log.Error("query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	var (
+		mobiApp string
+		build   int
+	)
+	res = map[string]map[int]struct{}{}
+	for rows.Next() {
+		if err = rows.Scan(&mobiApp, &build); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			res = nil
+			return
+		}
+		if plat, ok := res[mobiApp]; ok {
+			plat[build] = struct{}{}
+		} else {
+			res[mobiApp] = map[int]struct{}{
+				build: struct{}{},
+			}
+		}
+	}
+	return
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-resource/dao/audit/audit_test.go

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

app/interface/main/app-resource/dao/bplus/BUILD

@@ -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 = ["bplus_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["bplus.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/bplus",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log: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"],
+)

app/interface/main/app-resource/dao/bplus/bplus.go

@@ -0,0 +1,61 @@
+package bplus
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_checkUser = "/promo_svr/v0/promo_svr/inner_user_check"
+)
+
+// Dao bplus
+type Dao struct {
+	client *httpx.Client
+	// url
+	checkUserURL string
+}
+
+// New bplus
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		// url
+		checkUserURL: c.Host.VC + _checkUser,
+	}
+	return
+}
+
+// UserCheck 动态互推入口白名单
+func (d *Dao) UserCheck(c context.Context, mid int64) (ok bool, err error) {
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Status int `json:"status"`
+		}
+	}
+	if err = d.client.Get(c, d.checkUserURL, "", params, &res); err != nil {
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("UserCheck url(%s) response(%s)", d.checkUserURL+"?"+params.Encode(), b)
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.checkUserURL+"?"+params.Encode())
+		return
+	}
+	if res.Data.Status == 1 {
+		ok = true
+	}
+	return
+}

app/interface/main/app-resource/dao/bplus/bplus_test.go

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

app/interface/main/app-resource/dao/broadcast/BUILD

@@ -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 = ["broadcast_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["broadcast.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/broadcast",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/service/main/broadcast/api/grpc/v1: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"],
+)

app/interface/main/app-resource/dao/broadcast/broadcast.go

@@ -0,0 +1,41 @@
+package broadcast
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-resource/conf"
+	pb "go-common/app/service/main/broadcast/api/grpc/v1"
+	warden "go-common/app/service/main/broadcast/api/grpc/v1"
+	wardenclient "go-common/app/service/main/broadcast/api/grpc/v1"
+	"go-common/library/log"
+)
+
+type Dao struct {
+	c *conf.Config
+	// grpc
+	rpcClient pb.ZergClient
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+	}
+	var err error
+	if d.rpcClient, err = wardenclient.NewClient(c.BroadcastRPC); err != nil {
+		panic(fmt.Sprintf("BroadcastRPC warden.NewClient error (%+v)", err))
+	}
+	return
+}
+
+// ServerList warden server list
+func (d *Dao) ServerList(ctx context.Context, platform string) (res *warden.ServerListReply, err error) {
+	arg := &warden.ServerListReq{
+		Platform: platform,
+	}
+	if res, err = d.rpcClient.ServerList(ctx, arg); err != nil {
+		log.Error("d.rpcClient.ServerList error(%v)", err)
+		return
+	}
+	return
+}

app/interface/main/app-resource/dao/broadcast/broadcast_test.go

@@ -0,0 +1,48 @@
+package broadcast
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-resource")
+		flag.Set("conf_token", "z8JNX5MFIyDxyBsqwQyF6pnjWQ5YOA14")
+		flag.Set("tree_id", "2722")
+		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 TestServerList(t *testing.T) {
+	Convey("get ServerList all", t, func() {
+		_, err := d.ServerList(ctx(), "ios")
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-resource/dao/egg/BUILD

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["egg.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/egg",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/static:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/egg/egg.go

@@ -0,0 +1,52 @@
+package egg
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/static"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_eggSQL = `SELECT e.id,ep.plat,ep.conditions,ep.build,ep.url,ep.md5,ep.size FROM egg AS e,egg_plat AS ep 
+	WHERE e.id=ep.egg_id AND e.stime<? AND e.etime>? AND e.publish=1 AND e.delete=0 AND ep.deleted=0`
+)
+
+type Dao struct {
+	db *xsql.DB
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	return
+}
+
+// Egg select all egg
+func (d *Dao) Egg(ctx context.Context, now time.Time) (res map[int8][]*static.Static, err error) {
+	res = map[int8][]*static.Static{}
+	rows, err := d.db.Query(ctx, _eggSQL, now, now)
+	if err != nil {
+		log.Error("mysqlDB.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		s := &static.Static{}
+		if err = rows.Scan(&s.Sid, &s.Plat, &s.Condition, &s.Build, &s.URL, &s.Hash, &s.Size); err != nil {
+			log.Error("egg rows.Scan error(%v)", err)
+			return
+		}
+		if s.URL == "" {
+			continue
+		}
+		s.StaticChange()
+		res[s.Plat] = append(res[s.Plat], s)
+	}
+	err = rows.Err()
+	return
+}

app/interface/main/app-resource/dao/location/BUILD

@@ -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-resource/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-resource/dao/location",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/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"],
+)

app/interface/main/app-resource/dao/location/dao.go

@@ -0,0 +1,47 @@
+package location
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/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) Info(c context.Context, ipaddr string) (info *locmdl.Info, err error) {
+	if info, err = d.locRPC.Info(c, &locmdl.ArgIP{IP: ipaddr}); err != nil {
+		log.Error("%v", err)
+	}
+	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
+}

app/interface/main/app-resource/dao/location/dao_test.go

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

app/interface/main/app-resource/dao/module/BUILD

@@ -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 = ["module_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["module.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/module",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model:go_default_library",
+        "//app/interface/main/app-resource/model/module:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/module/module.go

@@ -0,0 +1,135 @@
+package module
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/module"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_moduleDevSQL = `SELECT p.id,d.name FROM resource_department AS d,resource_pool AS p WHERE d.id=p.department_id AND d.is_deleted=0 AND p.action=1 AND p.deleted=0`
+	_moduleAllSQL = `SELECT rp.id,r.id,r.version,rp.name,rp.compresstype,rf.type,rf.url,rf.md5,rf.size,rf.file_type,rf.from_ver FROM resource_pool AS rp,resource AS r,resource_file AS rf 
+	WHERE rp.id=r.pool_id AND r.id=rf.resource_id ORDER BY rp.id ASC,r.version DESC,rf.from_ver DESC`
+	_resourceConfigSQL = `SELECT id,resource_id,stime,etime,valid,valid_test,default_package,is_wifi FROM resource_config WHERE is_deleted=0`
+	_resourceLimitSQL  = `SELECT l.config_id,l.column,l.condition,l.value FROM resource_limit AS l WHERE l.is_deleted=0`
+)
+
+// Dao is a module dao.
+type Dao struct {
+	db *sql.DB
+}
+
+// New new a module dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	return
+}
+
+// ModuleDev get modelu dev
+func (d *Dao) ModuleDev(ctx context.Context) (res map[string]*module.ResourcePool, err error) {
+	rows, err := d.db.Query(ctx, _moduleDevSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make(map[string]*module.ResourcePool)
+	for rows.Next() {
+		// NOTE: don't ask way the map key is "pink", stupid demand! fuck!!!
+		// rp := &module.ResourcePool{ID: 1, Name: "pink"}
+		r := &module.Resource{}
+		if err = rows.Scan(&r.ID, &r.Name); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		var (
+			resTmp *module.ResourcePool
+			ok     bool
+		)
+		if resTmp, ok = res[r.Name]; !ok {
+			resTmp = &module.ResourcePool{ID: r.ID, Name: r.Name}
+			res[r.Name] = resTmp
+		}
+		resTmp.Resources = append(resTmp.Resources, r)
+	}
+	return
+}
+
+// ModuleAll get module
+func (d *Dao) ModuleAll(ctx context.Context) (res map[int][]*module.Resource, err error) {
+	rows, err := d.db.Query(ctx, _moduleAllSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make(map[int][]*module.Resource)
+	for rows.Next() {
+		r := &module.Resource{}
+		if err = rows.Scan(&r.ID, &r.ResID, &r.Version, &r.Name, &r.Compresstype, &r.Type, &r.URL, &r.MD5, &r.Size, &r.Increment, &r.FromVer); err != nil {
+			log.Error("d.db.rows.Scan error(%v)", err)
+			return
+		}
+		r.URL = model.URLHTTPS(r.URL)
+		res[r.ID] = append(res[r.ID], r)
+	}
+	return
+}
+
+// ResourceCondition
+func (d *Dao) ResourceConfig(ctx context.Context) (conditions map[int]*module.Condition, err error) {
+	rows, err := d.db.Query(ctx, _resourceConfigSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	conditions = make(map[int]*module.Condition)
+	for rows.Next() {
+		var (
+			condition = &module.Condition{}
+		)
+		if err = rows.Scan(&condition.ID, &condition.ResID, &condition.STime, &condition.ETime, &condition.Valid, &condition.ValidTest, &condition.Default, &condition.IsWifi); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		conditions[condition.ResID] = condition
+	}
+	return
+}
+
+// ResourceLimit
+func (d *Dao) ResourceLimit(ctx context.Context) (columns map[int]map[string][]*module.Column, err error) {
+	rows, err := d.db.Query(ctx, _resourceLimitSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	columns = make(map[int]map[string][]*module.Column)
+	for rows.Next() {
+		var (
+			cid         int
+			column      = &module.Column{}
+			columnValue string
+			cm          map[string][]*module.Column
+			ok          bool
+		)
+		if err = rows.Scan(&cid, &columnValue, &column.Condition, &column.Value); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		if cm, ok = columns[cid]; !ok {
+			cm = make(map[string][]*module.Column)
+			columns[cid] = cm
+		}
+		cm[columnValue] = append(cm[columnValue], column)
+	}
+	return
+}

app/interface/main/app-resource/dao/module/module_test.go

@@ -0,0 +1,55 @@
+package module
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-resource")
+		flag.Set("conf_token", "z8JNX5MFIyDxyBsqwQyF6pnjWQ5YOA14")
+		flag.Set("tree_id", "2722")
+		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 TestModuleAll(t *testing.T) {
+	Convey("get module all", t, func() {
+		_, err := d.ModuleAll(ctx())
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestModuleDev(t *testing.T) {
+	Convey("get resourcePool all", t, func() {
+		_, err := d.ModuleDev(ctx())
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-resource/dao/notice/BUILD

@@ -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 = ["notice_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["notice.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/notice",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/notice:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/notice/notice.go

@@ -0,0 +1,58 @@
+package notice
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/notice"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getSQL = `SELECT id,plat,title,content,build,conditions,area,url,type,ef_time,ex_time FROM notice WHERE state=1 AND ef_time<? AND ex_time>? ORDER BY mtime DESC`
+)
+
+// Dao is notice dao.
+type Dao struct {
+	db  *sql.DB
+	get *sql.Stmt
+}
+
+// New new a notice dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	d.get = d.db.Prepared(_getSQL)
+	return
+}
+
+// GetAll get all notice data.
+func (d *Dao) All(ctx context.Context, now time.Time) (res []*notice.Notice, err error) {
+	rows, err := d.get.Query(ctx, now, now)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = []*notice.Notice{}
+	for rows.Next() {
+		b := &notice.Notice{}
+		if err = rows.Scan(&b.ID, &b.Plat, &b.Title, &b.Content, &b.Build, &b.Condition, &b.Area, &b.URI, &b.Type, &b.Start, &b.End); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			return nil, err
+
+		}
+		res = append(res, b)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-resource/dao/notice/notice_test.go

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

app/interface/main/app-resource/dao/param/BUILD

@@ -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 = ["param_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["param.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/param",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/param:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/param/param.go

@@ -0,0 +1,62 @@
+package param
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/param"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	// get param key and value
+	_getAllSQL = "SELECT name,value,plat,build,conditions FROM param WHERE state=0 AND plat!=9"
+)
+
+// Dao is a param dao.
+type Dao struct {
+	db  *sql.DB
+	get *sql.Stmt
+}
+
+// New new a param dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.get = d.db.Prepared(_getAllSQL)
+	return
+}
+
+// All get all param
+func (d *Dao) All(ctx context.Context) (m map[string][]*param.Param, err error) {
+	rows, err := d.get.Query(ctx)
+	if err != nil {
+		log.Error("d.get error(%v)", err)
+		return nil, err
+	}
+	defer rows.Close()
+	m = map[string][]*param.Param{}
+	var _key = "param_%d"
+	for rows.Next() {
+		p := &param.Param{}
+		if err = rows.Scan(&p.Name, &p.Value, &p.Plat, &p.Build, &p.Condition); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return nil, err
+		}
+		p.Change()
+		key := fmt.Sprintf(_key, p.Plat)
+		m[key] = append(m[key], p)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/interface/main/app-resource/dao/param/param_test.go

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

app/interface/main/app-resource/dao/plugin/BUILD

@@ -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 = ["plugin_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["plugin.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/plugin",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/plugin:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/plugin/plugin.go

@@ -0,0 +1,61 @@
+package plugin
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/plugin"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getSQL = "SELECT `name`,`package`,`policy`,`ver_code`,`ver_name`,`size`,`md5`,`url`,`enable`,`force`,`clear`,`min_build`,`max_build`,`base_code`,`base_name`,`desc`,`coverage` FROM plugin WHERE `enable`=1 AND `state`=0"
+)
+
+type Dao struct {
+	db        *sql.DB
+	pluginGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.pluginGet = d.db.Prepared(_getSQL)
+	return
+}
+
+func (d *Dao) All(c context.Context) (psm map[string][]*plugin.Plugin, err error) {
+	rows, err := d.pluginGet.Query(c)
+	if err != nil {
+		log.Error("query error(%v)", err)
+		return nil, err
+	}
+	defer rows.Close()
+	psm = map[string][]*plugin.Plugin{}
+	for rows.Next() {
+		p := &plugin.Plugin{}
+		if err = rows.Scan(&p.Name, &p.Package, &p.Policy, &p.VerCode, &p.VerName, &p.Size, &p.MD5, &p.URL, &p.Enable, &p.Force, &p.Clear, &p.MinBuild, &p.MaxBuild, &p.BaseCode, &p.BaseName, &p.Desc, &p.Coverage); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return nil, err
+		}
+		if p.MaxBuild != 0 && p.MaxBuild < p.MinBuild {
+			continue
+		}
+		psm[p.Name] = append(psm[p.Name], p)
+	}
+	return psm, err
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}
+
+func (dao *Dao) PingDB(c context.Context) (err error) {
+	return dao.db.Ping(c)
+}

app/interface/main/app-resource/dao/plugin/plugin_test.go

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

app/interface/main/app-resource/dao/resource/BUILD

@@ -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 = ["resource_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["resource.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/resource",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/service/main/resource/model:go_default_library",
+        "//app/service/main/resource/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"],
+)

app/interface/main/app-resource/dao/resource/resource.go

@@ -0,0 +1,46 @@
+package resource
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	resource "go-common/app/service/main/resource/model"
+	resrpc "go-common/app/service/main/resource/rpc/client"
+	"go-common/library/log"
+)
+
+type Dao struct {
+	c *conf.Config
+	// rpc
+	resRpc *resrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		// rpc
+		resRpc: resrpc.New(c.ResourceRPC),
+	}
+	return
+}
+
+// ResSideBar resource ressidebar
+func (d *Dao) ResSideBar(ctx context.Context) (res *resource.SideBars, err error) {
+	if res, err = d.resRpc.SideBars(ctx); err != nil {
+		log.Error("resource d.resRpc.SideBars error(%v)", err)
+		return
+	}
+	return
+}
+
+// AbTest resource abtest
+func (d *Dao) AbTest(ctx context.Context, groups string) (res map[string]*resource.AbTest, err error) {
+	arg := &resource.ArgAbTest{
+		Groups: groups,
+	}
+	if res, err = d.resRpc.AbTest(ctx, arg); err != nil {
+		log.Error("resource d.resRpc.AbTest error(%v)", err)
+		return
+	}
+	return
+}

app/interface/main/app-resource/dao/resource/resource_test.go

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

app/interface/main/app-resource/dao/sidebar/BUILD

@@ -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 = ["sidebar_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/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-resource/dao/sidebar",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/sidebar:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/sidebar/dao.go

@@ -0,0 +1,67 @@
+package sidebar
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/sidebar"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_initSidebarKey = "sidebar_%d_%d"
+	_selSideSQL     = `SELECT s.id,s.plat,s.module,s.name,s.logo,s.logo_white,s.param,s.rank,l.build,l.conditions,s.tip FROM 
+		sidebar AS s,sidebar_limit AS l WHERE s.state=1 AND s.id=l.s_id AND s.online_time<? ORDER BY s.rank DESC,l.id ASC`
+)
+
+type Dao struct {
+	db  *xsql.DB
+	get *xsql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	d.get = d.db.Prepared(_selSideSQL)
+	return
+}
+
+// SideBar
+func (d *Dao) SideBar(ctx context.Context, now time.Time) (ss map[string][]*sidebar.SideBar, limits map[int64][]*sidebar.Limit, err error) {
+	ss = map[string][]*sidebar.SideBar{}
+	limits = map[int64][]*sidebar.Limit{}
+	rows, err := d.get.Query(ctx, now)
+	if err != nil {
+		log.Error("mysqlDB.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		s := &sidebar.SideBar{}
+		if err = rows.Scan(&s.ID, &s.Plat, &s.Module, &s.Name, &s.Logo, &s.LogoWhite, &s.Param, &s.Rank, &s.Build, &s.Conditions, &s.Tip); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		key := fmt.Sprintf(_initSidebarKey, s.Plat, s.Module)
+		if _, ok := limits[s.ID]; !ok {
+			ss[key] = append(ss[key], s)
+		}
+		limit := &sidebar.Limit{
+			ID:        s.ID,
+			Build:     s.Build,
+			Condition: s.Conditions,
+		}
+		limits[s.ID] = append(limits[s.ID], limit)
+	}
+	return
+}
+
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/interface/main/app-resource/dao/sidebar/sidebar_test.go

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

app/interface/main/app-resource/dao/splash/BUILD

@@ -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 = ["splash_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["splash.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/splash",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/splash:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/splash/splash.go

@@ -0,0 +1,118 @@
+package splash
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/splash"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_actAllSQL = `SELECT i.splash_id,s.animate,s.duration,s.type,s.times,s.goto,s.param,s.skip,s.starttime,s.endtime,s.platform,i.url,i.hash,i.width,i.height,s.area,s.conditions,s.build,s.operate,s.no_preview FROM 
+					splash AS s, splash_image AS i WHERE s.id=i.splash_id AND s.publish=1 AND i.type=3 AND s.platform!=0 AND s.type!=2 AND s.type!=4 AND s.state=0 ORDER BY s.starttime DESC`
+	_actBirthSQL = `SELECT i.splash_id,s.animate,s.duration,s.type,s.times,s.goto,s.param,s.skip,s.starttime,s.endtime,s.platform,i.url,i.hash,i.width,i.height,s.area,s.conditions,s.build,s.operate FROM 
+					splash AS s, splash_image AS i WHERE s.id=i.splash_id AND s.publish=1 AND i.type=3 AND s.platform!=0 AND s.type=2 AND s.state=0 ORDER BY s.starttime DESC`
+	_actVipSQL = `SELECT i.splash_id,s.animate,s.duration,s.type,s.times,s.goto,s.param,s.skip,s.starttime,s.endtime,s.platform,i.url,i.hash,i.width,i.height,s.area,s.conditions,s.build,s.operate FROM 
+					splash AS s, splash_image AS i WHERE s.id=i.splash_id AND s.publish=1 AND i.type=3 AND s.platform!=0 AND s.type=4 AND s.state=0 ORDER BY s.starttime DESC`
+)
+
+// Dao is splash dao.
+type Dao struct {
+	resdb *sql.DB
+	// splash_active
+	actAll   *sql.Stmt
+	actBirth *sql.Stmt
+	actVip   *sql.Stmt
+}
+
+// New new splash dao and return.
+func New(c *conf.Config) *Dao {
+	d := &Dao{
+		resdb: sql.NewMySQL(c.MySQL.Resource),
+	}
+	// splah_active
+	d.actAll = d.resdb.Prepared(_actAllSQL)
+	d.actBirth = d.resdb.Prepared(_actBirthSQL)
+	d.actVip = d.resdb.Prepared(_actVipSQL)
+	return d
+}
+
+// GetActiveAll get all splash from table splash_active.
+func (d *Dao) ActiveAll(ctx context.Context) (res []*splash.Splash, err error) {
+	rows, err := d.actAll.Query(ctx)
+	if err != nil {
+		log.Error("dao.Exec(), err (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := &splash.Splash{}
+		if err = rows.Scan(&sp.ID, &sp.Animate, &sp.Duration, &sp.Type, &sp.Times, &sp.Goto, &sp.Param, &sp.Skip, &sp.Start,
+			&sp.End, &sp.Plat, &sp.Image, &sp.Hash, &sp.Width, &sp.Height, &sp.Area, &sp.Condition, &sp.Build, &sp.Operate, &sp.NoPreview); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			res = nil
+			return
+		}
+		sp.PlatChange()
+		if sp.Operate == 1 {
+			res = append([]*splash.Splash{sp}, res...)
+		} else {
+			res = append(res, sp)
+		}
+	}
+	return
+}
+
+// ActiveBirth from table splash and splash_image.
+func (d *Dao) ActiveBirth(ctx context.Context) (res []*splash.Splash, err error) {
+	rows, err := d.actBirth.Query(ctx)
+	if err != nil {
+		log.Error("dao.Exec(), err (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := &splash.Splash{}
+		if err = rows.Scan(&sp.ID, &sp.Animate, &sp.Duration, &sp.Type, &sp.Times, &sp.Goto, &sp.Param, &sp.Skip, &sp.Start,
+			&sp.End, &sp.Plat, &sp.Image, &sp.Hash, &sp.Width, &sp.Height, &sp.Area, &sp.Condition, &sp.Build, &sp.Operate); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			res = nil
+			return
+		}
+		sp.PlatChange()
+		sp.BirthDate()
+		res = append(res, sp)
+	}
+	return
+}
+
+// ActiveVip form table vip splash
+func (d *Dao) ActiveVip(ctx context.Context) (res []*splash.Splash, err error) {
+	rows, err := d.actVip.Query(ctx)
+	if err != nil {
+		log.Error("dao.Exec(), err (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := &splash.Splash{}
+		if err = rows.Scan(&sp.ID, &sp.Animate, &sp.Duration, &sp.Type, &sp.Times, &sp.Goto, &sp.Param, &sp.Skip, &sp.Start,
+			&sp.End, &sp.Plat, &sp.Image, &sp.Hash, &sp.Width, &sp.Height, &sp.Area, &sp.Condition, &sp.Build, &sp.Operate); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			res = nil
+			return
+		}
+		sp.PlatChange()
+		res = append(res, sp)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.resdb != nil {
+		dao.resdb.Close()
+	}
+}

app/interface/main/app-resource/dao/splash/splash_test.go

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

app/interface/main/app-resource/dao/tab/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["tab.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/tab",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/tab: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"],
+)

app/interface/main/app-resource/dao/tab/tab.go

@@ -0,0 +1,46 @@
+package tab
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/tab"
+	"go-common/library/database/sql"
+)
+
+const (
+	_getAllMenuSQL = "SELECT id,plat,name,ctype,cvalue,plat_ver,status,color,badge FROM app_menus WHERE stime<? AND etime>? AND status=1 ORDER BY `order` ASC"
+)
+
+type Dao struct {
+	db *sql.DB
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	return
+}
+
+// Menus menus tab
+func (d *Dao) Menus(c context.Context, now time.Time) (menus []*tab.Menu, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _getAllMenuSQL, now, now); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		m := &tab.Menu{}
+		if err = rows.Scan(&m.TabID, &m.Plat, &m.Name, &m.CType, &m.CValue, &m.PlatVersion, &m.Status, &m.Color, &m.Badge); err != nil {
+			return
+		}
+		if m.CValue != "" {
+			m.Change()
+			menus = append(menus, m)
+		}
+	}
+	err = rows.Err()
+	return
+}

app/interface/main/app-resource/dao/version/BUILD

@@ -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 = ["version_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["version.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/version",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model:go_default_library",
+        "//app/interface/main/app-resource/model/version:go_default_library",
+        "//library/database/sql: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"],
+)

app/interface/main/app-resource/dao/version/version.go

@@ -0,0 +1,213 @@
+package version
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/version"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	// version
+	_allSQL = "SELECT id,plat,description,version,build,ptime FROM version WHERE state=0 ORDER BY ptime DESC"
+	// version_update AND version
+	_allUpsSQL = `SELECT up.id,up.channel,up.url,up.size,up.md5,v.build,v.version,v.description,up.sdkint_list,up.model,up.policy,up.is_force,
+				up.is_push,up.policy_name,v.state,up.mtime,v.plat,up.policy_url,up.buvid_start,up.buvid_end
+					FROM version v RIGHT JOIN version_update up ON v.id=up.vid AND v.plat in(0,7,8,9,11,12) WHERE up.state=1 AND v.state!=1 AND up.url!='' ORDER BY v.build DESC`
+	_allUpsLimitSQL = `SELECT up_id,value,condi FROM version_update_limit ORDER BY value ASC`
+	_allSosSQL      = `SELECT id,package,name,description,clear,ver_code,ver_name,url,size,enable_state,force_state,md5,min_build,coverage,sdkint,model 
+					FROM version_so WHERE enable_state!=2 ORDER BY id DESC`
+	_allIncreSQL = `SELECT i.id,i.target_version,i.target_build,i.target_id,i.source_version,i.source_build,i.source_id,i.task_id,i.file_path,i.url,i.md5,i.size,v.build,v.plat
+						FROM version v RIGHT JOIN version_incremental i ON v.id=i.vid AND v.plat in(0,7,8,9,11,12) WHERE i.state=1 AND v.state!=1 AND i.url!='' ORDER BY v.build DESC`
+	_allRnSQL = `SELECT id,deployment_key,bundle_id,url,md5,size,version FROM version_rn WHERE state=1 ORDER BY ctime DESC`
+)
+
+// Dao is a version dao
+type Dao struct {
+	db     *sql.DB
+	get    *sql.Stmt
+	update *sql.Stmt
+	so     *sql.Stmt
+	incre  *sql.Stmt
+	rn     *sql.Stmt
+	limit  *sql.Stmt
+}
+
+// New new a version dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.get = d.db.Prepared(_allSQL)
+	d.update = d.db.Prepared(_allUpsSQL)
+	d.so = d.db.Prepared(_allSosSQL)
+	d.incre = d.db.Prepared(_allIncreSQL)
+	d.rn = d.db.Prepared(_allRnSQL)
+	d.limit = d.db.Prepared(_allUpsLimitSQL)
+	return
+}
+
+// GetVersion get version.
+func (d *Dao) All(ctx context.Context) (ver map[int8][]*version.Version, err error) {
+	rows, err := d.get.Query(ctx)
+	if err != nil {
+		log.Error("d.get error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[int8][]*version.Version{}
+	for rows.Next() {
+		a := &version.Version{}
+		if err = rows.Scan(&a.Id, &a.Plat, &a.Desc, &a.Version, &a.Build, &a.PTime); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		ver[a.Plat] = append(ver[a.Plat], a)
+	}
+	return
+}
+
+// GetUpdate get active version AND version_update
+func (d *Dao) Updates(ctx context.Context) (ver map[int8]map[string][]*version.VersionUpdate, err error) {
+	var (
+		masterChannel  = "master"
+		defaultChannel = "bili"
+	)
+	rows, err := d.update.Query(ctx)
+	if err != nil {
+		log.Error("d.update error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[int8]map[string][]*version.VersionUpdate{}
+	for rows.Next() {
+		a := &version.VersionUpdate{}
+		if err = rows.Scan(&a.Id, &a.Channel, &a.Url, &a.Size, &a.MD5, &a.Build, &a.Version, &a.Desc, &a.SdkInts, &a.Model, &a.Policy, &a.IsForce,
+			&a.IsPush, &a.PolicyName, &a.State, &a.Mtime, &a.Plat, &a.PolicyURL, &a.BuvidStart, &a.BuvidEnd); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		a.VersionUpdateChange()
+		if a.State == 2 {
+			a.IsGray = 1
+		} else {
+			a.IsGray = 0
+		}
+		if a.Channel == masterChannel && a.Plat != model.PlatAndroidTVYST {
+			a.Channel = defaultChannel
+		}
+		if v, ok := ver[a.Plat]; !ok {
+			ver[a.Plat] = map[string][]*version.VersionUpdate{
+				a.Channel: []*version.VersionUpdate{a},
+			}
+		} else {
+			v[a.Channel] = append(v[a.Channel], a)
+		}
+	}
+	return
+}
+
+// Limits version update limits
+func (d *Dao) Limits(ctx context.Context) (res map[int][]*version.UpdateLimit, err error) {
+	res = map[int][]*version.UpdateLimit{}
+	rows, err := d.limit.Query(ctx)
+	if err != nil {
+		log.Error("d.update error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		l := &version.UpdateLimit{}
+		if err = rows.Scan(&l.ID, &l.BuildLimit, &l.Conditions); err != nil {
+			log.Error("version update limit sql error(%v)", err)
+			return
+		}
+		res[l.ID] = append(res[l.ID], l)
+	}
+	return
+}
+
+// GetSos get version_so
+func (d *Dao) Sos(ctx context.Context) (ver map[string][]*version.VersionSo, err error) {
+	rows, err := d.so.Query(ctx)
+	if err != nil {
+		log.Error("d.so error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[string][]*version.VersionSo{}
+	for rows.Next() {
+		s := &version.VersionSo{}
+		if err = rows.Scan(&s.Id, &s.Package, &s.Name, &s.Description, &s.Clear, &s.Ver_code, &s.Ver_name, &s.Url, &s.Size, &s.Enable_state,
+			&s.Force_state, &s.Md5, &s.Min_build, &s.Coverage, &s.Sdkint, &s.Model); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		ver[s.Name] = append(ver[s.Name], s)
+	}
+	return
+}
+
+// Incrementals version incrementals
+func (d *Dao) Incrementals(ctx context.Context) (ver map[int8]map[string][]*version.Incremental, err error) {
+	rows, err := d.incre.Query(ctx)
+	if err != nil {
+		log.Error("d.incre error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[int8]map[string][]*version.Incremental{}
+	for rows.Next() {
+		v := &version.Incremental{}
+		if err = rows.Scan(&v.ID, &v.TargetVersion, &v.TargetBuild, &v.TargetID, &v.SourceVersion, &v.SourceBuild, &v.SourceID, &v.TaskID, &v.FilePath, &v.URL, &v.Md5,
+			&v.Size, &v.Build, &v.Plat); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		if vi, ok := ver[v.Plat]; !ok {
+			ver[v.Plat] = map[string][]*version.Incremental{
+				v.SourceID: []*version.Incremental{v},
+			}
+		} else {
+			vi[v.SourceID] = append(vi[v.SourceID], v)
+		}
+	}
+	return
+}
+
+// Rn version rn
+func (d *Dao) Rn(ctx context.Context) (ver map[string]map[string]*version.Rn, err error) {
+	rows, err := d.rn.Query(ctx)
+	if err != nil {
+		log.Error("d.rn error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[string]map[string]*version.Rn{}
+	for rows.Next() {
+		v := &version.Rn{}
+		if err = rows.Scan(&v.ID, &v.DeploymentKey, &v.BundleID, &v.URL, &v.Md5, &v.Size, &v.Version); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		if vi, ok := ver[v.DeploymentKey]; !ok {
+			ver[v.DeploymentKey] = map[string]*version.Rn{
+				v.Version: v,
+			}
+		} else if _, ok := vi[v.Version]; !ok {
+			vi[v.Version] = v
+		}
+	}
+	return
+}
+
+// Close close db resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-resource/dao/version/version_test.go

@@ -0,0 +1,68 @@
+package version
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/app-resource/conf"
+	"path/filepath"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestAll(t *testing.T) {
+	Convey("get all", t, func() {
+		res, err := d.All(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUpdates(t *testing.T) {
+	Convey("get Updates all", t, func() {
+		res, err := d.Updates(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestIncrementals(t *testing.T) {
+	Convey("get Incrementals all", t, func() {
+		res, err := d.Incrementals(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSos(t *testing.T) {
+	Convey("get Sos all", t, func() {
+		res, err := d.Sos(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestRn(t *testing.T) {
+	Convey("get Rn all", t, func() {
+		res, err := d.Rn(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-resource-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}

app/interface/main/app-resource/dao/white/BUILD

@@ -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 = ["white_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["white.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/white",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log: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"],
+)

app/interface/main/app-resource/dao/white/white.go

@@ -0,0 +1,53 @@
+package white
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+// Dao bplus
+type Dao struct {
+	client *httpx.Client
+}
+
+// New bplus
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+	}
+	return
+}
+
+// WhiteVerify white verify
+func (d *Dao) WhiteVerify(c context.Context, mid int64, urlStr string) (ok bool, err error) {
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Status int `json:"status"`
+		}
+	}
+	if err = d.client.Get(c, urlStr, "", params, &res); err != nil {
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("WhiteVerify url(%s) response(%s)", urlStr+"?"+params.Encode(), b)
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), urlStr+"?"+params.Encode())
+		return
+	}
+	if res.Data.Status == 1 {
+		ok = true
+	}
+	return
+}

app/interface/main/app-resource/dao/white/white_test.go

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

app/interface/main/app-resource/grpc/BUILD

@@ -0,0 +1,35 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["server.go"],
+    importpath = "go-common/app/interface/main/app-resource/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/api/v1:go_default_library",
+        "//app/interface/main/app-resource/http:go_default_library",
+        "//app/interface/main/app-resource/service/module:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/rpc/warden: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"],
+)

app/interface/main/app-resource/grpc/server.go

@@ -0,0 +1,37 @@
+package grpc
+
+import (
+	"context"
+
+	v1 "go-common/app/interface/main/app-resource/api/v1"
+	"go-common/app/interface/main/app-resource/http"
+	modulesvr "go-common/app/interface/main/app-resource/service/module"
+	"go-common/library/log"
+	"go-common/library/net/rpc/warden"
+)
+
+// Server struct
+type Server struct {
+	moduleSvc *modulesvr.Service
+}
+
+// New Coin warden rpc server
+func New(c *warden.ServerConfig, svr *http.Server) (wsvr *warden.Server, err error) {
+	wsvr = warden.NewServer(c)
+	v1.RegisterAppResourceServer(wsvr.Server(), &Server{
+		moduleSvc: svr.ModuleSvc,
+	})
+	wsvr, err = wsvr.Start()
+	return
+}
+
+// ModuleUpdateCache update module cache
+func (s *Server) ModuleUpdateCache(c context.Context, noArg *v1.NoArgRequest) (noReply *v1.NoReply, err error) {
+	if err = s.moduleSvc.ModuleUpdateCache(); err != nil {
+		log.Error("ModuleUpdateCache error(%v)", err)
+		return
+	}
+	noReply = &v1.NoReply{}
+	log.Info("ModuleUpdateCache load cache success")
+	return
+}

app/interface/main/app-resource/http/BUILD

@@ -0,0 +1,73 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "abtest.go",
+        "audit.go",
+        "broadcast.go",
+        "domain.go",
+        "http.go",
+        "interest.go",
+        "local.go",
+        "module.go",
+        "notice.go",
+        "param.go",
+        "plugin.go",
+        "show.go",
+        "sidebar.go",
+        "splash.go",
+        "static.go",
+        "version.go",
+        "white.go",
+    ],
+    importpath = "go-common/app/interface/main/app-resource/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model:go_default_library",
+        "//app/interface/main/app-resource/model/module:go_default_library",
+        "//app/interface/main/app-resource/model/version:go_default_library",
+        "//app/interface/main/app-resource/service/abtest:go_default_library",
+        "//app/interface/main/app-resource/service/audit:go_default_library",
+        "//app/interface/main/app-resource/service/broadcast:go_default_library",
+        "//app/interface/main/app-resource/service/domain:go_default_library",
+        "//app/interface/main/app-resource/service/guide:go_default_library",
+        "//app/interface/main/app-resource/service/module:go_default_library",
+        "//app/interface/main/app-resource/service/notice:go_default_library",
+        "//app/interface/main/app-resource/service/param:go_default_library",
+        "//app/interface/main/app-resource/service/ping:go_default_library",
+        "//app/interface/main/app-resource/service/plugin:go_default_library",
+        "//app/interface/main/app-resource/service/show:go_default_library",
+        "//app/interface/main/app-resource/service/sidebar:go_default_library",
+        "//app/interface/main/app-resource/service/splash:go_default_library",
+        "//app/interface/main/app-resource/service/static:go_default_library",
+        "//app/interface/main/app-resource/service/version:go_default_library",
+        "//app/interface/main/app-resource/service/white:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/auth:go_default_library",
+        "@com_github_golang_protobuf//proto: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"],
+)

app/interface/main/app-resource/http/abtest.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func abTest(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(abSvc.Experiment(c, plat, build), nil)
+}
+
+func abTestV2(c *bm.Context) {
+	params := c.Request.Form
+	buvid := params.Get("buvid")
+	if buvid == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(abSvc.TemporaryABTests(c, buvid), nil)
+}
+
+func abserver(c *bm.Context) {
+	params := c.Request.Form
+	buvid := params.Get("buvid")
+	device := params.Get("device")
+	mobiAPP := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	filteredStr := params.Get("filtered")
+	if buvid == "" || device == "" || mobiAPP == "" || buildStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(abSvc.AbServer(c, buvid, device, mobiAPP, filteredStr, build, mid))
+}

app/interface/main/app-resource/http/audit.go

@@ -0,0 +1,22 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func audit(c *bm.Context) {
+	params := c.Request.Form
+	buildStr := params.Get("build")
+	mobiApp := params.Get("mobi_app")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("stronv.ParseInt(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, auditSvc.Audit(c, mobiApp, build))
+}

app/interface/main/app-resource/http/broadcast.go

@@ -0,0 +1,14 @@
+package http
+
+import (
+	"go-common/app/interface/main/app-resource/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func serverList(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	c.JSON(broadcastSvc.ServerList(c, plat))
+}

app/interface/main/app-resource/http/domain.go

@@ -0,0 +1,7 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func domain(c *bm.Context) {
+	c.JSON(domainSvc.Domain(), nil)
+}

app/interface/main/app-resource/http/http.go

@@ -0,0 +1,158 @@
+package http
+
+import (
+	"go-common/app/interface/main/app-resource/conf"
+	absvr "go-common/app/interface/main/app-resource/service/abtest"
+	auditsvr "go-common/app/interface/main/app-resource/service/audit"
+	broadcastsvr "go-common/app/interface/main/app-resource/service/broadcast"
+	domainsvr "go-common/app/interface/main/app-resource/service/domain"
+	guidesvc "go-common/app/interface/main/app-resource/service/guide"
+	modulesvr "go-common/app/interface/main/app-resource/service/module"
+	"go-common/app/interface/main/app-resource/service/notice"
+	"go-common/app/interface/main/app-resource/service/param"
+	pingsvr "go-common/app/interface/main/app-resource/service/ping"
+	pluginsvr "go-common/app/interface/main/app-resource/service/plugin"
+	showsvr "go-common/app/interface/main/app-resource/service/show"
+	sidesvr "go-common/app/interface/main/app-resource/service/sidebar"
+	"go-common/app/interface/main/app-resource/service/splash"
+	staticsvr "go-common/app/interface/main/app-resource/service/static"
+	"go-common/app/interface/main/app-resource/service/version"
+	whitesvr "go-common/app/interface/main/app-resource/service/white"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/auth"
+)
+
+var (
+	// depend service
+	authSvc *auth.Auth
+	// self service
+	pgSvr        *pluginsvr.Service
+	pingSvr      *pingsvr.Service
+	sideSvr      *sidesvr.Service
+	verSvc       *version.Service
+	paramSvc     *param.Service
+	ntcSvc       *notice.Service
+	splashSvc    *splash.Service
+	auditSvc     *auditsvr.Service
+	abSvc        *absvr.Service
+	moduleSvc    *modulesvr.Service
+	guideSvc     *guidesvc.Service
+	staticSvc    *staticsvr.Service
+	domainSvc    *domainsvr.Service
+	whiteSvc     *whitesvr.Service
+	showSvc      *showsvr.Service
+	broadcastSvc *broadcastsvr.Service
+)
+
+type Server struct {
+	// depend service
+	AuthSvc *auth.Auth
+	// self service
+	PgSvr        *pluginsvr.Service
+	PingSvr      *pingsvr.Service
+	SideSvr      *sidesvr.Service
+	VerSvc       *version.Service
+	ParamSvc     *param.Service
+	NtcSvc       *notice.Service
+	SplashSvc    *splash.Service
+	AuditSvc     *auditsvr.Service
+	AbSvc        *absvr.Service
+	ModuleSvc    *modulesvr.Service
+	GuideSvc     *guidesvc.Service
+	StaticSvc    *staticsvr.Service
+	DomainSvc    *domainsvr.Service
+	WhiteSvc     *whitesvr.Service
+	ShowSvc      *showsvr.Service
+	BroadcastSvc *broadcastsvr.Service
+}
+
+// Init is
+func Init(c *conf.Config, svr *Server) {
+	initService(c, svr)
+	// init external router
+	engineOut := bm.DefaultServer(c.BM.Outer)
+	outerRouter(engineOut)
+	// init Outer server
+	if err := engineOut.Start(); err != nil {
+		log.Error("engineOut.Start() error(%v) | config(%v)", err, c)
+		panic(err)
+	}
+}
+
+// initService init services.
+func initService(c *conf.Config, svr *Server) {
+	// init self service
+	authSvc = svr.AuthSvc
+	pgSvr = svr.PgSvr
+	pingSvr = svr.PingSvr
+	sideSvr = svr.SideSvr
+	verSvc = svr.VerSvc
+	paramSvc = svr.ParamSvc
+	ntcSvc = svr.NtcSvc
+	splashSvc = svr.SplashSvc
+	auditSvc = svr.AuditSvc
+	abSvc = svr.AbSvc
+	moduleSvc = svr.ModuleSvc
+	guideSvc = svr.GuideSvc
+	staticSvc = svr.StaticSvc
+	domainSvc = svr.DomainSvc
+	broadcastSvc = svr.BroadcastSvc
+	whiteSvc = svr.WhiteSvc
+	showSvc = svr.ShowSvc
+}
+
+// outerRouter init outer router api path.
+func outerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	r := e.Group("/x/resource")
+	{
+		r.GET("/plugin", plugin)
+		r.GET("/sidebar", authSvc.GuestMobile, sidebar)
+		r.GET("/topbar", topbar)
+		r.GET("/abtest", abTest)
+		r.GET("/abtest/v2", abTestV2)
+		r.GET("/abtest/abserver", authSvc.GuestMobile, abserver)
+		m := r.Group("/module")
+		{
+			m.POST("", module)
+			m.POST("/list", list)
+		}
+		g := r.Group("/guide", authSvc.GuestMobile)
+		{
+			g.GET("/interest", interest)
+			g.GET("/interest2", interest2)
+		}
+		r.GET("/static", getStatic)
+		r.GET("/domain", domain)
+		r.GET("/broadcast/servers", serverList)
+		r.GET("/white/list", whiteList)
+		r.GET("/show/tab", authSvc.GuestMobile, tabs)
+	}
+	v := e.Group("/x/v2/version")
+	{
+		v.GET("", getVersion)
+		v.GET("/update", versionUpdate)
+		v.GET("/update.pb", versionUpdatePb)
+		v.GET("/so", versionSo)
+		v.GET("/rn/update", versionRn)
+	}
+	p := e.Group("/x/v2/param", authSvc.GuestMobile)
+	{
+		p.GET("", getParam)
+	}
+	n := e.Group("/x/v2/notice", authSvc.GuestMobile)
+	{
+		n.GET("", getNotice)
+	}
+	s := e.Group("/x/v2/splash")
+	{
+		s.GET("", splashs)
+		s.GET("/birthday", birthSplash)
+		s.GET("/list", authSvc.GuestMobile, splashList)
+	}
+	a := e.Group("/x/v2/audit")
+	{
+		a.GET("", audit)
+	}
+}

app/interface/main/app-resource/http/interest.go

@@ -0,0 +1,48 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_headerBuvid    = "Buvid"
+	_headerDeviceID = "Device-ID"
+)
+
+// interest get interest list
+func interest(c *bm.Context) {
+	var (
+		header = c.Request.Header
+		params = c.Request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	buvid := header.Get(_headerBuvid)
+	c.JSON(guideSvc.Interest(mobiApp, buvid, time.Now()), nil)
+}
+
+// interest2 get interest list
+func interest2(c *bm.Context) {
+	var (
+		header = c.Request.Header
+		params = c.Request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	buildStr := params.Get("build")
+	buvid := header.Get(_headerBuvid)
+	if buvid == "" || len(buvid) <= 5 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dvcid := header.Get(_headerDeviceID)
+	c.JSON(guideSvc.Interest2(mobiApp, device, dvcid, buvid, build, time.Now()), nil)
+}

app/interface/main/app-resource/http/local.go

@@ -0,0 +1,17 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	var err error
+	if err = pingSvr.Ping(c); err != nil {
+		log.Error("app-resource service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/interface/main/app-resource/http/module.go

@@ -0,0 +1,83 @@
+package http
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+
+	mdl "go-common/app/interface/main/app-resource/model/module"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func list(c *bm.Context) {
+	var (
+		params                            = c.Request.Form
+		build, sysver, level, scale, arch int
+		err                               error
+		env                               string
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	platform := params.Get("platform")
+	env = params.Get("env")
+	if env != mdl.EnvRelease && env != mdl.EnvTest && env != mdl.EnvDefault {
+		env = mdl.EnvRelease
+	}
+	build, _ = strconv.Atoi(params.Get("build"))
+	sysver, _ = strconv.Atoi(params.Get("sysver"))
+	level, _ = strconv.Atoi(params.Get("level"))
+	scale, _ = strconv.Atoi(params.Get("scale"))
+	arch, _ = strconv.Atoi(params.Get("arch"))
+	rPoolName := params.Get("resource_pool_name")
+	// NOTE: don't ask way rPoolName coded "pink", idiot demand! fuck!!!
+	// rPoolName := "pink"
+	// params
+	verlist := params.Get("verlist")
+	var versions []*mdl.Versions
+	if verlist != "" {
+		if err = json.Unmarshal([]byte(verlist), &versions); err != nil {
+			log.Error("http list() json.Unmarshal(%s) mobile_app(%s) device(%s) build(%d) error(%v)", verlist, mobiApp, device, build, err)
+		}
+	}
+	data := moduleSvc.List(c, mobiApp, device, platform, rPoolName, env, build, sysver, level, scale, arch, versions, time.Now())
+	c.JSON(data, nil)
+}
+
+func module(c *bm.Context) {
+	var (
+		params                            = c.Request.Form
+		build, sysver, level, scale, arch int
+		err                               error
+		env                               string
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	platform := params.Get("platform")
+	env = params.Get("env")
+	if env != mdl.EnvRelease && env != mdl.EnvTest && env != mdl.EnvDefault {
+		env = mdl.EnvRelease
+	}
+	build, _ = strconv.Atoi(params.Get("build"))
+	sysver, _ = strconv.Atoi(params.Get("sysver"))
+	level, _ = strconv.Atoi(params.Get("level"))
+	scale, _ = strconv.Atoi(params.Get("scale"))
+	arch, _ = strconv.Atoi(params.Get("arch"))
+	rPoolName := params.Get("resource_pool_name")
+	// NOTE: don't ask way rPoolName coded "pink", idiot demand! fuck!!!
+	// rPoolName := "pink"
+	rName := params.Get("resource_name")
+	verStr := params.Get("ver")
+	ver, _ := strconv.Atoi(verStr)
+	if rPoolName == "" || rName == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data, err := moduleSvc.Resource(c, mobiApp, device, platform, rPoolName, rName, env, ver, build, sysver, level, scale, arch, time.Now())
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}

app/interface/main/app-resource/http/notice.go

@@ -0,0 +1,37 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// getNotice get notice data.
+func getNotice(c *bm.Context) {
+	params := c.Request.Form
+	ver := params.Get("ver")
+	buildStr := params.Get("build")
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	typeStr := params.Get("type")
+	// check params
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("stronv.ParseInt(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	typeInt, _ := strconv.Atoi(typeStr)
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	// get
+	data, version, err := ntcSvc.Notice(c, plat, build, typeInt, ver)
+	res := map[string]interface{}{
+		"data": data,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/param.go

@@ -0,0 +1,47 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// getParam get param data.
+func getParam(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	platStr := params.Get("plat")
+	ver := params.Get("ver")
+	buildStr := params.Get("build")
+	// check params
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("stronv.ParseInt(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var plat int8
+	if mobiApp != "" {
+		device := params.Get("device")
+		plat = model.Plat(mobiApp, device)
+	} else if platStr != "" { // android have not mobi_app when 4.18
+		var platInt int64
+		platInt, err = strconv.ParseInt(platStr, 10, 64)
+		if err != nil {
+			log.Error("stronv.ParseInt(%s) error(%v)", platStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		plat = int8(platInt)
+	}
+	// service
+	data, version, err := paramSvc.Param(plat, build, ver)
+	res := map[string]interface{}{
+		"data": data,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/plugin.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func plugin(c *bm.Context) {
+	var (
+		params   = c.Request.Form
+		build    int
+		baseCode int
+		seed     int
+		err      error
+	)
+	name := params.Get("name")
+	buildStr := params.Get("build")
+	baseCodeStr := params.Get("base_code")
+	seedStr := params.Get("seed")
+	if build, err = strconv.Atoi(buildStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if seed, err = strconv.Atoi(seedStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if baseCode, err = strconv.Atoi(baseCodeStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pg := pgSvr.Plugin(build, baseCode, seed, name); pg != nil {
+		c.JSON(pg, nil)
+	} else {
+		c.JSON(struct{}{}, nil)
+	}
+
+}

app/interface/main/app-resource/http/show.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func tabs(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		header = c.Request.Header
+		res    = map[string]interface{}{}
+	)
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	buvid := header.Get(_headerBuvid)
+	device := params.Get("device")
+	verStr := params.Get("ver")
+	language := params.Get("lang")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	data, version, ab, err := showSvc.Tabs(c, plat, build, buvid, verStr, mobiApp, language, mid)
+	if ab != nil {
+		res["abtest"] = ab
+	}
+	res["data"] = data
+	res["ver"] = version
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/sidebar.go

@@ -0,0 +1,67 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func sidebar(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		module int
+		mid    int64
+	)
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	device := params.Get("device")
+	language := params.Get("lang")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	switch plat {
+	case model.PlatAndroid, model.PlatAndroidG, model.PlatAndroidB, model.PlatAndroidI:
+		module = 1
+	case model.PlatIPhone, model.PlatIPhoneI, model.PlatIPhoneB:
+		module = 3
+	}
+	c.JSON(sideSvr.SideBar(c, plat, build, module, mid, language), nil)
+}
+
+func topbar(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		module int
+		mid    int64
+	)
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	device := params.Get("device")
+	language := params.Get("lang")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	switch plat {
+	case model.PlatAndroid, model.PlatAndroidG, model.PlatAndroidB, model.PlatAndroidI:
+		module = 2
+	case model.PlatIPhone, model.PlatIPhoneI, model.PlatIPhoneB:
+		module = 4
+	case model.PlatIPad, model.PlatIPadI:
+		module = 5
+	}
+	c.JSON(sideSvr.SideBar(c, plat, build, module, mid, language), nil)
+}

app/interface/main/app-resource/http/splash.go

@@ -0,0 +1,120 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// splashs splash handler
+func splashs(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	widthStr := params.Get("width")
+	heightStr := params.Get("height")
+	buildStr := params.Get("build")
+	channel := params.Get("channel")
+	ver := params.Get("ver")
+	// check params
+	width, err := strconv.Atoi(widthStr)
+	if err != nil {
+		log.Error("width(%s) is invalid", widthStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	height, err := strconv.Atoi(heightStr)
+	if err != nil {
+		log.Error("height(%s) is invalid", heightStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, _ := strconv.Atoi(buildStr)
+	device := params.Get("device")
+	var plat int8
+	if mobiApp != "" {
+		plat = model.Plat(mobiApp, device)
+	} else {
+		plat = model.PlatAndroid
+	}
+	result, version, err := splashSvc.Display(c, plat, width, height, int(build), channel, ver, time.Now())
+	res := map[string]interface{}{
+		"data": result,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}
+
+func birthSplash(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	widthStr := params.Get("width")
+	heightStr := params.Get("height")
+	year := params.Get("year")
+	birth := params.Get("birth")
+	if year == "1930" && birth == "0101" {
+		log.Error("birth day is empty(%s,%s)", year, birth)
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	// check params
+	width, err := strconv.Atoi(widthStr)
+	if err != nil {
+		log.Error("width(%s) is invalid", widthStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	height, err := strconv.Atoi(heightStr)
+	if err != nil {
+		log.Error("height(%s) is invalid", heightStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	result, err := splashSvc.Birthday(c, plat, width, height, birth)
+	c.JSON(result, err)
+}
+
+// splashList ad splash handler
+func splashList(c *bm.Context) {
+	var (
+		header = c.Request.Header
+		params = c.Request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	widthStr := params.Get("width")
+	heightStr := params.Get("height")
+	buildStr := params.Get("build")
+	birth := params.Get("birth")
+	adExtra := params.Get("ad_extra")
+	device := params.Get("device")
+	// check params
+	width, err := strconv.Atoi(widthStr)
+	if err != nil {
+		log.Error("width(%s) is invalid", widthStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	height, err := strconv.Atoi(heightStr)
+	if err != nil {
+		log.Error("height(%s) is invalid", heightStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, _ := strconv.Atoi(buildStr)
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	buvid := header.Get(_headerBuvid)
+	plat := model.Plat(mobiApp, device)
+	result, err := splashSvc.AdList(c, plat, mobiApp, device, buvid, birth, adExtra, height, width, build, mid)
+	c.JSON(result, err)
+}

app/interface/main/app-resource/http/static.go

@@ -0,0 +1,32 @@
+package http
+
+import (
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"strconv"
+	"time"
+)
+
+// getStatic get static
+func getStatic(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	ver := params.Get("ver")
+	buildStr := params.Get("build")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("build(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	plat := model.Plat(mobiApp, device)
+	data, version, err := staticSvc.Static(plat, build, ver, time.Now())
+	res := map[string]interface{}{
+		"data": data,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/version.go

@@ -0,0 +1,137 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/version"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+
+	"github.com/golang/protobuf/proto"
+)
+
+// getVersion get version
+func getVersion(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	data, err := verSvc.Version(plat)
+	c.JSON(data, err)
+}
+
+// versionUpdate get versionUpdate
+func versionUpdate(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		header = c.Request.Header
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	buildStr := params.Get("build")
+	channel := params.Get("channel")
+	sdkStr := params.Get("sdkint")
+	platModel := params.Get("model")
+	oldID := params.Get("old_id")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	buvid := header.Get(_headerBuvid)
+	// mobiApp not equal to android or mobiApp is null,default android
+	if !model.IsAndroid(plat) {
+		plat = model.PlatAndroid
+	}
+	if (plat == model.PlatAndroid) && (build >= 591000 && build <= 599000) {
+		plat = model.PlatAndroidB
+	}
+	data, err := verSvc.VersionUpdate(build, plat, buvid, sdkStr, channel, platModel, oldID)
+	if err != nil {
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+// versionUpdate get versionUpdate
+func versionUpdatePb(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		header = c.Request.Header
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	buildStr := params.Get("build")
+	channel := params.Get("channel")
+	sdkStr := params.Get("sdkint")
+	platModel := params.Get("model")
+	oldID := params.Get("old_id")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	buvid := header.Get(_headerBuvid)
+	// mobiApp not equal to android or mobiApp is null,default android
+	if !model.IsAndroid(plat) {
+		plat = model.PlatAndroid
+	}
+	data, err := verSvc.VersionUpdate(build, plat, buvid, sdkStr, channel, platModel, oldID)
+	if err != nil {
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	size, _ := strconv.Atoi(data.Size)
+	resPb := &version.VerUpdate{
+		Ver:     *proto.String(data.Version),
+		Build:   *proto.Int(data.Build),
+		Info:    *proto.String(data.Desc),
+		Size:    *proto.Int(size),
+		Url:     *proto.String(data.Url),
+		Hash:    *proto.String(data.MD5),
+		Policy:  *proto.Int(data.Policy),
+		IsForce: *proto.Int(data.IsForce),
+		Mtime:   *proto.Int64(data.Mtime.Time().Unix()),
+	}
+	c.JSON(resPb, nil)
+}
+
+func versionSo(c *bm.Context) {
+	params := c.Request.Form
+	name := params.Get("name")
+	seedStr := params.Get("seed")
+	buildStr := params.Get("build")
+	sdkStr := params.Get("sdkint")
+	model := params.Get("model")
+	seed, err := strconv.Atoi(seedStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	sdkint, _ := strconv.Atoi(sdkStr)
+	data, err := verSvc.VersionSo(build, seed, sdkint, name, model)
+	if err != nil {
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+// versionRn get versionUpdate
+func versionRn(c *bm.Context) {
+	params := c.Request.Form
+	deploymentKey := params.Get("deployment_key")
+	bundleID := params.Get("bundle_id")
+	version := params.Get("base_version")
+	data, err := verSvc.VersionRn(version, deploymentKey, bundleID)
+	c.JSON(data, err)
+}

app/interface/main/app-resource/http/white.go

@@ -0,0 +1,7 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func whiteList(c *bm.Context) {
+	c.JSON(whiteSvc.List(), nil)
+}

app/interface/main/app-resource/model/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["const.go"],
+    importpath = "go-common/app/interface/main/app-resource/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//app/interface/main/app-resource/model/tab:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/interface/main/app-resource/model/abtest:all-srcs",
+        "//app/interface/main/app-resource/model/broadcast:all-srcs",
+        "//app/interface/main/app-resource/model/domain:all-srcs",
+        "//app/interface/main/app-resource/model/experiment:all-srcs",
+        "//app/interface/main/app-resource/model/guide:all-srcs",
+        "//app/interface/main/app-resource/model/module:all-srcs",
+        "//app/interface/main/app-resource/model/notice:all-srcs",
+        "//app/interface/main/app-resource/model/param:all-srcs",
+        "//app/interface/main/app-resource/model/plugin:all-srcs",
+        "//app/interface/main/app-resource/model/show:all-srcs",
+        "//app/interface/main/app-resource/model/sidebar:all-srcs",
+        "//app/interface/main/app-resource/model/splash:all-srcs",
+        "//app/interface/main/app-resource/model/static:all-srcs",
+        "//app/interface/main/app-resource/model/tab:all-srcs",
+        "//app/interface/main/app-resource/model/version:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-resource/model/abtest/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["abtest.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/abtest",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//app/service/main/resource/model: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"],
+)

app/interface/main/app-resource/model/abtest/abtest.go

@@ -0,0 +1,15 @@
+package abtest
+
+import (
+	resource "go-common/app/service/main/resource/model"
+)
+
+type List struct {
+	ID   int64  `json:"group_id,lomitempty"`
+	Name string `json:"group_name,omitempty"`
+}
+
+func (l *List) ListChange(r *resource.AbTest) {
+	l.ID = r.ID
+	l.Name = r.Name
+}

app/interface/main/app-resource/model/broadcast/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["broadcast.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/broadcast",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//app/service/main/broadcast/api/grpc/v1: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"],
+)

app/interface/main/app-resource/model/broadcast/broadcast.go

@@ -0,0 +1,43 @@
+package broadcast
+
+import (
+	wardensvr "go-common/app/service/main/broadcast/api/grpc/v1"
+)
+
+type ServerListReply struct {
+	Domain       string   `json:"domain,omitempty"`
+	TCPPort      int32    `json:"tcp_port,omitempty"`
+	WsPort       int32    `json:"ws_port,omitempty"`
+	WssPort      int32    `json:"wss_port,omitempty"`
+	Heartbeat    int32    `json:"heartbeat,omitempty"`
+	HeartbeatMax int32    `json:"heartbeat_max,omitempty"`
+	Nodes        []string `json:"nodes,omitempty"`
+	Backoff      *Backoff `json:"backoff,omitempty"`
+}
+
+type Backoff struct {
+	MaxDelay  int32   `json:"max_delay,omitempty"`
+	BaseDelay int32   `json:"base_delay,omitempty"`
+	Factor    float32 `json:"factor,omitempty"`
+	Jitter    float32 `json:"jitter,omitempty"`
+}
+
+func (l *ServerListReply) ServerListChange(w *wardensvr.ServerListReply) {
+	l.Domain = w.Domain
+	l.TCPPort = w.TcpPort
+	l.WsPort = w.WsPort
+	l.WssPort = w.WssPort
+	l.Heartbeat = w.Heartbeat
+	l.HeartbeatMax = w.HeartbeatMax
+	if len(w.Nodes) > 0 {
+		l.Nodes = w.Nodes
+	}
+	if w.Backoff != nil {
+		l.Backoff = &Backoff{
+			MaxDelay:  w.Backoff.MaxDelay,
+			BaseDelay: w.Backoff.BaseDelay,
+			Factor:    w.Backoff.Factor,
+			Jitter:    w.Backoff.Jitter,
+		}
+	}
+}

app/interface/main/app-resource/model/const.go

@@ -0,0 +1,201 @@
+package model
+
+import (
+	"fmt"
+	"strings"
+
+	"go-common/app/interface/main/app-resource/model/tab"
+)
+
+const (
+	// PlatAndroid is int8 for android.
+	PlatAndroid = int8(0)
+	// PlatIPhone is int8 for iphone.
+	PlatIPhone = int8(1)
+	// PlatIPad is int8 for ipad.
+	PlatIPad = int8(2)
+	// PlatWPhone is int8 for wphone.
+	PlatWPhone = int8(3)
+	// PlatAndroidG is int8 for Android Global.
+	PlatAndroidG = int8(4)
+	// PlatIPhoneI is int8 for Iphone Global.
+	PlatIPhoneI = int8(5)
+	// PlatIPadI is int8 for IPAD Global.
+	PlatIPadI = int8(6)
+	// PlatAndroidTV is int8 for AndroidTV Global.
+	PlatAndroidTV = int8(7)
+	// PlatAndroidI is int8 for Android Global.
+	PlatAndroidI = int8(8)
+	// PlatAndroidB is int8 for Android Blue.
+	PlatAndroidB = int8(9)
+	// PlatIPhoneB is int8 for Ios Blue
+	PlatIPhoneB = int8(10)
+	// PlatBilistudio is int8 for bilistudio
+	PlatBilistudio = int8(11)
+	// PlatAndroidTVYST is int8 for AndroidTV_YST Global.
+	PlatAndroidTVYST = int8(12)
+
+	GotoAv         = "av"
+	GotoWeb        = "web"
+	GotoBangumi    = "bangumi"
+	GotoSp         = "sp"
+	GotoLive       = "live"
+	GotoGame       = "game"
+	GotoPegasusTab = "pegasus"
+)
+
+var (
+	PegasusHandler = func(m *tab.Menu) func(uri string) string {
+		return func(uri string) string {
+			if m == nil {
+				return uri
+			}
+			if m.Name != "" {
+				return fmt.Sprintf("%s?name=%s", uri, m.Name)
+			}
+			return uri
+		}
+	}
+)
+
+// Plat return plat by platStr or mobiApp
+func Plat(mobiApp, device string) int8 {
+	switch mobiApp {
+	case "iphone":
+		if device == "pad" {
+			return PlatIPad
+		}
+		return PlatIPhone
+	case "white":
+		return PlatIPhone
+	case "ipad":
+		return PlatIPad
+	case "android":
+		return PlatAndroid
+	case "win":
+		return PlatWPhone
+	case "android_G":
+		return PlatAndroidG
+	case "android_i":
+		return PlatAndroidI
+	case "android_b":
+		return PlatAndroidB
+	case "iphone_i":
+		if device == "pad" {
+			return PlatIPadI
+		}
+		return PlatIPhoneI
+	case "ipad_i":
+		return PlatIPadI
+	case "iphone_b":
+		return PlatIPhoneB
+	case "android_tv":
+		return PlatAndroidTV
+	case "android_tv_yst":
+		return PlatAndroidTVYST
+	case "bilistudio":
+		return PlatBilistudio
+	case "biliLink":
+		return PlatIPhone
+	}
+	return PlatIPhone
+}
+
+// InvalidBuild check source build is not allow by config build and condition.
+// eg: when condition is gt, means srcBuild must gt cfgBuild, otherwise is invalid srcBuild.
+func InvalidBuild(srcBuild, cfgBuild int, cfgCond string) bool {
+	if cfgBuild != 0 && cfgCond != "" {
+		switch cfgCond {
+		case "gt":
+			if cfgBuild >= srcBuild {
+				return true
+			}
+		case "lt":
+			if cfgBuild <= srcBuild {
+				return true
+			}
+		case "eq":
+			if cfgBuild != srcBuild {
+				return true
+			}
+		case "ne":
+			if cfgBuild == srcBuild {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// IsAndroid check plat is android or ipad.
+func IsAndroid(plat int8) bool {
+	return plat == PlatAndroid || plat == PlatAndroidG || plat == PlatAndroidB || plat == PlatAndroidI ||
+		plat == PlatBilistudio || plat == PlatAndroidTV || plat == PlatAndroidTVYST
+}
+
+// IsIOS check plat is iphone or ipad.
+func IsIOS(plat int8) bool {
+	return plat == PlatIPad || plat == PlatIPhone || plat == PlatIPadI || plat == PlatIPhoneI || plat == PlatIPhoneB
+}
+
+// FillURI deal app schema.
+func FillURI(gt, param string, f func(uri string) string) (uri string) {
+	if param == "" {
+		return
+	}
+	switch gt {
+	case GotoAv, "":
+		uri = "bilibili://video/" + param
+	case GotoLive:
+		uri = "bilibili://live/" + param
+	case GotoBangumi:
+		uri = "bilibili://bangumi/season/" + param
+	case GotoGame:
+		uri = "bilibili://game/" + param
+	case GotoSp:
+		uri = "bilibili://splist/" + param
+	case GotoWeb:
+		uri = param
+	case GotoPegasusTab:
+		uri = "bilibili://pegasus/op/" + param
+	}
+	if f != nil {
+		uri = f(uri)
+	}
+	return
+}
+
+// MobiAPPBuleChange
+func MobiAPPBuleChange(mobiApp string) string {
+	switch mobiApp {
+	case "android_b":
+		return "android"
+	case "iphone_b":
+		return "iphone"
+	}
+	return mobiApp
+}
+
+func URLHTTPS(uri string) (url string) {
+	if strings.HasPrefix(uri, "http://") {
+		url = "https://" + uri[7:]
+	} else {
+		url = uri
+	}
+	return
+}
+
+// IsOverseas is overseas
+func IsOverseas(plat int8) bool {
+	return plat == PlatAndroidI || plat == PlatIPhoneI || plat == PlatIPadI
+}
+
+func PlatAPPBuleChange(plat int8) int8 {
+	switch plat {
+	case PlatAndroidB:
+		return PlatAndroid
+	case PlatIPhoneB:
+		return PlatIPhone
+	}
+	return plat
+}

app/interface/main/app-resource/model/domain/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["domain.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/domain",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-resource/model/domain/domain.go

@@ -0,0 +1,7 @@
+package domain
+
+// Domain
+type Domain struct {
+	Domains      []string `json:"domains"`
+	ImageDomains []string `json:"image_domains"`
+}

app/interface/main/app-resource/model/experiment/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["experiment.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/experiment",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-resource/model/experiment/experiment.go

@@ -0,0 +1,21 @@
+package experiment
+
+type Experiment struct {
+	ID           int64    `json:"id,omitempty"`
+	Plat         int8     `json:"-"`
+	Name         string   `json:"name,omitempty"`
+	Strategy     string   `json:"strategy,omitempty"`
+	Desc         string   `json:"desc,omitempty"`
+	TrafficGroup string   `json:"traffic_group,omitempty"`
+	Limit        []*Limit `json:"-"`
+}
+
+type Limit struct {
+	ExperimentID int64  `json:"-"`
+	Build        int    `json:"-"`
+	Condition    string `json:"-"`
+}
+
+type ABTestV2 struct {
+	AutoPlay int `json:"autoplay"`
+}

app/interface/main/app-resource/model/guide/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["guide.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/guide",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-resource/model/guide/guide.go

@@ -0,0 +1,11 @@
+package guide
+
+type Interest struct {
+	ID   int    `json:"-"`
+	Name string `json:"name"`
+}
+
+type InterestTM struct {
+	Interests []*Interest `json:"interests,omitempty"`
+	FeedType  int         `json:"feed_type"`
+}

app/interface/main/app-resource/model/module/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["module.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/module",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//library/time: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"],
+)

app/interface/main/app-resource/model/module/module.go

@@ -0,0 +1,66 @@
+package module
+
+import (
+	xtime "go-common/library/time"
+)
+
+const (
+	Total       = 0
+	Incremental = 1
+
+	EnvRelease = "1"
+	EnvTest    = "2"
+	EnvDefault = "3"
+
+	NotValid = int8(0)
+	Valid    = int8(1)
+)
+
+type ResourcePool struct {
+	ID        int         `json:"-"`
+	Name      string      `json:"name"`
+	Resources []*Resource `json:"resources,omitempty"`
+}
+
+type Resource struct {
+	ID           int        `json:"-"`
+	ResID        int        `json:"-"`
+	Name         string     `json:"name"`
+	Compresstype int        `json:"compresstype"`
+	Type         string     `json:"type"`
+	URL          string     `json:"url"`
+	MD5          string     `json:"md5"`
+	TotalMD5     string     `json:"total_md5"`
+	Size         int        `json:"size"`
+	Version      int        `json:"ver"`
+	Increment    int        `json:"increment"`
+	FromVer      int        `json:"-"`
+	Condition    *Condition `json:"-"`
+	Level        int        `json:"level,omitempty"`
+	IsWifi       int8       `json:"is_wifi"`
+}
+
+type Condition struct {
+	ID        int                  `json:"-"`
+	ResID     int                  `json:"-"`
+	STime     xtime.Time           `json:"stime"`
+	ETime     xtime.Time           `json:"etime"`
+	Valid     int8                 `json:"valid"`
+	ValidTest int8                 `json:"valid_test"`
+	Default   int                  `json:"-"`
+	Columns   map[string][]*Column `json:"columns"`
+	IsWifi    int8                 `json:"-"`
+}
+
+type Column struct {
+	Condition string `json:"condition"`
+	Value     string `json:"value"`
+}
+
+type Versions struct {
+	PoolName string `json:"name"`
+	Resource []struct {
+		ResourceName string      `json:"name"`
+		Version      interface{} `json:"ver"`
+	} `json:"resources"`
+}

app/interface/main/app-resource/model/notice/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["notice.go"],
+    importpath = "go-common/app/interface/main/app-resource/model/notice",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//library/time: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"],
+)

app/interface/main/app-resource/model/notice/notice.go

@@ -0,0 +1,18 @@
+package notice
+
+import xtime "go-common/library/time"
+
+// Notice is notice type.
+type Notice struct {
+	ID        int        `json:"id,omitempty"`
+	Title     string     `json:"title,omitempty"`
+	Content   string     `json:"content,omitempty"`
+	Start     xtime.Time `json:"start_time,omitempty"`
+	End       xtime.Time `json:"end_time,omitempty"`
+	URI       string     `json:"uri,omitempty"`
+	Type      int        `json:"-"`
+	Plat      int8       `json:"-"`
+	Build     int        `json:"-"`
+	Condition string     `json:"-"`
+	Area      string     `json:"-"`
+}