Create & Init Project...

app/service/main/workflow/dao/BUILD

@@ -0,0 +1,61 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "callback_test.go",
+        "dao_test.go",
+        "es_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/workflow/conf:go_default_library",
+        "//app/service/main/workflow/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "callback.go",
+        "dao.go",
+        "es.go",
+    ],
+    importpath = "go-common/app/service/main/workflow/dao",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/workflow/conf:go_default_library",
+        "//app/service/main/workflow/model:go_default_library",
+        "//library/database/elastic:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/main/workflow/dao/sobot:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/workflow/dao/callback.go

@@ -0,0 +1,21 @@
+package dao
+
+import (
+	"context"
+	"errors"
+
+	"go-common/app/service/main/workflow/model"
+	"go-common/library/log"
+)
+
+// Callback callback message
+func (d *Dao) Callback(c context.Context, chall *model.Challenge, businessID int8) (err error) {
+	if URL, ok := d.callbackMap[businessID]; ok {
+		if err = d.callback.Post(context.Background(), URL, "", nil, &chall); err != nil {
+			log.Error("d.CallbackSetting(%s) error(%v)", chall, err)
+			return
+		}
+		return
+	}
+	return errors.New("Callback cannot find businessID in callbackMap")
+}

app/service/main/workflow/dao/callback_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/service/main/workflow/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoCallback(t *testing.T) {
+	var (
+		c          = context.Background()
+		chall      = &model.Challenge{}
+		businessID = int8(6)
+	)
+	convey.Convey("Callback", t, func(ctx convey.C) {
+		err := d.Callback(c, chall, businessID)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/service/main/workflow/dao/dao.go

@@ -0,0 +1,81 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/service/main/workflow/conf"
+	"go-common/app/service/main/workflow/model"
+	"go-common/library/database/elastic"
+	"go-common/library/database/orm"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_mngTagURL     = "/x/admin/manager/internal/tag/list"
+	_mngControlURL = "/x/admin/manager/internal/control/list"
+)
+
+// Dao tag dao
+type Dao struct {
+	c *conf.Config
+	// db *sql.DB
+	DB *gorm.DB
+
+	callback    *bm.Client
+	callbackMap map[int8]string
+
+	ReadClient    *bm.Client
+	MngTagURL     string
+	MngControlURL string
+	es            *elastic.Elastic
+}
+
+// New init dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:             c,
+		DB:            orm.NewMySQL(c.ORM.Write),
+		callback:      bm.NewClient(c.HTTPClient.Write),
+		callbackMap:   make(map[int8]string),
+		ReadClient:    bm.NewClient(c.HTTPClient.Read),
+		MngTagURL:     c.Host.ManagerURI + _mngTagURL,
+		MngControlURL: c.Host.ManagerURI + _mngControlURL,
+		es:            elastic.NewElastic(c.Elastic),
+	}
+	d.initORM()
+	d.initCallback()
+	return
+}
+
+func (d *Dao) initORM() {
+	d.DB.LogMode(true)
+}
+
+func (d *Dao) initCallback() {
+	callbacks := []model.Callback{}
+	if err := d.DB.Where("state =?", model.Enabled).Find(&callbacks).Error; err != nil {
+		log.Error("d.CallbackSetting() error(%v)", err)
+		panic(err)
+	}
+	for _, callback := range callbacks {
+		d.callbackMap[callback.Business] = callback.URL
+	}
+}
+
+// Close close dao.
+func (d *Dao) Close() {
+	if d.DB != nil {
+		d.DB.Close()
+	}
+}
+
+// Ping ping cpdb
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.DB != nil {
+		err = d.DB.DB().PingContext(c)
+	}
+	return
+}

app/service/main/workflow/dao/dao_test.go

@@ -0,0 +1,51 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/workflow/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.manager.workflow-service")
+		flag.Set("conf_token", "410a3a978eeda5cf44b66f193708c283")
+		flag.Set("tree_id", "6791")
+		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/workflow-service.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	d.callbackMap = map[int8]string{6: "http://uat-manager.bilibili.co/api/v4/archive/ticket/callback"}
+	os.Exit(m.Run())
+}
+
+func TestPing(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.Ping(c)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/service/main/workflow/dao/es.go

@@ -0,0 +1,20 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/library/log"
+)
+
+// UpdateUserTag 更新举报对象的第一个用户tag
+func (d *Dao) UpdateUserTag(c context.Context, gid int64, userTid int32) (err error) {
+	us := d.es.NewUpdate("workflow_group_common").Insert()
+	data := map[string]int64{"id": gid, "first_user_tid": int64(userTid)}
+	us.AddData("workflow_group_common", data)
+	if err = us.Do(c); err != nil {
+		log.Error("failed upsert elastic error(%v)", err)
+		return
+	}
+	log.Info("gid(%d) has first user complain tid(%d) success upsert", gid, userTid)
+	return
+}

app/service/main/workflow/dao/es_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoUpdateUserTag(t *testing.T) {
+	convey.Convey("UpdateUserTag", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			gid     = int64(1)
+			userTid = int32(1)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.UpdateUserTag(c, gid, userTid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/service/main/workflow/dao/sobot/BUILD

@@ -0,0 +1,54 @@
+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",
+        "sobot_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/workflow/conf:go_default_library",
+        "//app/service/main/workflow/model/sobot:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "sobot.go",
+    ],
+    importpath = "go-common/app/service/main/workflow/dao/sobot",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/workflow/conf:go_default_library",
+        "//app/service/main/workflow/model/sobot:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/main/workflow/dao/sobot/dao.go

@@ -0,0 +1,30 @@
+package sobot
+
+import (
+	"go-common/app/service/main/workflow/conf"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao it
+type Dao struct {
+	c               *conf.Config
+	ticketInfoURL   string
+	ticketAddURL    string
+	ticketModifyURL string
+	replyAddURL     string
+	// sobot httpclient
+	httpSobot *bm.Client
+}
+
+// New Dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:               c,
+		httpSobot:       bm.NewClient(c.HTTPClient.Sobot),
+		ticketInfoURL:   c.Host.ServiceURI + _sobotTicketInfoURL,
+		ticketAddURL:    c.Host.ServiceURI + _sobotAddTicketURL,
+		ticketModifyURL: c.Host.ServiceURI + _sobotTicketModifyURL,
+		replyAddURL:     c.Host.ServiceURI + _sobotAddReplyURL,
+	}
+	return
+}

app/service/main/workflow/dao/sobot/dao_test.go

@@ -0,0 +1,36 @@
+package sobot
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/workflow/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.manager.workflow-service")
+		flag.Set("conf_token", "410a3a978eeda5cf44b66f193708c283")
+		flag.Set("tree_id", "6791")
+		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/workflow-service.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}

app/service/main/workflow/dao/sobot/sobot.go

@@ -0,0 +1,160 @@
+package sobot
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go-common/library/log"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"go-common/app/service/main/workflow/model/sobot"
+)
+
+const (
+	_sobotTicketModifyURL = "/ws/updateStatusBilibili/4"
+	_sobotAddTicketURL    = "/ws/addCustomerTicketBilibili/4"
+	_sobotAddReplyURL     = "/ws/addCustomerReplyInfoBilibili/4"
+	_sobotTicketInfoURL   = "/ws/queryTicketReplyByCustomerListBilibili/4"
+)
+
+// SobotTicketInfo get ticket into
+func (d *Dao) SobotTicketInfo(c context.Context, ticketID int32) (res json.RawMessage, err error) {
+	var (
+		req *http.Request
+	)
+	params := url.Values{}
+	params.Set("companyId", d.c.HTTPClient.Sobot.Secret)
+	params.Set("ticketId", strconv.Itoa(int(ticketID)))
+	sign := md5.Sum([]byte(fmt.Sprintf("%s%s%d", d.c.HTTPClient.Sobot.Secret, d.c.HTTPClient.Sobot.Key, ticketID)))
+	params.Set("sobotKey", hex.EncodeToString(sign[:]))
+	if req, err = http.NewRequest("GET", d.ticketInfoURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("http.NewRequest(GET,%s) error(%v)", d.ticketInfoURL, err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if err = d.httpSobot.Do(c, req, &res); err != nil {
+		log.Error("d.httpSobot.Do() error(%v)", err)
+		return
+	}
+	return
+}
+
+// SobotAddTicket add ticket to sobot
+func (d *Dao) SobotAddTicket(c context.Context, tp *sobot.TicketParam) (err error) {
+	var (
+		req *http.Request
+		res struct {
+			RetCode string `json:"retCode"`
+			Item    string `json:"item"`
+		}
+	)
+	params := url.Values{}
+	params.Set("fileStr", tp.FileStr)
+	params.Set("companyId", d.c.HTTPClient.Sobot.Secret)
+	params.Set("customerName", tp.CustomerName)
+	params.Set("customerQq", tp.CustomerQQ)
+	params.Set("customerNick", tp.CustomerNick)
+	params.Set("customerEmail", tp.CustomerEmail)
+	params.Set("customerPhone", tp.CustomerPhone)
+	params.Set("customerSource", strconv.Itoa(int(tp.CustomerSource)))
+	params.Set("ticketId", strconv.Itoa(int(tp.TicketID)))
+	params.Set("ticketTitle", tp.TicketTitle)
+	params.Set("ticketContent", tp.TicketContent)
+	params.Set("ticketLevel", strconv.Itoa(int(tp.TicketLevel)))
+	params.Set("ticketStatus", strconv.Itoa(int(tp.TicketStatus)))
+	params.Set("ticketFrom", strconv.Itoa(int(sobot.TicketFrom)))
+	sign := md5.Sum([]byte(fmt.Sprintf("%s%s%d", d.c.HTTPClient.Sobot.Secret, d.c.HTTPClient.Sobot.Key, tp.TicketID)))
+	params.Set("sobotKey", hex.EncodeToString(sign[:]))
+	if req, err = http.NewRequest("POST", d.ticketAddURL, strings.NewReader(params.Encode())); err != nil {
+		log.Error("http.NewRequest(POST,%s) error(%v)", d.ticketAddURL, err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if err = d.httpSobot.Do(c, req, &res); err != nil {
+		log.Error("d.httpSobot.Do() error(%v)", err)
+		return
+	}
+	if res.RetCode != sobot.EcodeOK {
+		log.Error("d.httpSobot.Do() url(%s) ecode(%s)", d.ticketAddURL, res.RetCode)
+		err = errors.New(res.RetCode)
+		return
+	}
+	return
+}
+
+// SobotAddReply add reply to sobot
+func (d *Dao) SobotAddReply(c context.Context, rp *sobot.ReplyParam) (err error) {
+	var (
+		req *http.Request
+		res struct {
+			RetCode string `json:"retCode"`
+			Item    string `json:"item"`
+		}
+	)
+	params := url.Values{}
+	params.Set("companyId", d.c.HTTPClient.Sobot.Secret)
+	params.Set("customerEmail", rp.CustomerEmail)
+	params.Set("replyContent", rp.ReplyContent)
+	params.Set("ticketId", strconv.Itoa(int(rp.TicketID)))
+	params.Set("replyType", strconv.Itoa(int(rp.ReplyType)))
+	params.Set("startType", strconv.Itoa(int(rp.StartType)))
+	sign := md5.Sum([]byte(fmt.Sprintf("%s%s%d", d.c.HTTPClient.Sobot.Secret, d.c.HTTPClient.Sobot.Key, rp.TicketID)))
+	params.Set("sobotKey", hex.EncodeToString(sign[:]))
+	if req, err = http.NewRequest("POST", d.replyAddURL, strings.NewReader(params.Encode())); err != nil {
+		log.Error("http.NewRequest(POST,%s) error(%v)", d.replyAddURL, err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if err = d.httpSobot.Do(c, req, &res); err != nil {
+		log.Error("d.httpSobot.Do() error(%v)", err)
+		return
+	}
+	if res.RetCode != sobot.EcodeOK {
+		log.Error("d.httpSobot.Do() url(%s) ecode(%s)", d.replyAddURL, res.RetCode)
+		err = errors.New(res.RetCode)
+		return
+	}
+	return
+}
+
+// SobotTicketModify modify ticket
+func (d *Dao) SobotTicketModify(c context.Context, tp *sobot.TicketParam) (err error) {
+	// http
+	var (
+		req *http.Request
+		res struct {
+			RetCode string `json:"retCode"`
+			Item    string `json:"item"`
+		}
+	)
+	params := url.Values{}
+	params.Set("companyId", d.c.HTTPClient.Sobot.Secret)
+	params.Set("customerEmail", tp.CustomerEmail)
+	params.Set("ticketId", strconv.Itoa(int(tp.TicketID)))
+	params.Set("ticketFrom", strconv.Itoa(int(sobot.TicketFrom)))
+	params.Set("ticketStatus", strconv.Itoa(int(tp.TicketStatus)))
+	params.Set("startType", strconv.Itoa(int(tp.StartType)))
+	sign := md5.Sum([]byte(fmt.Sprintf("%s%s%d", d.c.HTTPClient.Sobot.Secret, d.c.HTTPClient.Sobot.Key, tp.TicketID)))
+	params.Set("sobotKey", hex.EncodeToString(sign[:]))
+	if req, err = http.NewRequest("POST", d.ticketModifyURL, strings.NewReader(params.Encode())); err != nil {
+		log.Error("http.NewRequest(POST,%s) error(%v)", d.ticketModifyURL, err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	if err = d.httpSobot.Do(c, req, &res); err != nil {
+		log.Error("d.httpSobot.Do() error(%v)", err)
+		return
+	}
+	if res.RetCode != sobot.EcodeOK {
+		log.Error("d.httpSobot.Do() url(%s) ecode(%s)", d.ticketModifyURL, res.RetCode)
+		err = errors.New(res.RetCode)
+		return
+	}
+	return
+}

app/service/main/workflow/dao/sobot/sobot_test.go

@@ -0,0 +1,78 @@
+package sobot
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/service/main/workflow/model/sobot"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestSobotSobotTicketInfo(t *testing.T) {
+	var (
+		c        = context.Background()
+		ticketID = int32(0)
+	)
+	convey.Convey("SobotTicketInfo", t, func(ctx convey.C) {
+		res, err := d.SobotTicketInfo(c, ticketID)
+		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 TestSobotSobotAddTicket(t *testing.T) {
+	var (
+		c  = context.Background()
+		tp = &sobot.TicketParam{
+			TicketTitle:   "我是202工单",
+			TicketID:      202,
+			TicketContent: "233333333",
+			CustomerEmail: "1107691251@qq.com",
+		}
+	)
+	convey.Convey("SobotAddTicket", t, func(ctx convey.C) {
+		err := d.SobotAddTicket(c, tp)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err.Error(), convey.ShouldEqual, "2000101")
+		})
+	})
+}
+
+func TestSobotSobotAddReply(t *testing.T) {
+	var (
+		c  = context.Background()
+		rp = &sobot.ReplyParam{
+			TicketID:      202,
+			ReplyContent:  "reply_test",
+			CustomerEmail: "1107691251@qq.com",
+			StartType:     1,
+			ReplyType:     1,
+		}
+	)
+	convey.Convey("SobotAddReply", t, func(ctx convey.C) {
+		err := d.SobotAddReply(c, rp)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestSobotSobotTicketModify(t *testing.T) {
+	var (
+		c  = context.Background()
+		tp = &sobot.TicketParam{
+			TicketID:      202,
+			CustomerEmail: "1107691251@qq.com",
+			StartType:     1,
+		}
+	)
+	convey.Convey("SobotTicketModify", t, func(ctx convey.C) {
+		err := d.SobotTicketModify(c, tp)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}