Create & Init Project...

app/job/main/account-summary/dao/BUILD

@@ -0,0 +1,65 @@
+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.go",
+        "member.go",
+        "passport.go",
+        "relation.go",
+        "summary.go",
+    ],
+    importpath = "go-common/app/job/main/account-summary/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/account-summary/conf:go_default_library",
+        "//app/job/main/account-summary/model:go_default_library",
+        "//app/service/main/member/api/gorpc:go_default_library",
+        "//app/service/main/relation/rpc/client:go_default_library",
+        "//library/database/hbase.v2:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//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_test.go",
+        "member_test.go",
+        "passport_test.go",
+        "relation_test.go",
+        "summary_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/account-summary/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/job/main/account-summary/dao/dao.go

@@ -0,0 +1,49 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/job/main/account-summary/conf"
+	member "go-common/app/service/main/member/api/gorpc"
+	relation "go-common/app/service/main/relation/rpc/client"
+	"go-common/library/database/sql"
+	bm "go-common/library/net/http/blademaster"
+
+	"go-common/library/database/hbase.v2"
+)
+
+// Dao dao
+type Dao struct {
+	c               *conf.Config
+	AccountSumHBase *hbase.Client
+	MemberService   *member.Service
+	RelationService *relation.Service
+	httpClient      *bm.Client
+	MemberDB        *sql.DB
+	RelationDB      *sql.DB
+	PassportDB      *sql.DB
+}
+
+// New init mysql db
+func New(c *conf.Config) *Dao {
+	dao := &Dao{
+		c:               c,
+		AccountSumHBase: hbase.NewClient(c.AccountSummaryHBase),
+		MemberService:   member.New(c.MemberService),
+		RelationService: relation.New(c.RelationService),
+		httpClient:      bm.NewClient(c.HTTPClient),
+		MemberDB:        sql.NewMySQL(c.MemberDB),
+		RelationDB:      sql.NewMySQL(c.RelationDB),
+		PassportDB:      sql.NewMySQL(c.PassportDB),
+	}
+	return dao
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+}
+
+// Ping dao ping
+func (d *Dao) Ping(ctx context.Context) error {
+	return nil
+}

app/job/main/account-summary/dao/dao_test.go

@@ -0,0 +1,33 @@
+package dao
+
+import (
+	"flag"
+	"go-common/app/job/main/account-summary/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account.account-summary")
+		flag.Set("conf_token", "5761c1b876ef2941fe4b63f621b3d74a")
+		flag.Set("tree_id", "51697")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}

app/job/main/account-summary/dao/member.go

@@ -0,0 +1,133 @@
+package dao
+
+// import (
+// 	"context"
+// 	"fmt"
+
+// 	"go-common/app/job/main/account-summary/model"
+// 	member "go-common/app/service/main/member/model"
+// 	"go-common/library/log"
+
+// 	"github.com/pkg/errors"
+// )
+
+// const (
+// 	_AllBase     = `SELECT mid,name,sex,face,sign,rank FROM user_base_%02d`
+// 	_AllExp      = `SELECT mid,exp FROM user_exp_%02d`
+// 	_AllOfficial = `SELECT mid,role,title,description FROM user_official`
+// )
+
+// func (d *Dao) allMemberBaseFromTable(ctx context.Context, no int64) ([]*model.MemberBase, error) {
+// 	rows, err := d.MemberDB.Query(ctx, fmt.Sprintf(_AllBase, no))
+// 	if err != nil {
+// 		return nil, errors.WithStack(err)
+// 	}
+// 	defer rows.Close()
+
+// 	res := make([]*model.MemberBase, 0)
+// 	for rows.Next() {
+// 		mb := &member.BaseInfo{}
+// 		if err = rows.Scan(&mb.Mid, &mb.Name, &mb.Sex, &mb.Face, &mb.Sign, &mb.Rank); err != nil {
+// 			log.Error("Failed to scan row in query all member base: %+v", err)
+// 			err = nil
+// 			continue
+// 		}
+// 		mb.RandFaceURL()
+
+// 		b := &model.MemberBase{
+// 			EmbedMid: model.EmbedMid{Mid: mb.Mid},
+// 			Birthday: model.Date(mb.Birthday),
+// 			Face:     mb.Face,
+// 			Name:     mb.Name,
+// 			Rank:     mb.Rank,
+// 			Sex:      mb.Sex,
+// 			Sign:     mb.Sign,
+// 		}
+// 		res = append(res, b)
+// 	}
+
+// 	return res, nil
+// }
+
+// func (d *Dao) allMemberExpFromTable(ctx context.Context, no int64) ([]*model.MemberExp, error) {
+// 	rows, err := d.MemberDB.Query(ctx, fmt.Sprintf(_AllExp, no))
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	defer rows.Close()
+
+// 	res := make([]*model.MemberExp, 0)
+// 	for rows.Next() {
+// 		mid := int64(0)
+// 		exp := int64(0)
+// 		if err = rows.Scan(&mid, &exp); err != nil {
+// 			log.Error("Failed to scan row in query all member exp: %+v", err)
+// 			err = nil
+// 			continue
+// 		}
+
+// 		e := &model.MemberExp{
+// 			EmbedMid: model.EmbedMid{Mid: mid},
+// 			Exp:      exp / 100,
+// 		}
+// 		res = append(res, e)
+// 	}
+
+// 	return res, nil
+// }
+
+// // AllMemberBase is
+// func (d *Dao) AllMemberBase(ctx context.Context) <-chan []*model.MemberBase {
+// 	resCh := make(chan []*model.MemberBase)
+// 	go func() {
+// 		for i := 0; i < 100; i++ {
+// 			res, err := d.allMemberBaseFromTable(context.Background(), int64(i))
+// 			if err != nil {
+// 				log.Error("Failed to get all member base from table with table id: %d: %+v", i, err)
+// 				continue
+// 			}
+// 			resCh <- res
+// 		}
+// 		close(resCh)
+// 	}()
+// 	return resCh
+// }
+
+// // AllMemberExp is
+// func (d *Dao) AllMemberExp(ctx context.Context) <-chan []*model.MemberExp {
+// 	resCh := make(chan []*model.MemberExp)
+// 	go func() {
+// 		for i := 0; i < 100; i++ {
+// 			res, err := d.allMemberExpFromTable(context.Background(), int64(i))
+// 			if err != nil {
+// 				log.Error("Failed to get all member exp from table with table id: %d: %+v", i, err)
+// 				continue
+// 			}
+// 			resCh <- res
+// 		}
+// 		close(resCh)
+// 	}()
+// 	return resCh
+// }
+
+// // AllOfficial is
+// func (d *Dao) AllOfficial(ctx context.Context) ([]*model.MemberOfficial, error) {
+// 	rows, err := d.MemberDB.Query(ctx, _AllOfficial)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	defer rows.Close()
+
+// 	res := make([]*model.MemberOfficial, 0)
+// 	for rows.Next() {
+// 		o := &model.MemberOfficial{}
+// 		if err = rows.Scan(&o.Mid, &o.Role, &o.Title, &o.Description); err != nil {
+// 			log.Error("Failed to scan row in query all member official: %+v", err)
+// 			err = nil
+// 			continue
+// 		}
+// 		res = append(res, o)
+// 	}
+
+// 	return res, nil
+// }

app/job/main/account-summary/dao/member_test.go

@@ -0,0 +1 @@
+package dao

app/job/main/account-summary/dao/passport.go

@@ -0,0 +1,51 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/app/job/main/account-summary/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	queryByMidURI = "/intranet/acc/queryByMid"
+
+	// _AsoAccountByMid          = `SELECT mid,email FROM aso_account WHERE mid=?`
+	// _AsoAccountInfoByMid      = `SELECT mid,join_ip,join_time FROM aso_account_info%d WHERE mid=?`
+	_AsoAccountRegOriginByMid = `SELECT mid,origintype,regtype FROM aso_account_reg_origin_%d WHERE mid=?`
+	// _AllCountryID  = `SELECT id,code FROM aso_country_code`
+)
+
+// PassportProfile is
+func (d *Dao) PassportProfile(ctx context.Context, mid int64) (*model.PassportProfile, error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+
+	var res struct {
+		Code int                    `json:"code"`
+		Data *model.PassportProfile `json:"data"`
+	}
+	if err := d.httpClient.Get(ctx, d.c.Host.Passport+queryByMidURI, "", params, &res); err != nil {
+		log.Error("Failed to query by mid: %+v: %+v", params, err)
+		return nil, err
+	}
+	if res.Code != 0 {
+		log.Error("Failed to query by mid with code: %+v: %d", params, res.Code)
+		return nil, ecode.Int(res.Code)
+	}
+	return res.Data, nil
+}
+
+// AsoAccountRegOrigin is
+func (d *Dao) AsoAccountRegOrigin(ctx context.Context, mid int64) (*model.AsoAccountRegOrigin, error) {
+	row := d.PassportDB.QueryRow(ctx, fmt.Sprintf(_AsoAccountRegOriginByMid, mid%20), mid)
+	origin := new(model.AsoAccountRegOrigin)
+	if err := row.Scan(&origin.Mid, &origin.OriginType, &origin.RegType); err != nil {
+		return nil, err
+	}
+	return origin, nil
+}

app/job/main/account-summary/dao/passport_test.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoPassportProfile(t *testing.T) {
+	var (
+		// ctx = context.Background()
+		mid = int64(0)
+	)
+	convey.Convey("PassportProfile", t, func(ctx convey.C) {
+		p1, err := d.PassportProfile(context.TODO(), mid)
+		ctx.Convey("Then err should be nil.p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoAsoAccountRegOrigin(t *testing.T) {
+	var (
+		// ctx = context.Background()
+		mid = int64(0)
+	)
+	convey.Convey("AsoAccountRegOrigin", t, func(ctx convey.C) {
+		p1, err := d.AsoAccountRegOrigin(context.TODO(), mid)
+		ctx.Convey("Then err should be nil.p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}

app/job/main/account-summary/dao/relation.go

@@ -0,0 +1,51 @@
+package dao
+
+// import (
+// 	"context"
+// 	"fmt"
+
+// 	"go-common/app/job/main/account-summary/model"
+// 	"go-common/library/log"
+// )
+
+// var (
+// 	_AllStat = `SELECT mid,following,whisper,black,follower FROM user_relation_stat_%02d`
+// )
+
+// func (d *Dao) allRelationStatFromTable(ctx context.Context, no int64) ([]*model.RelationStat, error) {
+// 	rows, err := d.RelationDB.Query(ctx, fmt.Sprintf(_AllStat, no))
+// 	if err != nil {
+// 		return nil, err
+// 	}
+
+// 	res := make([]*model.RelationStat, 0)
+// 	defer rows.Close()
+// 	for rows.Next() {
+// 		rs := &model.RelationStat{}
+// 		if err = rows.Scan(&rs.Mid, &rs.Following, &rs.Whisper, &rs.Black, &rs.Follower); err != nil {
+// 			log.Error("Failed to scan row in query all relation stat: %+v", err)
+// 			err = nil
+// 			continue
+// 		}
+// 		res = append(res, rs)
+// 	}
+
+// 	return res, nil
+// }
+
+// // AllRelationStat is
+// func (d *Dao) AllRelationStat(ctx context.Context) <-chan []*model.RelationStat {
+// 	resCh := make(chan []*model.RelationStat)
+// 	go func() {
+// 		for i := 0; i < 50; i++ {
+// 			res, err := d.allRelationStatFromTable(ctx, int64(i))
+// 			if err != nil {
+// 				log.Error("Failed to get all relation stat from table with table id: %d: %+v", i, err)
+// 				continue
+// 			}
+// 			resCh <- res
+// 		}
+// 		close(resCh)
+// 	}()
+// 	return resCh
+// }

app/job/main/account-summary/dao/relation_test.go

@@ -0,0 +1 @@
+package dao

app/job/main/account-summary/dao/summary.go

@@ -0,0 +1,100 @@
+package dao
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/job/main/account-summary/model"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_SummaryTable = "ugc:AccountSum"
+	_ColFamily    = "accountsum"
+)
+
+// Save is
+func (d *Dao) Save(ctx context.Context, key string, data map[string][]byte) error {
+	values := map[string]map[string][]byte{
+		_ColFamily: data,
+	}
+	_, err := d.AccountSumHBase.PutStr(ctx, _SummaryTable, key, values)
+	return err
+}
+
+// GetByKey is
+func (d *Dao) GetByKey(ctx context.Context, key string) (*model.AccountSummary, error) {
+	res, err := d.AccountSumHBase.GetStr(ctx, _SummaryTable, key)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	sum := model.NewAccountSummary()
+	for _, c := range res.Cells {
+		v := string(c.Value)
+		switch string(c.Qualifier) {
+		case "birthday":
+			sum.Birthday = v
+		case "face":
+			sum.Face = v
+		case "mid":
+			sum.Mid, _ = strconv.ParseInt(v, 10, 64)
+		case "name":
+			sum.Name = v
+		case "rank":
+			sum.Rank, _ = strconv.ParseInt(v, 10, 64)
+		case "sex":
+			sum.Sex, _ = strconv.ParseInt(v, 10, 64)
+		case "sign":
+			sum.Sign = v
+		case "official.role":
+			sum.Official.Role, _ = strconv.ParseInt(v, 10, 64)
+		case "official.mid":
+			sum.Official.Mid, _ = strconv.ParseInt(v, 10, 64)
+		case "official.title":
+			sum.Official.Title = v
+		case "official.description":
+			sum.Official.Description = v
+		case "exp.mid":
+			sum.Exp.Mid, _ = strconv.ParseInt(v, 10, 64)
+		case "exp.exp":
+			sum.Exp.Exp, _ = strconv.ParseInt(v, 10, 64)
+		case "relation.mid":
+			sum.RelationStat.Mid, _ = strconv.ParseInt(v, 10, 64)
+		case "relation.follower":
+			sum.RelationStat.Follower, _ = strconv.ParseInt(v, 10, 64)
+		case "relation.following":
+			sum.RelationStat.Following, _ = strconv.ParseInt(v, 10, 64)
+		case "relation.black":
+			sum.RelationStat.Black, _ = strconv.ParseInt(v, 10, 64)
+		case "relation.whisper":
+			sum.RelationStat.Whisper, _ = strconv.ParseInt(v, 10, 64)
+		case "block.mid":
+			sum.Block.Mid, _ = strconv.ParseInt(v, 10, 64)
+		case "block.block_status":
+			sum.Block.BlockStatus, _ = strconv.ParseInt(v, 10, 64)
+		case "block.start_time":
+			sum.Block.StartTime = v
+		case "block.end_time":
+			sum.Block.EndTime = v
+		case "passport.mid":
+			sum.Passport.Mid, _ = strconv.ParseInt(v, 10, 64)
+		case "passport.tel_status":
+			sum.Passport.TelStatus, _ = strconv.ParseInt(v, 10, 64)
+		case "passport.country_id":
+			sum.Passport.CountryID, _ = strconv.ParseInt(v, 10, 64)
+		case "passport.join_ip":
+			sum.Passport.JoinIP = v
+		case "passport.join_time":
+			sum.Passport.JoinTime = v
+		case "passport.email_suffix":
+			sum.Passport.EmailSuffix = v
+		case "passport.origin_type":
+			sum.Passport.OriginType, _ = strconv.ParseInt(v, 10, 64)
+		case "passport.reg_type":
+			sum.Passport.RegType, _ = strconv.ParseInt(v, 10, 64)
+		}
+	}
+	return sum, nil
+}

app/job/main/account-summary/dao/summary_test.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoSave(t *testing.T) {
+	var (
+		// ctx  = context.Background()·
+		key  = ""
+		data map[string][]byte
+	)
+	convey.Convey("Save", t, func(ctx convey.C) {
+		err := d.Save(context.TODO(), key, data)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoGetByKey(t *testing.T) {
+	var (
+		// ctx = context.Background()
+		key = ""
+	)
+	convey.Convey("GetByKey", t, func(ctx convey.C) {
+		p1, err := d.GetByKey(context.TODO(), key)
+		ctx.Convey("Then err should be nil.p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}