Create & Init Project...

app/admin/main/credit/dao/search/BUILD

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

app/admin/main/credit/dao/search/dao.go

@@ -0,0 +1,226 @@
+package search
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/app/admin/main/credit/model"
+	"go-common/app/admin/main/credit/model/blocked"
+	"go-common/app/admin/main/credit/model/search"
+	"go-common/library/database/elastic"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao .
+type Dao struct {
+	elastic *elastic.Elastic
+}
+
+// New .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		elastic: elastic.NewElastic(nil),
+	}
+	return
+}
+
+// Blocked get search blocked.
+func (d *Dao) Blocked(c context.Context, arg *blocked.ArgBlockedSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedInfo).Index(blocked.TableBlockedInfo).Fields("id")
+	if arg.Keyword != blocked.SearchDefaultString {
+		req.WhereLike([]string{"origin_content"}, []string{arg.Keyword}, true, elastic.LikeLevelHigh)
+	}
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("uid", arg.UID)
+	}
+	if arg.OPID != blocked.SearchDefaultNum {
+		req.WhereEq("oper_id", arg.OPID)
+	}
+	if arg.OriginType != blocked.SearchDefaultNum {
+		req.WhereEq("origin_type", arg.OriginType)
+	}
+	if arg.BlockedType != blocked.SearchDefaultNum {
+		req.WhereEq("blocked_type", arg.BlockedType)
+	}
+	if arg.PublishStatus != blocked.SearchDefaultNum {
+		req.WhereEq("publish_status", arg.PublishStatus)
+	}
+	req.WhereRange("punish_time", arg.Start, arg.End, elastic.RangeScopeLcRc)
+	req.WhereEq("status", blocked.SearchDefaultStatus)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Publish get search publish.
+func (d *Dao) Publish(c context.Context, arg *blocked.ArgPublishSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedPublish).Index(blocked.TableBlockedPublish).Fields("id")
+	if arg.Keyword != blocked.SearchDefaultString {
+		req.WhereLike([]string{"title", "sub_title"}, []string{arg.Keyword}, true, elastic.LikeLevelHigh)
+	}
+	if arg.Type != blocked.SearchDefaultNum {
+		req.WhereEq("ptype", arg.Type)
+	}
+	req.WhereRange("show_time", arg.ShowFrom, arg.ShowTo, elastic.RangeScopeLcRc)
+	req.WhereEq("status", blocked.SearchDefaultStatus)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Case get search case.
+func (d *Dao) Case(c context.Context, arg *blocked.ArgCaseSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedCase).Index(blocked.TableBlockedCase).Fields("id")
+	if arg.Keyword != blocked.SearchDefaultString {
+		req.WhereLike([]string{"origin_content"}, []string{arg.Keyword}, true, elastic.LikeLevelHigh)
+	}
+	if arg.OriginType != blocked.SearchDefaultNum {
+		req.WhereEq("origin_type", arg.OriginType)
+	}
+	if arg.Status != blocked.SearchDefaultNum {
+		req.WhereEq("status", arg.Status)
+	}
+	if arg.CaseType != blocked.SearchDefaultNum {
+		req.WhereEq("case_type", arg.CaseType)
+	}
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.OPID != blocked.SearchDefaultNum {
+		req.WhereEq("oper_id", arg.OPID)
+	}
+	req.WhereRange("start_time", arg.TimeFrom, arg.TimeTo, elastic.RangeScopeLcRc)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Jury get search jury.
+func (d *Dao) Jury(c context.Context, arg *blocked.ArgJurySearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedJury).Index(blocked.TableBlockedJury).Fields("id")
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.Status != blocked.SearchDefaultNum {
+		req.WhereEq("status", arg.Status)
+	}
+	if arg.Black != blocked.SearchDefaultNum {
+		req.WhereEq("black", arg.Black)
+	}
+	req.WhereRange("expired", arg.ExpiredFrom, arg.ExpiredTo, elastic.RangeScopeLcRc)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Opinion get search opinion.
+func (d *Dao) Opinion(c context.Context, arg *blocked.ArgOpinionSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedOpinion).Index(blocked.TableBlockedOpinion).Fields("id")
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.CID != blocked.SearchDefaultNum {
+		req.WhereEq("cid", arg.CID)
+	}
+	if arg.Vote != blocked.SearchDefaultNum {
+		req.WhereEq("vote", arg.Vote)
+	}
+	if arg.State != blocked.SearchDefaultNum {
+		req.WhereEq("state", arg.State)
+	}
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// KPIPoint get search kpi point.
+func (d *Dao) KPIPoint(c context.Context, arg *blocked.ArgKpiPointSearch) (ids []int64, pager *blocked.Pager, err error) {
+	var (
+		dayFromT, dayToT time.Time
+		dayFrom, dayTo   string
+	)
+	req := d.elastic.NewRequest(blocked.BusinessBlockedKpiPoint).Index(blocked.TableBlockedKpiPoint).Fields("id")
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.Start != blocked.SearchDefaultString {
+		if dayFromT, err = time.ParseInLocation(model.TimeFormatSec, arg.Start, time.Local); err != nil {
+			err = errors.Errorf("time.ParseInLocation(%s) error(%v)", arg.Start, err)
+			return
+		}
+		dayFrom = dayFromT.Format(model.TimeFormatDay)
+	}
+	if arg.End != blocked.SearchDefaultString {
+		if dayToT, err = time.ParseInLocation(model.TimeFormatSec, arg.End, time.Local); err != nil {
+			err = errors.Errorf("time.ParseInLocation(%s) error(%v)", arg.End, err)
+			return
+		}
+		dayTo = dayToT.Format(model.TimeFormatDay)
+	}
+	req.WhereRange("day", dayFrom, dayTo, elastic.RangeScopeLcRc)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// SearchUpdate update about seach data.
+func (d *Dao) SearchUpdate(c context.Context, appid string, table string, data []interface{}) (err error) {
+	us := d.elastic.NewUpdate(appid)
+	for _, v := range data {
+		us.AddData(table, v)
+	}
+	if err = us.Do(c); err != nil {
+		log.Info("appid(%s) table(%s) params(%s) ip(%s) search blocked update error(%v)", appid, table, us.Params(), metadata.String(c, metadata.RemoteIP), err)
+	}
+	return
+}
+
+func pagerExtra(res *search.ReSearchData) (ids []int64, pager *blocked.Pager) {
+	for _, v := range res.Result {
+		ids = append(ids, v.ID)
+	}
+	if res.Page != nil {
+		pager = &blocked.Pager{
+			Total: res.Page.Total,
+			PN:    res.Page.PN,
+			PS:    res.Page.PS,
+			Sort:  res.Sort,
+			Order: res.Order,
+		}
+	}
+	return
+}

app/admin/main/credit/dao/search/dao_test.go

@@ -0,0 +1,114 @@
+package search
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/app/admin/main/credit/model/blocked"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestDao_Blocked(t *testing.T) {
+	arg := &blocked.ArgBlockedSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Blocked(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func TestDao_Publish(t *testing.T) {
+	arg := &blocked.ArgPublishSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Publish(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_Case(t *testing.T) {
+	arg := &blocked.ArgCaseSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Case(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_Jury(t *testing.T) {
+	arg := &blocked.ArgJurySearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Jury(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_Opinion(t *testing.T) {
+	arg := &blocked.ArgOpinionSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Opinion(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_KPIPoint(t *testing.T) {
+	arg := &blocked.ArgKpiPointSearch{Order: "id", Start: "2006-01-02 15:04:05", End: "2019-01-02 15:04:05"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.KPIPoint(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_BlockedUpdate(t *testing.T) {
+	single := map[string]interface{}{
+		"id":      1,
+		"oper_id": 1,
+		"status":  1,
+		"black":   1,
+	}
+	var multiple []interface{}
+	multiple = append(multiple, single)
+	Convey("return someting", t, func() {
+		err := d.SearchUpdate(context.TODO(), "block_info", "blocked_info", multiple)
+		So(err, ShouldBeNil)
+	})
+}