Create & Init Project...

app/service/live/xrewardcenter/BUILD

@@ -0,0 +1,23 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/live/xrewardcenter/api/grpc/v1:all-srcs",
+        "//app/service/live/xrewardcenter/cmd:all-srcs",
+        "//app/service/live/xrewardcenter/conf:all-srcs",
+        "//app/service/live/xrewardcenter/dao:all-srcs",
+        "//app/service/live/xrewardcenter/model:all-srcs",
+        "//app/service/live/xrewardcenter/server/grpc:all-srcs",
+        "//app/service/live/xrewardcenter/server/http:all-srcs",
+        "//app/service/live/xrewardcenter/service:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xrewardcenter/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v1.0.0
+1. 修复任意门入口问题

app/service/live/xrewardcenter/CONTRIBUTORS.md

@@ -0,0 +1,11 @@
+# Owner
+wujunchen
+xiehaishen
+
+# Author
+wujunchen
+xiehaishen
+
+# Reviewer
+xiehaishen
+liugang

app/service/live/xrewardcenter/OWNERS

@@ -0,0 +1,15 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- wujunchen
+- xiehaishen
+labels:
+- live
+- service
+- service/live/xrewardcenter
+options:
+  no_parent_owners: true
+reviewers:
+- liugang
+- wujunchen
+- xiehaishen

app/service/live/xrewardcenter/README.md

@@ -0,0 +1,12 @@
+# xrewardcenter-interface
+
+# 项目简介
+1.
+
+# 编译环境
+
+
+# 依赖包
+
+
+# 编译执行

app/service/live/xrewardcenter/api/grpc/api.md

@@ -0,0 +1 @@
+# HTTP API文档

app/service/live/xrewardcenter/api/grpc/v1/AnchorReward.anchorReward.md

@@ -0,0 +1,192 @@
+## (主播侧)-我的主播奖励(登录态)
+
+`POST http://api.live.bilibili.com/xlive/internal/xrewardcenter/v1/anchorReward/myReward`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|page|否|integer| 页数|
+|uid|是|integer| 主播uid|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        "data": [
+            {
+                //  id
+                "id": 0,
+                //  奖励类型 1:ss推荐卡 2:s推荐卡、任意门
+                "reward_type": 0,
+                //  1:未使用,3:已使用,5:已过期
+                "status": 0,
+                //  奖励id
+                "reward_id": 0,
+                //  奖励名称
+                "name": "",
+                //  奖励图标
+                "icon": "",
+                //  获得时间datetime
+                "achieve_time": "",
+                //  过期时间datetime
+                "expire_time": "",
+                //  来源,1:主播任务,2:小时榜
+                "source": 0,
+                //  奖励简介
+                "reward_intro": ""
+            }
+        ],
+        "page": {
+            //  当前页码
+            "page": 0,
+            //  每页大小
+            "page_size": 0,
+            //  总页数
+            "total_page": 0,
+            //  总记录数
+            "total_count": 0
+        },
+        //  过期奖励数量
+        "expire_count": 0
+    }
+}
+```
+
+##* (主播侧)-奖励使用记录(登录态)
+ 
+
+`GET http://api.live.bilibili.com/xlive/xrewardcenter/v1/anchorReward/useRecord`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|page|否|integer| 页数|
+|uid|是|integer| 主播uid|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        "data": [
+            {
+                //  id
+                "id": 0,
+                //  奖励id
+                "reward_id": 0,
+                //  1:未使用,3:已使用,5:已过期
+                "status": 0,
+                //  奖励名称
+                "name": "",
+                //  奖励图标
+                "icon": "",
+                //  获得时间datetime
+                "achieve_time": "",
+                //  获得时间datetime
+                "use_time": "",
+                //  过期时间datetime
+                "expire_time": "",
+                //  来源,1:主播任务,2:小时榜
+                "source": 0,
+                //  奖励简介
+                "reward_intro": ""
+            }
+        ],
+        "page": {
+            //  当前页码
+            "page": 0,
+            //  每页大小
+            "page_size": 0,
+            //  总页数
+            "total_page": 0,
+            //  总记录数
+            "total_count": 0
+        }
+    }
+}
+```
+
+##* (主播侧)-使用奖励(登录态)
+ 
+
+`GET http://api.live.bilibili.com/xlive/xrewardcenter/v1/anchorReward/useReward`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|id|是|integer| 奖励列表id|
+|uid|是|integer| 主播uid|
+|use_plat|是|string| 使用平台|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        "result": 0
+    }
+}
+```
+
+##* (主播侧)-奖励和任务红点(登录态)
+ 
+
+`GET http://api.live.bilibili.com/xlive/xrewardcenter/v1/anchorReward/isViewed`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|uid|是|integer| 主播uid|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        //  是否展示任务红点
+        "task_should_notice": 0,
+        //  是否展示奖励入口
+        "show_reward_entry": 0,
+        //  是否展示奖励红点
+        "reward_should_notice": 0,
+        //  任务状态, 0:没有,1:领取, 5:完成
+        "task_status": 0,
+        //  是否在首页黑名单中
+        "is_blacked": 0,
+        //  点击跳转h5链接
+        "url": ""
+    }
+}
+```
+
+## (主播侧)-添加主播奖励(内部接口)
+
+`POST http://api.live.bilibili.com/xlive/internal/xrewardcenter/v1/anchorReward/addReward`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|reward_id|是|integer| 奖励id, 1:任意门|
+|roomid|是|integer| 房间号|
+|source|是|integer| 来源,1:主播任务,2:小时榜,3:周星|
+|uid|是|integer| 主播uid|
+|order_id|是|string| 流水单号|
+|lifespan|否|integer| 礼物有效期小时数,默认24小时|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        //  是否成功
+        "result": 0
+    }
+}
+```
+

app/service/live/xrewardcenter/api/grpc/v1/AnchorReward.bm.go

@@ -0,0 +1,122 @@
+// Code generated by protoc-gen-bm v0.1, DO NOT EDIT.
+// source: api/grpc/v1/AnchorReward.proto
+
+/*
+Package v1 is a generated blademaster stub package.
+This code was generated with go-common/app/tool/bmgen/protoc-gen-bm v0.1.
+
+It is generated from these files:
+	api/grpc/v1/AnchorReward.proto
+*/
+package v1
+
+import (
+	"context"
+
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+// to suppressed 'imported but not used warning'
+var _ *bm.Context
+var _ context.Context
+var _ binding.StructValidator
+
+// ======================
+// AnchorReward Interface
+// ======================
+
+type AnchorReward interface {
+	// (主播侧)-我的主播奖励(登录态)
+	// `method:"POST" internal:"true"`
+	MyReward(ctx context.Context, req *AnchorTaskMyRewardReq) (resp *AnchorTaskMyRewardResp, err error)
+
+	// * (主播侧)-奖励使用记录(登录态)
+	//
+	UseRecord(ctx context.Context, req *AnchorTaskUseRecordReq) (resp *AnchorTaskUseRecordResp, err error)
+
+	// * (主播侧)-使用奖励(登录态)
+	//
+	UseReward(ctx context.Context, req *AnchorTaskUseRewardReq) (resp *AnchorTaskUseRewardResp, err error)
+
+	// * (主播侧)-奖励和任务红点(登录态)
+	//
+	IsViewed(ctx context.Context, req *AnchorTaskIsViewedReq) (resp *AnchorTaskIsViewedResp, err error)
+
+	// (主播侧)-添加主播奖励(内部接口)
+	// `method:"POST" internal:"true"`
+	AddReward(ctx context.Context, req *AnchorTaskAddRewardReq) (resp *AnchorTaskAddRewardResp, err error)
+}
+
+var v1AnchorRewardSvc AnchorReward
+
+// @params AnchorTaskMyRewardReq
+// @router POST /xlive/internal/xrewardcenter/v1/anchorReward/myReward
+// @response AnchorTaskMyRewardResp
+func anchorRewardMyReward(c *bm.Context) {
+	p := new(AnchorTaskMyRewardReq)
+	if err := c.BindWith(p, binding.Default(c.Request.Method, c.Request.Header.Get("Content-Type"))); err != nil {
+		return
+	}
+	resp, err := v1AnchorRewardSvc.MyReward(c, p)
+	c.JSON(resp, err)
+}
+
+// @params AnchorTaskUseRecordReq
+// @router GET /xlive/xrewardcenter/v1/anchorReward/useRecord
+// @response AnchorTaskUseRecordResp
+func anchorRewardUseRecord(c *bm.Context) {
+	p := new(AnchorTaskUseRecordReq)
+	if err := c.BindWith(p, binding.Default(c.Request.Method, c.Request.Header.Get("Content-Type"))); err != nil {
+		return
+	}
+	resp, err := v1AnchorRewardSvc.UseRecord(c, p)
+	c.JSON(resp, err)
+}
+
+// @params AnchorTaskUseRewardReq
+// @router GET /xlive/xrewardcenter/v1/anchorReward/useReward
+// @response AnchorTaskUseRewardResp
+func anchorRewardUseReward(c *bm.Context) {
+	p := new(AnchorTaskUseRewardReq)
+	if err := c.BindWith(p, binding.Default(c.Request.Method, c.Request.Header.Get("Content-Type"))); err != nil {
+		return
+	}
+	resp, err := v1AnchorRewardSvc.UseReward(c, p)
+	c.JSON(resp, err)
+}
+
+// @params AnchorTaskIsViewedReq
+// @router GET /xlive/xrewardcenter/v1/anchorReward/isViewed
+// @response AnchorTaskIsViewedResp
+func anchorRewardIsViewed(c *bm.Context) {
+	p := new(AnchorTaskIsViewedReq)
+	if err := c.BindWith(p, binding.Default(c.Request.Method, c.Request.Header.Get("Content-Type"))); err != nil {
+		return
+	}
+	resp, err := v1AnchorRewardSvc.IsViewed(c, p)
+	c.JSON(resp, err)
+}
+
+// @params AnchorTaskAddRewardReq
+// @router POST /xlive/internal/xrewardcenter/v1/anchorReward/addReward
+// @response AnchorTaskAddRewardResp
+func anchorRewardAddReward(c *bm.Context) {
+	p := new(AnchorTaskAddRewardReq)
+	if err := c.BindWith(p, binding.Default(c.Request.Method, c.Request.Header.Get("Content-Type"))); err != nil {
+		return
+	}
+	resp, err := v1AnchorRewardSvc.AddReward(c, p)
+	c.JSON(resp, err)
+}
+
+// RegisterV1AnchorRewardService Register the blademaster route with middleware map
+// midMap is the middleware map, the key is defined in proto
+func RegisterV1AnchorRewardService(e *bm.Engine, svc AnchorReward, midMap map[string]bm.HandlerFunc) {
+	v1AnchorRewardSvc = svc
+	e.POST("/xlive/internal/xrewardcenter/v1/anchorReward/myReward", anchorRewardMyReward)
+	e.GET("/xlive/xrewardcenter/v1/anchorReward/useRecord", anchorRewardUseRecord)
+	e.GET("/xlive/xrewardcenter/v1/anchorReward/useReward", anchorRewardUseReward)
+	e.GET("/xlive/xrewardcenter/v1/anchorReward/isViewed", anchorRewardIsViewed)
+	e.POST("/xlive/internal/xrewardcenter/v1/anchorReward/addReward", anchorRewardAddReward)
+}

app/service/live/xrewardcenter/api/grpc/v1/AnchorReward.proto

@@ -0,0 +1,191 @@
+syntax = "proto3";
+
+package live.xrewardcenter.v1;
+
+option go_package = "v1";
+
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+service AnchorReward {
+
+    // (主播侧)-我的主播奖励(登录态)
+    // `method:"POST" internal:"true"`
+    rpc myReward (AnchorTaskMyRewardReq) returns (AnchorTaskMyRewardResp);
+
+    /** (主播侧)-奖励使用记录(登录态)
+     * 
+     */
+    rpc useRecord (AnchorTaskUseRecordReq) returns (AnchorTaskUseRecordResp);
+
+    /** (主播侧)-使用奖励(登录态)
+     * 
+     */
+    rpc useReward (AnchorTaskUseRewardReq) returns (AnchorTaskUseRewardResp);
+
+    /** (主播侧)-奖励和任务红点(登录态)
+     * 
+     */
+    rpc isViewed (AnchorTaskIsViewedReq) returns (AnchorTaskIsViewedResp);
+
+    // (主播侧)-添加主播奖励(内部接口)
+    // `method:"POST" internal:"true"`
+    rpc addReward (AnchorTaskAddRewardReq) returns (AnchorTaskAddRewardResp);
+}
+
+message AnchorTaskAddRewardReq {
+    // 奖励id, 1:任意门
+    int64 reward_id = 4 [(gogoproto.moretags) = "form:\"reward_id\" validate:\"required\""];
+    // 房间号
+    int64 roomid = 8 [(gogoproto.moretags) = "form:\"roomid\" validate:\"required\""];
+    // 来源,1:主播任务,2:小时榜,3:周星
+    int64 source = 9 [(gogoproto.moretags) = "form:\"source\" validate:\"required\""];
+    // 主播uid
+    int64 uid = 10 [(gogoproto.moretags) = "form:\"uid\" validate:\"required\""];
+    // 流水单号
+    string order_id = 11 [(gogoproto.moretags) = "form:\"order_id\" validate:\"required\""];
+    // 礼物有效期小时数,默认24小时
+    int64 lifespan = 12 [(gogoproto.moretags) = "form:\"lifespan\" validate:\"min=0\""];
+}
+
+message AnchorTaskAddRewardResp {
+    // 是否成功
+    int64 result = 1;
+}
+
+
+message AnchorTaskMyRewardReq {
+    // 页数
+    int64 page = 1 [(gogoproto.moretags) = "form:\"page\""];
+    // 主播uid
+    int64 uid = 2 [(gogoproto.moretags) = "form:\"uid\" validate:\"required\""];
+}
+
+message AnchorTaskMyRewardResp {
+    //
+    repeated RewardObj data = 1;
+    //
+    Page page = 2;
+    // 过期奖励数量
+    int64 expire_count = 3;
+
+    message RewardObj {
+        // id
+        int64 id = 1;
+        // 奖励类型 1:ss推荐卡 2:s推荐卡、任意门
+        int64 reward_type = 2;
+        // 1:未使用,3:已使用,5:已过期
+        int64 status = 3;
+        // 奖励id
+        int64 reward_id = 4;
+        // 奖励名称
+        string name = 5;
+        // 奖励图标
+        string icon = 6;
+        // 获得时间datetime
+        string achieve_time = 7;
+        // 过期时间datetime
+        string expire_time = 8;
+        // 来源,1:主播任务,2:小时榜
+        int64 source = 9;
+        // 奖励简介
+        string reward_intro = 10;
+    }
+
+    message Page {
+        // 当前页码
+        int64 page = 1;
+        // 每页大小
+        int64 page_size = 2;
+        // 总页数
+        int64 total_page = 3;
+        // 总记录数
+        int64 total_count = 4;
+    }
+}
+
+
+message AnchorTaskUseRecordReq {
+    // 页数
+    int64 page = 1 [(gogoproto.moretags) = "form:\"page\""];
+    // 主播uid
+    int64 uid = 2 [(gogoproto.moretags) = "form:\"uid\" validate:\"required\""];
+}
+
+message AnchorTaskUseRecordResp {
+
+    message RewardObj {
+        // id
+        int64 id = 1;
+        // 奖励id
+        int64 reward_id = 2;
+        // 1:未使用,3:已使用,5:已过期
+        int64 status = 3;
+        // 奖励名称
+        string name = 4;
+        // 奖励图标
+        string icon = 5;
+        // 获得时间datetime
+        string achieve_time = 6;
+        // 获得时间datetime
+        string use_time = 10;
+        // 过期时间datetime
+        string expire_time = 7;
+        // 来源,1:主播任务,2:小时榜
+        int64 source = 8;
+        // 奖励简介
+        string reward_intro = 9;
+    }
+
+    message Page {
+        // 当前页码
+        int64 page = 1;
+        // 每页大小
+        int64 page_size = 2;
+        // 总页数
+        int64 total_page = 3;
+        // 总记录数
+        int64 total_count = 4;
+    }
+
+    //
+    repeated RewardObj data = 1;
+    //
+    Page page = 2;
+}
+
+
+message AnchorTaskUseRewardReq {
+    // 奖励列表id
+    int64 id = 1 [(gogoproto.moretags) = "form:\"id\" validate:\"required\""];
+    // 主播uid
+    int64 uid = 2 [(gogoproto.moretags) = "form:\"uid\" validate:\"required\""];
+    // 使用平台
+    string use_plat = 3 [(gogoproto.moretags) = "form:\"use_plat\" validate:\"required\""];
+}
+
+message AnchorTaskUseRewardResp {
+
+    int64 result = 1;
+}
+
+
+message AnchorTaskIsViewedReq {
+    // 主播uid
+    int64 uid = 1 [(gogoproto.moretags) = "form:\"uid\" validate:\"required\""];
+}
+
+message AnchorTaskIsViewedResp {
+
+    // 是否展示任务红点
+    int64 task_should_notice = 1;
+    // 是否展示奖励入口
+    int64 show_reward_entry = 5;
+    // 是否展示奖励红点
+    int64 reward_should_notice = 2;
+    // 任务状态, 0:没有,1:领取, 5:完成
+    int64 task_status = 3;
+    // 是否在首页黑名单中
+    int64 is_blacked = 4;
+    // 点击跳转h5链接
+    string url = 6;
+}

app/service/live/xrewardcenter/api/grpc/v1/BUILD

@@ -0,0 +1,62 @@
+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",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "AnchorReward.bm.go",
+        "client.go",
+    ],
+    embed = [":v1_go_proto"],
+    importpath = "go-common/app/service/live/xrewardcenter/api/grpc/v1",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/binding:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "@com_github_gogo_protobuf//gogoproto: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"],
+)
+
+proto_library(
+    name = "v1_proto",
+    srcs = ["AnchorReward.proto"],
+    tags = ["automanaged"],
+    deps = ["@gogo_special_proto//github.com/gogo/protobuf/gogoproto"],
+)
+
+go_proto_library(
+    name = "v1_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:gogofast_grpc"],
+    importpath = "go-common/app/service/live/xrewardcenter/api/grpc/v1",
+    proto = ":v1_proto",
+    tags = ["automanaged"],
+    deps = ["@com_github_gogo_protobuf//gogoproto:go_default_library"],
+)

app/service/live/xrewardcenter/api/grpc/v1/client.go

@@ -0,0 +1,24 @@
+package v1
+
+import (
+	"context"
+
+	"go-common/library/net/rpc/warden"
+
+	"google.golang.org/grpc"
+)
+
+// AppID unique app id for service discovery
+const AppID = "live.xrewardcenter"
+
+// NewClient new member grpc client
+func NewClient(cfg *warden.ClientConfig, opts ...grpc.DialOption) (AnchorRewardClient, error) {
+	client := warden.NewClient(cfg, opts...)
+	conn, err := client.Dial(context.Background(), "discovery://default/"+AppID)
+	//conn, err := client.Dial(context.Background(), "127.0.0.1:9000")
+
+	if err != nil {
+		return nil, err
+	}
+	return NewAnchorRewardClient(conn), nil
+}

app/service/live/xrewardcenter/api/http/v1/anchorReward.md

@@ -0,0 +1,191 @@
+## (主播侧)-我的主播奖励(登录态)
+
+`POST http://api.live.bilibili.com/xlive/internal/xrewardcenter/v1/anchorReward/myReward`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|page|否|integer| 页数|
+|uid|否|integer| 主播uid|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        "data": [
+            {
+                //  id
+                "id": 0,
+                //  奖励类型 1:ss推荐卡 2:s推荐卡、任意门
+                "reward_type": 0,
+                //  1:未使用,3:已使用,5:已过期
+                "status": 0,
+                //  奖励id
+                "reward_id": 0,
+                //  奖励名称
+                "name": "",
+                //  奖励图标
+                "icon": "",
+                //  获得时间datetime
+                "achieve_time": "",
+                //  过期时间datetime
+                "expire_time": "",
+                //  来源,1:主播任务,2:小时榜
+                "source": 0,
+                //  奖励简介
+                "reward_intro": ""
+            }
+        ],
+        "page": {
+            //  当前页码
+            "page": 0,
+            //  每页大小
+            "page_size": 0,
+            //  总页数
+            "total_page": 0,
+            //  总记录数
+            "total_count": 0
+        },
+        //  过期奖励数量
+        "expire_count": 0
+    }
+}
+```
+
+##* (主播侧)-奖励使用记录(登录态)
+ 
+
+`GET http://api.live.bilibili.com/xlive/xrewardcenter/v1/anchorReward/useRecord`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|page|否|integer| 页数|
+|uid|否|integer| 主播uid|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        "data": [
+            {
+                //  id
+                "id": 0,
+                //  奖励id
+                "reward_id": 0,
+                //  1:未使用,3:已使用,5:已过期
+                "status": 0,
+                //  奖励名称
+                "name": "",
+                //  奖励图标
+                "icon": "",
+                //  获得时间datetime
+                "achieve_time": "",
+                //  获得时间datetime
+                "use_time": "",
+                //  过期时间datetime
+                "expire_time": "",
+                //  来源,1:主播任务,2:小时榜
+                "source": 0,
+                //  奖励简介
+                "reward_intro": ""
+            }
+        ],
+        "page": {
+            //  当前页码
+            "page": 0,
+            //  每页大小
+            "page_size": 0,
+            //  总页数
+            "total_page": 0,
+            //  总记录数
+            "total_count": 0
+        }
+    }
+}
+```
+
+##* (主播侧)-使用奖励(登录态)
+ 
+
+`GET http://api.live.bilibili.com/xlive/xrewardcenter/v1/anchorReward/useReward`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|id|否|integer| 奖励列表id|
+|uid|否|integer| 主播uid|
+|use_plat|否|string| 使用平台|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        "result": 0
+    }
+}
+```
+
+##* (主播侧)-奖励和任务红点(登录态)
+ 
+
+`GET http://api.live.bilibili.com/xlive/xrewardcenter/v1/anchorReward/isViewed`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|uid|否|integer| 主播uid|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        //  是否展示任务红点
+        "task_should_notice": 0,
+        //  是否展示奖励入口
+        "show_reward_entry": 0,
+        //  是否展示奖励红点
+        "reward_should_notice": 0,
+        //  任务状态, 0:没有,1:领取, 5:完成
+        "task_status": 0,
+        //  是否在首页黑名单中
+        "is_blacked": 0,
+        //  点击跳转h5链接
+        "url": ""
+    }
+}
+```
+
+## (主播侧)-添加主播奖励(内部接口)
+
+`POST http://api.live.bilibili.com/xlive/internal/xrewardcenter/v1/anchorReward/addReward`
+
+### 请求参数
+
+|参数名|必选|类型|描述|
+|:---|:---|:---|:---|
+|reward_id|否|integer| 奖励id, 1:任意门|
+|roomid|否|integer| 房间号|
+|source|否|integer| 来源,1:主播任务,2:小时榜|
+|uid|否|integer| 主播uid|
+|order_id|否|string| 流水单号|
+
+```json
+{
+    "code": 0,
+    "message": "ok",
+    "data": {
+        //  是否成功
+        "result": 0
+    }
+}
+```
+

app/service/live/xrewardcenter/cmd/BUILD

@@ -0,0 +1,47 @@
+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 = ["test.toml"],
+    importpath = "go-common/app/service/live/xrewardcenter/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/server/grpc:go_default_library",
+        "//app/service/live/xrewardcenter/server/http:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/trace:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/live/xrewardcenter/cmd/client:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xrewardcenter/cmd/client/BUILD

@@ -0,0 +1,40 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "client",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    importpath = "go-common/app/service/live/xrewardcenter/cmd/client",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xrewardcenter/api/grpc/v1:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//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/service/live/xrewardcenter/cmd/client/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log"
+	"time"
+
+	"fmt"
+	"go-common/app/service/live/xrewardcenter/api/grpc/v1"
+	"go-common/library/net/rpc/warden"
+	xtime "go-common/library/time"
+)
+
+var name, addr string
+
+func init() {
+	flag.StringVar(&name, "name", "lily", "name")
+	flag.StringVar(&addr, "addr", "127.0.0.1:9004", "server addr")
+}
+
+func main() {
+	flag.Parse()
+	cfg := &warden.ClientConfig{
+		Dial:    xtime.Duration(time.Second * 3),
+		Timeout: xtime.Duration(time.Second * 3),
+	}
+	cc, err := warden.NewClient(cfg).Dial(context.Background(), addr)
+	if err != nil {
+		log.Fatalf("new client failed!err:=%v", err)
+		return
+	}
+
+	client := v1.NewAnchorRewardClient(cc)
+
+	resp, err := client.MyReward(context.Background(), &v1.AnchorTaskMyRewardReq{
+		Page: 1,
+		Uid:  10000,
+	})
+	fmt.Printf("****** myReward:******* \n %+v \n %v \n", resp, err)
+
+	resp2, err := client.AddReward(context.Background(), &v1.AnchorTaskAddRewardReq{
+		RewardId: 1,
+		Roomid:   555,
+		Source:   1,
+		Uid:      10000,
+		OrderId:  "test123",
+		Lifespan: 1,
+	})
+	fmt.Printf("*****  addReward:********\n%+v \n %v \n", resp2, err)
+
+	//resp3, err := client.IsViewed(context.Background(), &v1.AnchorTaskIsViewedReq{
+	//	Uid: 10000,
+	//})
+	//fmt.Printf("got IsViewed:%+v", resp3)
+
+	//resp4, _ := client.UseRecord(context.Background(), &v1.AnchorTaskUseRecordReq{
+	//	Page: 1,
+	//	Uid:  10000,
+	//})
+	//fmt.Printf("got UseRecord:%+v", resp4)
+	//
+	//resp5, err := client.UseReward(context.Background(), &v1.AnchorTaskUseRewardReq{
+	//	Id:      1,
+	//	Uid:     10000,
+	//	UsePlat: "ios",
+	//})
+	//fmt.Printf("got UseReward:%+v", resp5)
+}

app/service/live/xrewardcenter/cmd/main.go

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

app/service/live/xrewardcenter/cmd/test.toml

@@ -0,0 +1,67 @@
+[log]
+    stdout=true
+
+[mysql]
+	addr = "172.22.34.101:3312"
+	dsn = "livetestuat:livetestuat20180711@tcp(172.22.34.101:3312)/live-sign?timeout=2s&readTimeout=2s&writeTimeout=2s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+	readDSN = ["root:root@tcp(127.0.0.1:3306)/live-sign?timeout=200ms&readTimeout=200ms&writeTimeout=200ms&parseTime=true&loc=Local&charset=utf8,utf8mb4","root:root@tcp(127.0.0.1:3306)/live-sign?timeout=200ms&readTimeout=200ms&writeTimeout=200ms&parseTime=true&loc=Local&charset=utf8,utf8mb4"]
+	active = 20
+	idle = 10
+	idleTimeout ="4h"
+	queryTimeout = "100ms"
+	execTimeout = "100ms"
+	tranTimeout = "200ms"
+
+[Cfg]
+    ExpireCountFrequency = "0 */1 * * * ?"
+    SetExpireFrequency = "0 */1 * * * ?"
+
+[orm]
+	dsn = "livetestuat:livetestuat20180711@tcp(172.22.34.101:3312)/live-sign?timeout=2s&readTimeout=2s&writeTimeout=2s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+	active = 20
+    idle = 10
+	idleTimeout ="4h"
+
+[redis]
+	name = "xrewardcenter"
+	proto = "tcp"
+    addr = "127.0.0.1:6379"
+	idle = 10
+	active = 10
+	dialTimeout = "1s"
+	readTimeout = "1s"
+	writeTimeout = "1s"
+	idleTimeout = "10s"
+	expire = "1m"
+
+[memcache]
+	name = "xrewardcenter"
+	proto = "tcp"
+	addr = "127.0.0.1:11211"
+	active = 50
+	idle = 10
+	dialTimeout = "1s"
+	readTimeout = "1s"
+	writeTimeout = "1s"
+	idleTimeout = "10s"
+	expire = "24h"
+
+[liverpc]
+    [liverpc.room]
+        Addr = "172.18.33.82:20200"
+    [liverpc.gift]
+        Addr = "172.18.33.82:7778"
+
+[httpClient]
+    key    = "e7482d29be4a95b8"
+    secret = "9e803791cdef756e75faee68e12b7442"
+    dial      = "500ms"
+    timeout   = "1s"
+    keepAlive = "60s"
+    timer     = 128
+    [httpClient.breaker]
+        window  = "10s"
+        sleep   = "100ms"
+        bucket  = 10
+        ratio   = 0.5
+        request = 100

app/service/live/xrewardcenter/conf/BUILD

@@ -0,0 +1,43 @@
+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/service/live/xrewardcenter/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/conf:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/net/rpc/liverpc:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/trace: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/service/live/xrewardcenter/conf/conf.go

@@ -0,0 +1,104 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+	"go-common/library/net/rpc/warden"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/conf"
+	"go-common/library/database/sql"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/verify"
+	"go-common/library/net/trace"
+
+	"github.com/BurntSushi/toml"
+	"go-common/library/database/orm"
+	"go-common/library/net/rpc/liverpc"
+)
+
+var (
+	confPath string
+	client   *conf.Client
+	// Conf config
+	Conf = &Config{}
+)
+
+// Config .
+type Config struct {
+	Log        *log.Config
+	BM         *bm.ServerConfig
+	Verify     *verify.Config
+	Tracer     *trace.Config
+	Redis      *redis.Config
+	Memcache   *memcache.Config
+	MySQL      *sql.Config
+	Ecode      *ecode.Config
+	Cfg        *Cfg
+	ORM        *orm.Config
+	LiveRpc    map[string]*liverpc.ClientConfig
+	Warden     *warden.ClientConfig
+	HTTPClient *bm.ClientConfig
+}
+
+// Cfg def
+type Cfg struct {
+	// ExpireCountFrequency crontab frequency
+	ExpireCountFrequency string
+	// SetExpireFrequency crontab frequency
+	SetExpireFrequency string
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default config path")
+}
+
+// Init init conf
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}
+
+func local() (err error) {
+	_, err = toml.DecodeFile(confPath, &Conf)
+	return
+}
+
+func remote() (err error) {
+	if client, err = conf.New(); err != nil {
+		return
+	}
+	if err = load(); err != nil {
+		return
+	}
+	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/service/live/xrewardcenter/dao/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 = ["dao.go"],
+    importpath = "go-common/app/service/live/xrewardcenter/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/gift/api/liverpc:go_default_library",
+        "//app/service/live/room/api/liverpc:go_default_library",
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/rpc/liverpc:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/live/xrewardcenter/dao/anchorReward:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xrewardcenter/dao/anchorReward/BUILD

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.cache.go",
+        "dao.go",
+        "mc.cache.go",
+        "mc.go",
+        "mysql.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/service/live/xrewardcenter/dao/anchorReward",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/model/anchorTask:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/jinzhu/gorm: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao.cache_test.go",
+        "dao_test.go",
+        "mc.cache_test.go",
+        "mc_test.go",
+        "mysql_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/model/anchorTask:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/service/live/xrewardcenter/dao/anchorReward/dao.cache.go

@@ -0,0 +1,54 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/gen. DO NOT EDIT.
+
+/*
+  Package anchorReward is a generated cache proxy package.
+  It is generated from:
+  type _cache interface {
+		// cache: -sync=true -nullcache=&model.AnchorRewardConf{ID:-1} -check_null_code=$.ID==-1
+		RewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+	}
+*/
+
+package anchorReward
+
+import (
+	"context"
+
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/stat/prom"
+)
+
+var _ _cache
+
+// RewardConf get data from cache if miss will call source method, then add to cache.
+func (d *Dao) RewardConf(c context.Context, id int64) (res *model.AnchorRewardConf, err error) {
+	addCache := true
+	res, err = d.CacheRewardConf(c, id)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	defer func() {
+		if res != nil && res.ID == -1 {
+			res = nil
+		}
+	}()
+	if res != nil {
+		prom.CacheHit.Incr("RewardConf")
+		return
+	}
+	prom.CacheMiss.Incr("RewardConf")
+	res, err = d.RawRewardConf(c, id)
+	if err != nil {
+		return
+	}
+	miss := res
+	if miss == nil {
+		miss = &model.AnchorRewardConf{ID: -1}
+	}
+	if !addCache {
+		return
+	}
+	d.AddCacheRewardConf(c, id, miss)
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/dao.cache_test.go

@@ -0,0 +1,24 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardRewardConf(t *testing.T) {
+	convey.Convey("RewardConf", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.RewardConf(c, id)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/anchorReward/dao.go

@@ -0,0 +1,418 @@
+package anchorReward
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/service/live/xrewardcenter/conf"
+	AnchorTaskModel "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/database/orm"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	xtime "go-common/library/time"
+	"math"
+	"time"
+
+	"bytes"
+	"encoding/json"
+	bm "go-common/library/net/http/blademaster"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+
+	"github.com/jinzhu/gorm"
+)
+
+// OrderExist .
+const (
+	//  缓存过期时间
+	rewardConfExpire = 3600
+	rewardConfPrefix = "rconf_v1_%d"
+)
+
+// Dao dao
+type Dao struct {
+	c                   *conf.Config
+	mc                  *memcache.Pool
+	redis               *redis.Pool
+	orm                 *gorm.DB
+	db                  *xsql.DB
+	keyRewardConfExpire int32
+	client              *bm.Client
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:                   c,
+		mc:                  memcache.NewPool(c.Memcache),
+		redis:               redis.NewPool(c.Redis),
+		db:                  xsql.NewMySQL(c.MySQL),
+		orm:                 orm.NewMySQL(c.ORM),
+		keyRewardConfExpire: rewardConfExpire,
+		client:              bm.NewClient(c.HTTPClient),
+	}
+	dao.initORM()
+	return
+}
+
+func keyRewardConf(id int64) string {
+	return fmt.Sprintf(rewardConfPrefix, id)
+}
+
+func (d *Dao) initORM() {
+	d.orm.LogMode(true)
+	d.orm.SingularTable(true)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/gen
+type _cache interface {
+	// cache: -sync=true -nullcache=&model.AnchorRewardConf{ID:-1} -check_null_code=$.ID==-1
+	RewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/mc
+type _mc interface {
+	// 获取奖励配置
+	// mc: -key=keyRewardConf
+	CacheRewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+
+	// 保存奖励配置
+	// mc: -key=keyRewardConf -expire=d.keyRewardConfExpire -encode=json|gzip
+	AddCacheRewardConf(c context.Context, id int64, value *model.AnchorRewardConf) error
+}
+
+// AddReward add Reward to a user.
+func (d *Dao) AddReward(c context.Context, iRewardID int64, uid int64, iSource int64, iRoomid int64, iLifespan int64) (err error) {
+	//aReward, _ := getRewardConfByLid(iRewardID)
+
+	m, _ := time.ParseDuration(fmt.Sprintf("+%dh", iLifespan))
+
+	arg := &AnchorTaskModel.AnchorReward{
+		Uid:         uid,
+		RewardId:    iRewardID,
+		Roomid:      iRoomid,
+		Source:      iSource,
+		AchieveTime: xtime.Time(time.Now().Unix()),
+		ExpireTime:  xtime.Time(time.Now().Add(m).Unix()),
+		Status:      model.RewardUnUsed,
+	}
+
+	//spew.Dump
+	// (arg)
+	if err := d.orm.Create(arg).Error; err != nil {
+		log.Error("addReward(%v) error(%v)", arg, err)
+		return err
+	}
+
+	if err := d.SetNewReward(c, uid, int64(1)); err != nil {
+		log.Error("addRewardMc(%v) error(%v)", uid, err)
+	}
+
+	if err := d.SetHasReward(c, uid, int64(1)); err != nil {
+		log.Error("SetHasReward(%v) error(%v)", uid, err)
+	}
+
+	log.Info("addReward (%v) succ", arg)
+
+	return
+}
+
+//GetByUidPage get reward by uid and page.
+func (d *Dao) GetByUidPage(c context.Context, uid int64, page int64, pageSize int64, status []int64) (pager *model.AnchorRewardPager, list []*model.AnchorRewardObject, err error) {
+	err = nil
+	pager = &model.AnchorRewardPager{}
+	list = []*model.AnchorRewardObject{}
+
+	var (
+		Items []*AnchorTaskModel.AnchorReward
+		count int64
+	)
+	iOffSet := (page - 1) * pageSize
+
+	db := d.orm.Where("status in (?)", status).Where("uid=?", uid)
+	db.Model(&AnchorTaskModel.AnchorReward{}).Count(&count)
+
+	if err = db.Model(&AnchorTaskModel.AnchorReward{}).Limit(pageSize).Offset(iOffSet).Order("mtime DESC, id").Find(&Items).Error; err != nil {
+		log.Error("get ap_anchor_task_reward_list uid(%v) error(%v)", uid, err)
+		return
+	}
+
+	for _, v := range Items {
+		aReward, err := d.RewardConf(c, v.RewardId)
+		if err != nil {
+			log.Error("RewardConf(%v) error(%v)", v.RewardId, err)
+			return pager, list, err
+		}
+
+		if aReward == nil {
+			continue
+		}
+
+		aListItem := &model.AnchorRewardObject{
+			Id:          v.Id,
+			RewardType:  aReward.RewardType,
+			Status:      v.Status,
+			RewardId:    v.RewardId,
+			Name:        aReward.Name,
+			Icon:        aReward.Icon,
+			AchieveTime: v.AchieveTime.Time().Format("2006-01-02 15:04:05"),
+			ExpireTime:  v.ExpireTime.Time().Format("2006-01-02 15:04:05"),
+			UseTime:     v.UseTime.Time().Format("2006-01-02 15:04:05"),
+			Source:      v.Source,
+			RewardIntro: aReward.RewardIntro,
+		}
+
+		list = append(list, aListItem)
+	}
+	pager = &model.AnchorRewardPager{
+		Page:       page,
+		PageSize:   pageSize,
+		TotalPage:  int64(math.Ceil(float64(count) / float64(pageSize))),
+		TotalCount: count,
+	}
+
+	return
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.orm != nil {
+		d.orm.DB().PingContext(c)
+	}
+
+	err = d.pingMC(c)
+	return
+}
+
+// GetById get reward by id.
+func (d *Dao) GetById(id int64) (reward *model.AnchorReward, err error) {
+	rewards := []*model.AnchorReward{}
+	if err := d.orm.Model(&model.AnchorReward{}).Find(&rewards, "id=?", id).Error; err != nil {
+		log.Error("getRewardById (%v) error(%v)", id, err)
+		return reward, err
+	}
+	if len(rewards) != 0 {
+		reward = rewards[0]
+	}
+
+	return
+}
+
+// UseReward use reward by id.
+func (d *Dao) UseReward(id int64, usePlat string) (rst bool, err error) {
+	if err := d.orm.
+		Model(&model.AnchorReward{}).
+		Where("id=?", id).
+		Update(map[string]interface{}{"status": model.RewardUsed, "use_plat": usePlat, "use_time": xtime.Time(time.Now().Unix())}).Error; err != nil {
+		log.Error("useReward (%v) error(%v)", id, err)
+		return rst, err
+	}
+	rst = true
+	return
+}
+
+// HasNewReward .
+func (d *Dao) HasNewReward(c context.Context, uid int64) (rst int64, err error) {
+	rst, _ = d.GetNewReward(c, uid)
+	return
+}
+
+func (d *Dao) findByUid(uid int64, limitOne bool) (reward *model.AnchorReward, err error) {
+	rewards := []*model.AnchorReward{}
+	db := d.orm.Where("uid=?", uid)
+
+	if limitOne {
+		db = db.Limit(1)
+	}
+
+	if err := db.Model(&model.AnchorReward{}).Find(&rewards).Error; err != nil {
+		log.Error("getRewardById (%v) error(%v)", uid, err)
+		return reward, err
+	}
+	if len(rewards) != 0 {
+		reward = rewards[0]
+	}
+
+	return
+}
+
+// HasReward returns if a user have reward.
+func (d *Dao) HasReward(c context.Context, uid int64) (r int64, err error) {
+	rst, err := d.GetHasReward(c, uid)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			reward, err2 := d.findByUid(uid, true)
+			if err2 != nil {
+				return rst, err2
+			}
+			if reward != nil {
+				rst = int64(1)
+				d.SetHasReward(c, uid, rst)
+			} else {
+				rst = int64(0)
+				d.SetHasReward(c, uid, rst)
+			}
+			return rst, err
+		}
+		log.Error("HasReward(%v) error(%v)", uid, err)
+		return rst, err
+	}
+	return rst, err
+}
+
+// CheckOrderID check orderid is valid.
+func (d *Dao) CheckOrderID(c context.Context, id string) (exist int64, err error) {
+	exist = 0
+	if exist, err = d.GetOrder(c, id); err != nil {
+		//spew.Dump(exist, err)
+		if err == memcache.ErrNotFound {
+			err = nil
+		}
+		return exist, err
+	}
+	return exist, err
+}
+
+// SaveOrderID save order id.
+func (d *Dao) SaveOrderID(c context.Context, id string) error {
+	err := d.SaveOrder(c, id)
+	return err
+}
+
+// SetExpire .
+func (d *Dao) SetExpire(now time.Time) (err error) {
+	var (
+		db = d.orm
+	)
+
+	setMap := map[string]interface{}{
+		"status": model.RewardExpired,
+	}
+
+	if err = db.Model(model.AnchorReward{}).
+		Where("status=? AND reward_id = ? AND expire_time <= ?", model.RewardUnUsed, 1, now.Format("2006-01-02 15:04:05")).
+		Update(setMap).
+		Error; err != nil {
+		log.Error("SetExpire (%v) error(%v)", setMap, err)
+		return err
+	}
+	return
+}
+
+// CountExpire .
+func (d *Dao) CountExpire(interval int64, now time.Time) (err error) {
+	var (
+		c      = context.TODO()
+		db     = d.orm
+		result = &[]model.AnchorReward{}
+	)
+
+	dur, _ := time.ParseDuration("-" + strconv.FormatInt(interval, 10) + "s")
+	begin := now.Add(dur)
+
+	//spew.Dump(begin.Format("2006-01-02 15:04:05"))
+	//spew.Dump(now.Format("2006-01-02 15:04:05"))
+	sqlTemp :=
+		"SELECT * FROM ap_anchor_task_reward_list WHERE status = ? AND expire_time > ? AND expire_time <= ? AND reward_id= ?"
+
+	db.Raw(sqlTemp,
+		model.RewardExpired,
+		begin.Format("2006-01-02 15:04:05"),
+		now.Format("2006-01-02 15:04:05"),
+		1).Scan(&result)
+
+	for _, v := range *result {
+		d.AddExpireCountCache(c, fmt.Sprintf(model.CountExpireUserKey, v.Uid), model.ExpireCountTime)
+	}
+	return
+}
+
+// SendBroadcastV2 .
+func (d *Dao) SendBroadcastV2(c context.Context, uid int64, roomid int64, rewardId int64) (err error) {
+	log.Info("send reward broadcast begin:%d", roomid)
+
+	var endPoint string = fmt.Sprintf("http://live-dm.bilibili.co/dm/1/push?cid=%d&ensure=1", roomid)
+
+	postJson := make(map[string]interface{})
+	postJson["cmd"] = "new_anchor_reward"
+	postJson["uid"] = uid
+	postJson["roomid"] = roomid
+	postJson["reward_id"] = rewardId
+
+	bytesData, err := json.Marshal(postJson)
+	if err != nil {
+		log.Error("json.Marshal(%v) error(%v)", postJson, err)
+		return
+	}
+
+	req, err := http.NewRequest("POST", endPoint, bytes.NewReader(bytesData))
+
+	req.Header.Add("Content-Type", "application/json")
+
+	if err != nil {
+		log.Error("http.NewRequest(%v) url(%v) error(%v)", postJson, endPoint, err)
+		return
+	}
+
+	var v interface{}
+
+	if err = d.client.Do(c, req, v); err != nil {
+		log.Error("s.client.Do error(%v) res (%v)", err, v)
+		return
+	}
+	log.Info("s.client.Do endpoint (%v) req (%v) res (%v)", endPoint, postJson, v)
+
+	return
+}
+
+// SendBroadcast .
+func (d *Dao) SendBroadcast(uid int64, roomid int64, rewardId int64) (err error) {
+	log.Info("send reward broadcast begin:%d", roomid)
+
+	var endPoint = fmt.Sprintf("http://live-dm.bilibili.co/dm/1/push?cid=%d&ensure=1", roomid)
+
+	postJson := make(map[string]interface{})
+	postJson["cmd"] = "new_anchor_reward"
+	postJson["uid"] = uid
+	postJson["roomid"] = roomid
+	postJson["reward_id"] = rewardId
+
+	bytesData, err := json.Marshal(postJson)
+	if err != nil {
+		log.Error("json.Marshal(%v) error(%v)", postJson, err)
+		return
+	}
+
+	req, err := http.NewRequest("POST", endPoint, bytes.NewReader(bytesData))
+
+	req.Header.Add("Content-Type", "application/json")
+
+	if err != nil {
+		log.Error("http.NewRequest(%v) url(%v) error(%v)", postJson, endPoint, err)
+		return
+	}
+
+	client := http.Client{
+		Timeout: time.Second,
+	}
+
+	// use httpClient to send request
+	response, err := client.Do(req)
+
+	if err != nil {
+		log.Error("sending request to API endpoint(%v) error(%v)", req, err)
+		return
+	}
+
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		log.Error("parse resp body(%v) error(%v)", body, err)
+	}
+
+	log.Info("send reward broadcast end:%d", roomid)
+
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/dao_test.go

@@ -0,0 +1,34 @@
+package anchorReward
+
+import (
+	"flag"
+	"go-common/app/service/live/xrewardcenter/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "")
+		flag.Set("conf_token", "")
+		flag.Set("tree_id", "")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/service/live/xrewardcenter/dao/anchorReward/mc.cache.go

@@ -0,0 +1,71 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/mc. DO NOT EDIT.
+
+/*
+  Package anchorReward is a generated mc cache package.
+  It is generated from:
+  type _mc interface {
+		// 获取奖励配置
+		// mc: -key=keyRewardConf
+		CacheRewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+
+		// 保存奖励配置
+		// mc: -key=keyRewardConf -expire=d.keyRewardConfExpire -encode=json|gzip
+		AddCacheRewardConf(c context.Context, id int64, value *model.AnchorRewardConf) error
+	}
+*/
+
+package anchorReward
+
+import (
+	"context"
+	"fmt"
+
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+var _ _mc
+
+// CacheRewardConf 获取奖励配置
+func (d *Dao) CacheRewardConf(c context.Context, id int64) (res *model.AnchorRewardConf, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyRewardConf(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheRewardConf")
+		log.Errorv(c, log.KV("CacheRewardConf", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &model.AnchorRewardConf{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheRewardConf")
+		log.Errorv(c, log.KV("CacheRewardConf", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheRewardConf 保存奖励配置
+func (d *Dao) AddCacheRewardConf(c context.Context, id int64, val *model.AnchorRewardConf) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyRewardConf(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.keyRewardConfExpire, Flags: memcache.FlagJSON | memcache.FlagGzip}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheRewardConf")
+		log.Errorv(c, log.KV("AddCacheRewardConf", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/mc.cache_test.go

@@ -0,0 +1,41 @@
+package anchorReward
+
+import (
+	"context"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardCacheRewardConf(t *testing.T) {
+	convey.Convey("CacheRewardConf", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.CacheRewardConf(c, id)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardAddCacheRewardConf(t *testing.T) {
+	convey.Convey("AddCacheRewardConf", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(0)
+			val = &model.AnchorRewardConf{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.AddCacheRewardConf(c, id, val)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/anchorReward/mc.go

@@ -0,0 +1,176 @@
+package anchorReward
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+
+	"go-common/app/service/live/xrewardcenter/model/anchorTask"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	//NewRewardCache have new reward.
+	NewRewardCache = "new_reward:v1:%d"
+	//HasRewardCache have a reward
+	HasRewardCache = "has_reward:v1:%d"
+)
+
+// HasNewReward .
+type HasNewReward struct {
+	HasNewReward int64 `json:"has_new_reward"`
+}
+
+// pingMC .
+func (d *Dao) pingMC(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: "ping", Value: []byte{1}, Expiration: 0}); err != nil {
+		err = errors.Wrap(err, "conn.Store(set,ping,1)")
+	}
+	return
+}
+
+func newRewardKey(uid int64) string {
+	return fmt.Sprintf(NewRewardCache, uid)
+}
+
+// SetNewReward get MRRecord from mc
+func (d *Dao) SetNewReward(c context.Context, uid int64, hasNew int64) (err error) {
+	var (
+		conn = d.mc.Get(c)
+		key  = newRewardKey(uid)
+	)
+
+	defer conn.Close()
+
+	log.Info("SetNewReward.mc.set(%v) (%v)", key, hasNew)
+
+	if err = conn.Set(&memcache.Item{
+		Key:        key,
+		Object:     hasNew,
+		Flags:      memcache.FlagJSON,
+		Expiration: 3600,
+	}); err != nil {
+		log.Error("SetNewReward.mc.set(%v %v) error(%v)", key, hasNew, err)
+		return
+	}
+	return
+}
+
+// GetNewReward set MRRecord to mc
+func (d *Dao) GetNewReward(c context.Context, uid int64) (r int64, err error) {
+	r = 0
+
+	var (
+		key  = newRewardKey(uid)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+
+	item, err := conn.Get(key)
+
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			return r, err
+		}
+		err = errors.Wrapf(err, "conn.get(%v,%v)", key, item)
+		return r, err
+	}
+
+	if err = conn.Scan(item, &r); err != nil {
+		log.Error("mc.Scan(%s) error(%v)", string(item.Value), err)
+	}
+
+	return
+}
+
+// GetHasReward .
+func (d *Dao) GetHasReward(c context.Context, uid int64) (r int64, err error) {
+	var (
+		key  = hasRewardKey(uid)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+
+	r = 0
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			return r, err
+		}
+		err = errors.Wrapf(err, "mc.get(%s,%v)", key, item)
+		return r, err
+	}
+
+	if err = conn.Scan(item, &r); err != nil {
+		log.Error("mc.Scan(%s) error(%v)", string(item.Value), err)
+	}
+	//spew.Dump(r, err)
+
+	return
+}
+
+func hasRewardKey(uid int64) string {
+	return fmt.Sprintf(HasRewardCache, uid)
+}
+
+// SetHasReward save whether one user have reward.
+func (d *Dao) SetHasReward(c context.Context, uid int64, isHave int64) (err error) {
+	var (
+		conn = d.mc.Get(c)
+		key  = hasRewardKey(uid)
+	)
+
+	defer conn.Close()
+
+	log.Info("SetHasReward.mc.set(%v %v)", key, isHave)
+
+	if err = conn.Set(&memcache.Item{
+		Key:        key,
+		Object:     isHave,
+		Flags:      memcache.FlagJSON,
+		Expiration: 3600 * 24,
+	}); err != nil {
+		log.Error("SetHasReward.mc.set(%v %v) error(%v)", key, isHave, err)
+		return
+	}
+	return
+}
+
+// GetOrder get order by id from cache.
+func (d *Dao) GetOrder(c context.Context, id string) (exists int64, err error) {
+
+	conn := d.mc.Get(c)
+	defer conn.Close()
+
+	_, err = conn.Get(id)
+
+	if err != nil {
+		exists = 0
+		return exists, err
+	}
+	exists = anchorTask.RewardExists
+	return exists, err
+}
+
+// SaveOrder save orderid in cache.
+func (d *Dao) SaveOrder(c context.Context, id string) (err error) {
+
+	conn := d.mc.Get(c)
+	defer conn.Close()
+
+	if err = conn.Set(&memcache.Item{
+		Key:        id,
+		Value:      []byte{1},
+		Expiration: 3600,
+	}); err != nil {
+		log.Error("(%v) error(%v)", id, err)
+		return
+	}
+
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/mc_test.go

@@ -0,0 +1,145 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardpingMC(t *testing.T) {
+	convey.Convey("pingMC", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.pingMC(c)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardnewRewardKey(t *testing.T) {
+	convey.Convey("newRewardKey", t, func(ctx convey.C) {
+		var (
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := newRewardKey(uid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSetNewReward(t *testing.T) {
+	convey.Convey("SetNewReward", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			uid    = int64(0)
+			hasNew = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetNewReward(c, uid, hasNew)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetNewReward(t *testing.T) {
+	convey.Convey("GetNewReward", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			r, err := d.GetNewReward(c, uid)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetHasReward(t *testing.T) {
+	convey.Convey("GetHasReward", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			r, err := d.GetHasReward(c, uid)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardhasRewardKey(t *testing.T) {
+	convey.Convey("hasRewardKey", t, func(ctx convey.C) {
+		var (
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := hasRewardKey(uid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSetHasReward(t *testing.T) {
+	convey.Convey("SetHasReward", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			uid    = int64(0)
+			isHave = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetHasReward(c, uid, isHave)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetOrder(t *testing.T) {
+	convey.Convey("GetOrder", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			exists, err := d.GetOrder(c, id)
+			ctx.Convey("Then err should be nil.exists should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(exists, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSaveOrder(t *testing.T) {
+	convey.Convey("SaveOrder", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SaveOrder(c, id)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/anchorReward/mysql.go

@@ -0,0 +1,22 @@
+package anchorReward
+
+import (
+	"context"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/log"
+)
+
+// RawRewardConf return reward config from db.
+func (d *Dao) RawRewardConf(c context.Context, id int64) (res *model.AnchorRewardConf, err error) {
+	rewards := []*model.AnchorRewardConf{}
+
+	if err := d.orm.Model(&model.AnchorReward{}).Find(&rewards, "id=?", id).Error; err != nil {
+		log.Error("getRewardById (%v) error(%v)", id, err)
+		return nil, err
+	}
+	if len(rewards) != 0 {
+		res = rewards[0]
+	}
+
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/mysql_test.go

@@ -0,0 +1,24 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardRawRewardConf(t *testing.T) {
+	convey.Convey("RawRewardConf", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.RawRewardConf(c, id)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/anchorReward/redis.go

@@ -0,0 +1,119 @@
+package anchorReward
+
+import (
+	"context"
+	"go-common/library/cache/redis"
+
+	"go-common/library/log"
+)
+
+const (
+	_preLock        = "lk_"
+	_preExpireCount = "ec_"
+)
+
+func lockKey(key string) string {
+	return _preLock + key
+}
+
+func expireCountKey(key string) string {
+	return _preExpireCount + key
+}
+
+//DelLockCache del lock cache.
+func (d *Dao) DelLockCache(c context.Context, k string) (err error) {
+	var (
+		key  = lockKey(k)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", key); err != nil {
+		log.Error("DelLockCache.conn.Do(del,%v) err(%v)", key, err)
+	} else {
+		log.Info("DelLockCache.conn.Do(del,%v)", key)
+	}
+	return
+}
+
+// GetExpireCountCache .
+func (d *Dao) GetExpireCountCache(c context.Context, k string) (count int64, err error) {
+	var (
+		key  = expireCountKey(k)
+		conn = d.redis.Get(c)
+	)
+
+	//spew.Dump(k)
+	defer conn.Close()
+	item, err := redis.Int(conn.Do("GET", key))
+	if err != nil {
+		if err == redis.ErrNil {
+			count = 0
+			err = nil
+		} else {
+			log.Error("conn.Do(GET %s) error(%v)", key, err)
+			return 0, err
+		}
+	}
+	count = int64(item)
+
+	return
+}
+
+// AddExpireCountCache .
+func (d *Dao) AddExpireCountCache(c context.Context, k string, times int64) (err error) {
+	var (
+		key  = expireCountKey(k)
+		conn = d.redis.Get(c)
+	)
+	//spew.Dump(k)
+	defer conn.Close()
+	if _, err = conn.Do("INCR", key); err != nil {
+		log.Error("conn.Do(incr,%v) err(%v)", key, err)
+	}
+
+	if _, err = redis.Bool(conn.Do("EXPIRE", key, times)); err != nil {
+		log.Error("conn.Do(EXPIRE, %s, %d) error(%v)", key, times, err)
+		return
+	}
+	return
+
+}
+
+// ClearExpireCountCache .
+func (d *Dao) ClearExpireCountCache(c context.Context, k string) (err error) {
+	var (
+		key  = expireCountKey(k)
+		conn = d.redis.Get(c)
+	)
+	//spew.Dump(k)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", key); err != nil {
+		log.Error("conn.Do(del,%v) err(%v)", key, err)
+		return
+	}
+
+	return
+}
+
+//SetNxLock redis lock.
+func (d *Dao) SetNxLock(c context.Context, k string, times int64) (res bool, err error) {
+	var (
+		key  = lockKey(k)
+		conn = d.redis.Get(c)
+	)
+
+	defer conn.Close()
+	if res, err = redis.Bool(conn.Do("SETNX", key, "1")); err != nil {
+		log.Error("conn.Do(SETNX(%d)) error(%v)", key, err)
+		return
+	}
+	//spew.Dump(res, err )
+	if res {
+		if _, err = redis.Bool(conn.Do("EXPIRE", key, times)); err != nil {
+			log.Error("conn.Do(EXPIRE, %s, %d) error(%v)", key, times, err)
+			return
+		}
+		log.Info("conn.Do(EXPIRE, %s, %d) ", key, times)
+	}
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/redis_test.go

@@ -0,0 +1,115 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardlockKey(t *testing.T) {
+	convey.Convey("lockKey", t, func(ctx convey.C) {
+		var (
+			key = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := lockKey(key)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardexpireCountKey(t *testing.T) {
+	convey.Convey("expireCountKey", t, func(ctx convey.C) {
+		var (
+			key = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := expireCountKey(key)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardDelLockCache(t *testing.T) {
+	convey.Convey("DelLockCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			k = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelLockCache(c, k)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetExpireCountCache(t *testing.T) {
+	convey.Convey("GetExpireCountCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			k = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.GetExpireCountCache(c, k)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardAddExpireCountCache(t *testing.T) {
+	convey.Convey("AddExpireCountCache", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			k     = ""
+			times = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.AddExpireCountCache(c, k, times)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardClearExpireCountCache(t *testing.T) {
+	convey.Convey("ClearExpireCountCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			k = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.ClearExpireCountCache(c, k)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSetNxLock(t *testing.T) {
+	convey.Convey("SetNxLock", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			k     = ""
+			times = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.SetNxLock(c, k, times)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/dao.go

@@ -0,0 +1,83 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/service/live/xrewardcenter/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+
+	gift_api "go-common/app/service/live/gift/api/liverpc"
+	room_api "go-common/app/service/live/room/api/liverpc"
+	"go-common/library/net/rpc/liverpc"
+)
+
+// Dao dao
+type Dao struct {
+	c     *conf.Config
+	mc    *memcache.Pool
+	redis *redis.Pool
+	db    *xsql.DB
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:     c,
+		mc:    memcache.NewPool(c.Memcache),
+		redis: redis.NewPool(c.Redis),
+		db:    xsql.NewMySQL(c.MySQL),
+	}
+	return
+}
+
+// RoomAPI .
+var RoomAPI *room_api.Client
+
+// GiftAPI .
+var GiftAPI *gift_api.Client
+
+// InitAPI init all service APIs
+func InitAPI() {
+	RoomAPI = room_api.New(getConf("room"))
+	GiftAPI = gift_api.New(getConf("gift"))
+}
+
+func getConf(appName string) *liverpc.ClientConfig {
+	c := conf.Conf.LiveRpc
+	if c != nil {
+		return c[appName]
+	}
+	return nil
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.mc.Close()
+	d.redis.Close()
+	d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	if err := d.db.Ping(c); err != nil {
+		log.Error("ping db error(%v)", err)
+		return err
+	}
+
+	return d.pingMemcache(c)
+}
+
+func (d *Dao) pingMemcache(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	err = conn.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0})
+
+	if err != nil {
+		log.Error("mc.ping.Store error(%v)", err)
+		return err
+	}
+	return err
+}

app/service/live/xrewardcenter/model/BUILD

@@ -0,0 +1,23 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/live/xrewardcenter/model/anchorTask:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xrewardcenter/model/anchorTask/BUILD

@@ -0,0 +1,32 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "anchorReward.go",
+        "anchorRewardConf.go",
+    ],
+    importpath = "go-common/app/service/live/xrewardcenter/model/anchorTask",
+    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/service/live/xrewardcenter/model/anchorTask/anchorReward.go

@@ -0,0 +1,83 @@
+package anchorTask
+
+import (
+	xtime "go-common/library/time"
+)
+
+// TableName is used to identify table name in gorm
+func (ar *AnchorReward) TableName() string {
+	return "ap_anchor_task_reward_list"
+}
+
+// consts .
+const (
+	RewardUnUsed  = int64(1)
+	RewardUsed    = int64(3)
+	RewardExpired = int64(5)
+
+	CountExpireLockKey = "xrc:lock:count_expire:lock:v1"
+	CountExpireUserKey = "xrc:lock:count_expire:user:v1:%d"
+	SetExpireLockKey   = "xrc:lock:set_expire:lock:v1"
+	ExpireCountTime    = 86400 * 30 * 3
+
+	RewardExists = int64(1)
+)
+
+// AnchorReward .
+type AnchorReward struct {
+	Id          int64      `json:"id" gorm:"comumn:id"`
+	Uid         int64      `json:"uid" gorm:"comumn:uid"`
+	RewardId    int64      `json:"reward_id" gorm:"comumn:reward_id"`
+	Roomid      int64      `json:"roomid" gorm:"comumn:roomid"`
+	Lid         int64      `json:"lid" gorm:"comumn:lid"`
+	Source      int64      `json:"source" gorm:"comumn:source"`
+	UsePlat     int64      `json:"use_plat" gorm:"comumn:use_plat"`
+	AchieveTime xtime.Time `json:"achieve_time" gorm:"comumn:achieve_time"`
+	UseTime     xtime.Time `json:"use_time" gorm:"comumn:use_time;not null;"`
+	StartTime   xtime.Time `json:"start_time" gorm:"comumn:start_time"`
+	EndTime     xtime.Time `json:"end_time" gorm:"comumn:end_time"`
+	ExpireTime  xtime.Time `json:"expire_time" gorm:"comumnw:expire_time"`
+	Status      int64      `json:"status" gorm:"comumn:status"`
+	Reserved1   int64      `json:"reserved1" gorm:"comumn:reserved1"`
+	Reserved2   string     `json:"reserved2" gorm:"comumn:reserved2"`
+	Ctime       xtime.Time `json:"ctime" gorm:"comumn:ctime"`
+	Mtime       xtime.Time `json:"mtime" gorm:"comumn:mtime"`
+}
+
+// AnchorRewardObject .
+type AnchorRewardObject struct {
+	// id
+	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	// 奖励类型 1:ss推荐卡 2:s推荐卡、任意门
+	RewardType int64 `protobuf:"varint,2,opt,name=reward_type,json=rewardType,proto3" json:"reward_type,omitempty"`
+	// 1:未使用,3:已使用,5:已过期
+	Status int64 `protobuf:"varint,3,opt,name=status,proto3" json:"status,omitempty"`
+	// 奖励id
+	RewardId int64 `protobuf:"varint,4,opt,name=reward_id,json=rewardId,proto3" json:"reward_id,omitempty"`
+	// 奖励名称
+	Name string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
+	// 奖励图标
+	Icon string `protobuf:"bytes,6,opt,name=icon,proto3" json:"icon,omitempty"`
+	// 获得时间datetime
+	AchieveTime string `protobuf:"bytes,7,opt,name=achieve_time,json=achieveTime,proto3" json:"achieve_time,omitempty"`
+	// 过期时间datetime
+	ExpireTime string `protobuf:"bytes,8,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
+	// 过期时间datetime
+	UseTime string `protobuf:"bytes,8,opt,name=expire_time,json=useTime,proto3" json:"use_time,omitempty"`
+	// 来源,1:主播任务,2:小时榜
+	Source int64 `protobuf:"varint,9,opt,name=source,proto3" json:"source,omitempty"`
+	// 奖励简介
+	RewardIntro string `protobuf:"bytes,10,opt,name=reward_intro,json=rewardIntro,proto3" json:"reward_intro,omitempty"`
+}
+
+// AnchorRewardPager .
+type AnchorRewardPager struct {
+	// 当前页码
+	Page int64 `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"`
+	// 每页大小
+	PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
+	// 总页数
+	TotalPage int64 `protobuf:"varint,3,opt,name=total_page,json=totalPage,proto3" json:"total_page,omitempty"`
+	// 总记录数
+	TotalCount int64 `protobuf:"varint,4,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
+}

app/service/live/xrewardcenter/model/anchorTask/anchorRewardConf.go

@@ -0,0 +1,25 @@
+package anchorTask
+
+import (
+	xtime "go-common/library/time"
+)
+
+// TableName is used to identify table name in gorm
+func (arc *AnchorRewardConf) TableName() string {
+	return "ap_anchor_task_reward_conf"
+}
+
+// AnchorRewardConf .
+type AnchorRewardConf struct {
+	ID           int64      `json:"id" gorm:"comumn:id"`
+	Name         string     `json:"name" gorm:"comumn:name"`
+	Icon         string     `json:"icon" gorm:"comumn:icon"`
+	RewardIntro  string     `json:"reward_intro" gorm:"comumn:reward_intro"`
+	RewardType   int64      `json:"reward_type" gorm:"comumn:reward_type"`
+	Detail       string     `json:"detail" gorm:"comumn:detail"`
+	Instructions string     `json:"instructions" gorm:"comumn:instructions"`
+	Reserved1    int64      `json:"reserved1" gorm:"comumn:reserved1"`
+	Reserved2    string     `json:"reserved2" gorm:"comumn:reserved2"`
+	Ctime        xtime.Time `json:"ctime" gorm:"comumn:ctime"`
+	Mtime        xtime.Time `json:"mtime" gorm:"comumn:mtime"`
+}

app/service/live/xrewardcenter/server/grpc/BUILD

@@ -0,0 +1,36 @@
+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/service/live/xrewardcenter/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xrewardcenter/api/grpc/v1:go_default_library",
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/dao:go_default_library",
+        "//app/service/live/xrewardcenter/service/v1: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/service/live/xrewardcenter/server/grpc/server.go

@@ -0,0 +1,24 @@
+package grpc
+
+import (
+	pb "go-common/app/service/live/xrewardcenter/api/grpc/v1"
+	"go-common/app/service/live/xrewardcenter/conf"
+	"go-common/app/service/live/xrewardcenter/dao"
+	svc "go-common/app/service/live/xrewardcenter/service/v1"
+	"go-common/library/log"
+	"go-common/library/net/rpc/warden"
+)
+
+// TODO
+
+// Init .
+func Init(c *conf.Config) {
+	s := warden.NewServer(nil)
+	dao.InitAPI()
+	pb.RegisterAnchorRewardServer(s.Server(), svc.NewAnchorTaskService(c))
+	_, err := s.Start()
+	if err != nil {
+		log.Error("grpc Start error(%v)", err)
+		panic(err)
+	}
+}

app/service/live/xrewardcenter/server/http/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 = ["http.go"],
+    importpath = "go-common/app/service/live/xrewardcenter/server/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/verify: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/service/live/xrewardcenter/server/http/http.go

@@ -0,0 +1,50 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/live/xrewardcenter/conf"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	//midAuth *auth.Auth
+	vfy *verify.Verify
+)
+
+// Init init
+func Init(c *conf.Config) {
+	vfy = verify.New(c.Verify)
+	engine := bm.DefaultServer(c.BM)
+	route(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("bm Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func route(e *bm.Engine) {
+	e.Ping(ping)
+	e.Register(register)
+	//midMap := map[string]bm.HandlerFunc{"auth": midAuth.User, "verify": vfy.Verify}
+
+	g := e.Group("/x/xrewardcenter")
+	{
+		g.GET("/start", vfy.Verify, howToStart)
+	}
+}
+
+func ping(c *bm.Context) {
+	c.AbortWithStatus(http.StatusOK)
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}
+
+// example for http request handler
+func howToStart(c *bm.Context) {
+	c.String(0, "Golang 大法好 !!!")
+}

app/service/live/xrewardcenter/service/BUILD

@@ -0,0 +1,23 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/live/xrewardcenter/service/v1:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xrewardcenter/service/v1/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["anchorReward.go"],
+    importpath = "go-common/app/service/live/xrewardcenter/service/v1",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/gift/api/liverpc/v0:go_default_library",
+        "//app/service/live/room/api/liverpc/v2:go_default_library",
+        "//app/service/live/xrewardcenter/api/grpc/v1:go_default_library",
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/dao:go_default_library",
+        "//app/service/live/xrewardcenter/dao/anchorReward:go_default_library",
+        "//app/service/live/xrewardcenter/model/anchorTask:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+        "//vendor/github.com/robfig/cron: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["anchorReward_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/live/xrewardcenter/api/grpc/v1:go_default_library",
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/service/live/xrewardcenter/service/v1/anchorReward.go

@@ -0,0 +1,393 @@
+package v1
+
+import (
+	"context"
+
+	v1pb "go-common/app/service/live/xrewardcenter/api/grpc/v1"
+	"go-common/app/service/live/xrewardcenter/conf"
+	"go-common/app/service/live/xrewardcenter/dao/anchorReward"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"fmt"
+	"time"
+
+	"go-common/app/service/live/gift/api/liverpc/v0"
+	"go-common/app/service/live/room/api/liverpc/v2"
+	"go-common/app/service/live/xrewardcenter/dao"
+
+	"github.com/pkg/errors"
+	"github.com/robfig/cron"
+)
+
+// consts .
+const (
+	PageSize = int64(20)
+	// 任意门道具id
+	GiftIDRenYiMen = int64(30035)
+	// 默认奖励有效期
+	DefaultLifespan = int64(24)
+)
+
+// AnchorRewardService struct
+type AnchorRewardService struct {
+	conf                 *conf.Config
+	dao                  *anchorReward.Dao
+	cron                 *cron.Cron
+	ExpireCountFrequency string
+	SetExpireFrequency   string
+}
+
+//NewAnchorTaskService init
+func NewAnchorTaskService(c *conf.Config) (s *AnchorRewardService) {
+	//spew.Dump(c)
+	s = &AnchorRewardService{
+		conf:                 c,
+		cron:                 cron.New(),
+		ExpireCountFrequency: c.Cfg.ExpireCountFrequency,
+		SetExpireFrequency:   c.Cfg.SetExpireFrequency,
+		dao:                  anchorReward.New(c),
+	}
+	s.addCrontab()
+	s.cron.Start()
+	return s
+}
+
+func (s *AnchorRewardService) addCrontab() (err error) {
+	//spew.Dump(s.ExpireCountFrequency)
+	err = s.cron.AddFunc(s.ExpireCountFrequency, s.CountExpire)
+
+	if err != nil {
+		log.Error("anchorTask.CountExpire AddFunc CountExpire error(%v)", err)
+	}
+
+	err = s.cron.AddFunc(s.SetExpireFrequency, s.SetExpire)
+
+	if err != nil {
+		log.Error("anchorTask.SetExpire AddFunc SetExpireFrequency error(%v)", err)
+	}
+
+	return
+}
+
+// MyReward implementation
+// * (主播侧)-我的主播奖励(登录态)
+//
+func (s *AnchorRewardService) MyReward(ctx context.Context, req *v1pb.AnchorTaskMyRewardReq) (resp *v1pb.AnchorTaskMyRewardResp, err error) {
+
+	var (
+		iPage = req.Page
+	)
+
+	uid := req.GetUid()
+
+	// 获取 uid
+	if 0 == uid {
+		err = ecode.NoLogin
+		//errors.WithMessage(ecode.NoLogin, "账号未登录")
+		return
+	}
+
+	if iPage <= 0 {
+		iPage = 1
+	}
+
+	resp = &v1pb.AnchorTaskMyRewardResp{}
+
+	pager, list, err := s.dao.GetByUidPage(ctx, uid, iPage, PageSize, []int64{model.RewardUnUsed})
+	if nil != err {
+		log.Error("myReward(%+v) error(%v)", req, err)
+		err = nil
+	}
+
+	for _, v := range list {
+		resp.Data = append(resp.Data, &v1pb.AnchorTaskMyRewardResp_RewardObj{
+			Id:          v.Id,
+			RewardType:  v.RewardType,
+			Status:      v.Status,
+			RewardId:    v.RewardId,
+			Name:        v.Name,
+			Icon:        v.Icon,
+			AchieveTime: v.AchieveTime,
+			ExpireTime:  v.ExpireTime,
+			Source:      v.Source,
+			RewardIntro: v.RewardIntro,
+		})
+	}
+
+	resp.Page = &v1pb.AnchorTaskMyRewardResp_Page{
+		Page:       pager.Page,
+		PageSize:   pager.PageSize,
+		TotalPage:  pager.TotalPage,
+		TotalCount: pager.TotalPage,
+	}
+
+	resp.ExpireCount, _ = s.dao.GetExpireCountCache(ctx, fmt.Sprintf(model.CountExpireUserKey, uid))
+
+	if err := s.dao.SetNewReward(ctx, uid, int64(0)); err != nil {
+		log.Error("hasNewRewardMc(%v) error(%v)", uid, err)
+	}
+
+	if err := s.dao.ClearExpireCountCache(ctx, fmt.Sprintf(model.CountExpireUserKey, uid)); err != nil {
+		log.Error("ClearExpireCountCache(%v) error(%v)", uid, err)
+	}
+
+	return
+}
+
+// SetExpire changes status if is expired.
+func (s *AnchorRewardService) SetExpire() {
+	var (
+		c        = context.TODO()
+		now      = time.Now()
+		interval = int64(60)
+	)
+
+	log.Info("SetExpire start (%v)", now)
+
+	if b, err := s.dao.SetNxLock(c, model.SetExpireLockKey, interval-1); !b || err != nil {
+		log.Info("SetExpire had run (%v,%v)", b, err)
+		return
+	}
+
+	s.dao.SetExpire(now)
+
+	s.dao.DelLockCache(c, model.SetExpireLockKey)
+}
+
+// CountExpire .
+func (s *AnchorRewardService) CountExpire() {
+	var (
+		c        = context.TODO()
+		now      = time.Now()
+		interval = int64(60)
+	)
+
+	log.Info("expireCount start (%v)", now)
+	if b, err := s.dao.SetNxLock(c, model.CountExpireLockKey, interval-1); !b || err != nil {
+		log.Info("expireCount had run (%v,%v)", b, err)
+		return
+	}
+
+	// do Count
+	s.dao.CountExpire(interval, now)
+
+	s.dao.DelLockCache(c, model.CountExpireLockKey)
+	log.Info("expireCount end (%v)", time.Now())
+}
+
+// UseRecord implementation
+// * (主播侧)-奖励使用记录(登录态)
+func (s *AnchorRewardService) UseRecord(ctx context.Context, req *v1pb.AnchorTaskUseRecordReq) (resp *v1pb.AnchorTaskUseRecordResp, err error) {
+	resp = &v1pb.AnchorTaskUseRecordResp{}
+	resp.Data = []*v1pb.AnchorTaskUseRecordResp_RewardObj{}
+	resp.Page = &v1pb.AnchorTaskUseRecordResp_Page{}
+
+	uid := req.GetUid()
+	if 0 == uid {
+		err = ecode.NoLogin
+		return
+	}
+
+	iPage := req.GetPage()
+	if iPage <= 0 {
+		iPage = 1
+	}
+
+	pager, list, err := s.dao.GetByUidPage(ctx, uid, iPage, PageSize, []int64{model.RewardExpired, model.RewardUsed})
+	//spew.Dump(pager)
+	if nil != err {
+		log.Error("%v\n", err)
+		err = ecode.Error(ecode.ServerErr, "内部错误4")
+		return
+	}
+
+	if pager == nil || list == nil {
+		log.Error("xrc.GetByUidPage nil pager (%v) list (%v)", pager, list)
+	}
+
+	//spew.Dump(list)
+	for _, v := range list {
+		resp.Data = append(resp.Data, &v1pb.AnchorTaskUseRecordResp_RewardObj{
+			Id:          v.Id,
+			RewardId:    v.RewardId,
+			Status:      v.Status,
+			Name:        v.Name,
+			Icon:        v.Icon,
+			AchieveTime: v.AchieveTime,
+			UseTime:     v.UseTime,
+			ExpireTime:  v.ExpireTime,
+			Source:      v.Source,
+			RewardIntro: v.RewardIntro,
+		})
+	}
+
+	resp.Page = &v1pb.AnchorTaskUseRecordResp_Page{
+		Page:       pager.Page,
+		PageSize:   pager.PageSize,
+		TotalPage:  pager.TotalPage,
+		TotalCount: pager.TotalCount,
+	}
+	//spew.Dump(resp)
+	return
+}
+
+// UseReward implementation
+// * (主播侧)-使用奖励(登录态)
+//
+func (s *AnchorRewardService) UseReward(ctx context.Context, req *v1pb.AnchorTaskUseRewardReq) (resp *v1pb.AnchorTaskUseRewardResp, err error) {
+	resp = &v1pb.AnchorTaskUseRewardResp{}
+	resp.Result = int64(0)
+
+	uid := req.GetUid()
+	if uid <= 0 {
+		err = ecode.NoLogin
+		return
+	}
+
+	id := req.GetId()
+	if id <= 0 {
+		err = ecode.Error(1, "id不合法")
+		return
+	}
+
+	aReward, err := s.dao.GetById(id)
+	log.Info("useReward reward(%+v), id(%v), uid(%v)", aReward, uid, id)
+
+	if err != nil || aReward == nil {
+		err = ecode.Error(5, "奖励不存在")
+		return
+	}
+
+	if uid != aReward.Uid {
+		err = ecode.Error(1, "参数错误")
+		return
+	}
+
+	if aReward.Status == model.RewardExpired {
+		err = ecode.Error(2, "这个奖励已经过期了呢")
+		return
+	}
+
+	if aReward.Status == model.RewardUsed {
+		err = ecode.Error(3, "这个奖励已经被你使用啦~")
+		return
+	}
+
+	if aReward.Status != model.RewardUnUsed {
+		err = ecode.Error(1, "奖励不可用")
+		return
+	}
+
+	reply, err := dao.RoomAPI.V2Room.GetByIds(ctx, &v2.RoomGetByIdsReq{Ids: []int64{int64(aReward.Roomid)}})
+
+	if err != nil {
+		log.Error("call V2Room.GetByIds(%v) error(%v)", aReward.Roomid, err)
+		err = errors.Wrap(ecode.Error(-500, "内部错误"), err.Error())
+		return
+	}
+	log.Info("call V2Room.GetByIds (%+v) succ (%+v)", aReward.Roomid, reply)
+
+	if nil == reply || nil == reply.GetData() {
+		log.Error("call V2Room.GetByIds roomid(%v) return nil(%+v)", aReward.Roomid, reply)
+		err = ecode.Error(-500, "内部错误")
+		return
+	}
+
+	if reply.GetData()[aReward.Roomid].LiveStatus != 1 {
+		err = ecode.Error(4, "为了更好的使用体验，请在开播状态下使用【任意门】哦~")
+		return
+	}
+
+	rst, err := s.dao.UseReward(id, req.GetUsePlat())
+
+	if err != nil || !rst {
+		err = ecode.Error(-500, "内部错误")
+		return
+	}
+
+	smallTvReq := &v0.SmalltvStartReq{
+		Uid:     uid,
+		Roomid:  aReward.Roomid,
+		GiftId:  GiftIDRenYiMen,
+		Num:     1,
+		Tid:     0,
+		StyleId: 5,
+	}
+	// 小电视抽奖
+	replyGift, err := dao.GiftAPI.V0Smalltv.Start(ctx, smallTvReq)
+
+	if err != nil {
+		log.Error("call V0Smalltv(%v) error(%v)", smallTvReq, err)
+	} else {
+		log.Info("call V0Smalltv (%+v) succ (%+v)", smallTvReq, replyGift)
+	}
+
+	resp.Result = int64(1)
+
+	return
+}
+
+// IsViewed implementation
+// * (主播侧)-奖励和任务红点(登录态)
+//
+func (s *AnchorRewardService) IsViewed(ctx context.Context, req *v1pb.AnchorTaskIsViewedReq) (resp *v1pb.AnchorTaskIsViewedResp, err error) {
+	resp = &v1pb.AnchorTaskIsViewedResp{}
+	uid := req.GetUid()
+	if uid <= 0 {
+		err = ecode.Error(1, "uid不合法")
+		return
+	}
+
+	resp.RewardShouldNotice, _ = s.dao.HasNewReward(ctx, uid)
+	resp.ShowRewardEntry, _ = s.dao.HasReward(ctx, uid)
+	resp.Url = "https://live.bilibili.com/p/html/live-app-award/index.html?is_live_webview=1"
+	return
+}
+
+// AddReward implementation
+// (主播侧)-添加主播奖励(内部接口)
+// `method:"POST" internal:"true"`
+func (s *AnchorRewardService) AddReward(ctx context.Context, req *v1pb.AnchorTaskAddRewardReq) (resp *v1pb.AnchorTaskAddRewardResp, err error) {
+	resp = &v1pb.AnchorTaskAddRewardResp{}
+
+	lifespan := req.GetLifespan()
+	if lifespan <= 0 {
+		lifespan = DefaultLifespan
+	}
+
+	exist, err := s.dao.CheckOrderID(ctx, req.GetOrderId())
+
+	if err != nil {
+		log.Error("addReward(%+v) error(%v)", req, err)
+		resp.Result = int64(0)
+		err = nil
+		return
+	}
+
+	if exist == model.RewardExists {
+		err = ecode.Error(1,
+			"order already exists!",
+		)
+		return
+	}
+
+	// 红点, 入口
+	s.dao.AddReward(ctx, req.GetRewardId(), req.GetUid(), req.GetSource(), req.GetRoomid(), lifespan)
+
+	// 广播
+	err = s.dao.SendBroadcastV2(ctx, req.GetUid(), req.GetRoomid(), req.GetRewardId())
+	if err != nil {
+		log.Error("SendBroadcast(%v) error(%v)", req, err)
+	}
+
+	if err != nil {
+		resp.Result = int64(0)
+	} else {
+		resp.Result = int64(1)
+		s.dao.SaveOrderID(ctx, req.GetOrderId())
+	}
+
+	return
+}

app/service/live/xrewardcenter/service/v1/anchorReward_test.go

@@ -0,0 +1,110 @@
+package v1
+
+import (
+	"flag"
+	. "github.com/smartystreets/goconvey/convey"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"go-common/app/service/live/xrewardcenter/api/grpc/v1"
+	"go-common/app/service/live/xrewardcenter/conf"
+	"testing"
+)
+
+var (
+	AnchorReward *AnchorRewardService
+)
+
+func init() {
+	flag.Set("conf", "../../cmd/test.toml")
+	var err error
+	if err = conf.Init(); err != nil {
+		panic(err)
+	}
+	AnchorReward = NewAnchorTaskService(conf.Conf)
+}
+
+// go test  -test.v -test.run TestAnchorRewardService_MyReward
+func TestAnchorRewardService_MyReward(t *testing.T) {
+	Convey("TestMyReward", t, func() {
+
+		ctx := metadata.NewContext(bm.Context{}, metadata.MD{
+			"mid": 10000,
+		})
+
+		res, err := AnchorReward.MyReward(ctx, &v1.AnchorTaskMyRewardReq{
+			Page: 1,
+			Uid:  10000,
+		})
+		t.Logf("%+v", res)
+		So(err, ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestIsViewed
+func TestAnchorRewardService_IsViewed(t *testing.T) {
+	Convey("TestAnchorRewardService_IsViewed", t, func() {
+
+		ctx := metadata.NewContext(bm.Context{}, metadata.MD{
+			"mid": 10000,
+		})
+
+		res, err := AnchorReward.IsViewed(ctx, &v1.AnchorTaskIsViewedReq{
+			Uid: 10000,
+		})
+		t.Logf("%+v", res)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestAnchorRewardService_UseRecord(t *testing.T) {
+	Convey("TestAnchorRewardService_UseRecord", t, func() {
+		ctx := metadata.NewContext(bm.Context{}, metadata.MD{
+			"mid": 10000,
+		})
+
+		res, err := AnchorReward.UseRecord(ctx, &v1.AnchorTaskUseRecordReq{
+			Page: 0,
+			Uid:  10000,
+		})
+		t.Logf("%+v", res)
+
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestAnchorRewardService_UseReward(t *testing.T) {
+	Convey("TestAnchorRewardService_UseReward", t, func() {
+		ctx := metadata.NewContext(bm.Context{}, metadata.MD{
+			"mid": 10000,
+		})
+
+		res, err := AnchorReward.UseReward(ctx, &v1.AnchorTaskUseRewardReq{
+			Id:      1,
+			Uid:     10000,
+			UsePlat: "ios",
+		})
+		t.Logf("%+v", res)
+
+		So(err, ShouldNotBeNil)
+	})
+}
+
+func TestAnchorRewardService_AddReward(t *testing.T) {
+	Convey("TestAnchorRewardService_AddReward", t, func() {
+		ctx := metadata.NewContext(bm.Context{}, metadata.MD{
+			"mid": 10000,
+		})
+
+		res, err := AnchorReward.AddReward(ctx, &v1.AnchorTaskAddRewardReq{
+			RewardId: 1,
+			Roomid:   1,
+			Source:   1,
+			Uid:      10000,
+			OrderId:  "test",
+		})
+		t.Logf("%+v", res)
+
+		So(err, ShouldBeNil)
+	})
+}