Create & Init Project...

app/admin/ep/marthe/dao/BUILD

@@ -0,0 +1,87 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "bugly.go",
+        "dao.go",
+        "mail.go",
+        "mysql_bugly_batch_run.go",
+        "mysql_bugly_cookie.go",
+        "mysql_bugly_issue.go",
+        "mysql_bugly_project.go",
+        "mysql_bugly_version.go",
+        "mysql_contact_info.go",
+        "mysql_schedule_task.go",
+        "mysql_tapd_bug_priority_conf.go",
+        "mysql_tapd_bug_record.go",
+        "mysql_tapd_bug_template.go",
+        "mysql_tapd_bug_version_template.go",
+        "mysql_user.go",
+        "tapd.go",
+        "wechat.go",
+    ],
+    importpath = "go-common/app/admin/ep/marthe/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/ep/marthe/conf:go_default_library",
+        "//app/admin/ep/marthe/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/sync/pipeline/fanout:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+        "//vendor/gopkg.in/gomail.v2: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",
+        "mysql_bugly_batch_run_test.go",
+        "mysql_bugly_cookie_test.go",
+        "mysql_bugly_issue_test.go",
+        "mysql_bugly_version_test.go",
+        "mysql_schedule_task_test.go",
+        "mysql_tapd_bug_priority_confg_test.go",
+        "mysql_tapd_bug_record_test.go",
+        "mysql_tapd_bug_template_test.go",
+        "mysql_tapd_bug_version_template_test.go",
+        "mysql_user_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/ep/marthe/conf:go_default_library",
+        "//app/admin/ep/marthe/model:go_default_library",
+        "//vendor/github.com/go-sql-driver/mysql:go_default_library",
+        "//vendor/github.com/satori/go.uuid:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)

app/admin/ep/marthe/dao/bugly.go

@@ -0,0 +1,192 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_buglyOkCode            = 200
+	_buglyCookieExpiredCode = 100006
+	_issueDetailCode        = 100000
+
+	_issueDetailList    = "/v2/lastCrashInfo/appId/%s/platformId/%s/issues/%s/crashDataType/null?offsetTop=56&fsn=6d0260aa-331f-48b9-8557-c2aaf6e0be90"
+	_issueList          = "/v2/issueList?sortOrder=desc&sortField=uploadTime&rows=50&fsn=45cdb5aa-eb6f-4bda-9bba-ba0b264bfc93&appId=%s&platformId=%s&version=%s&start=%s&rows=%s&exceptionTypeList=%s"
+	_issueVersionList   = "/v2/getSelector/appId/%s/platformId/%s?types=version&fsn=8b8782b5-053d-4f58-bc17-d5c43d7f5ece"
+	_issueExceptionList = "/v2/issueInfo/appId/%s/platformId/%s/issueId/%s/exceptionTypeList/Crash,Native,ExtensionCrash?fsn=114a8d02-586d-4fe4-8c23-79003fbe6882"
+)
+
+// BuglyVersion Bugly Version .
+func (d *Dao) BuglyVersion(c context.Context, buglyCookie *model.BuglyCookie, projectID, platformID string) (ret []*model.BugVersion, err error) {
+	var (
+		req     *http.Request
+		res     *model.BugVersionResponse
+		hostStr string
+	)
+
+	hostStr = d.c.Bugly.Host + fmt.Sprintf(_issueVersionList, projectID, platformID)
+
+	if req, err = d.newRequest("GET", hostStr, nil); err != nil {
+		return
+	}
+
+	req.Header.Set("Cookie", buglyCookie.Cookie)
+	req.Header.Set("x-token", buglyCookie.Token)
+	req.Header.Set("content-type", "application/json;charset=utf-8")
+	req.Header.Set("x-csrf-token", "undefined")
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.BugVersion url(%s) err(%v)", "BugVersion", err)
+		return
+	}
+
+	if res.Status != _buglyOkCode {
+		if res.Code == _buglyCookieExpiredCode {
+			err = ecode.MartheCookieExpired
+			log.Error("maybe need to update cookie and token")
+		} else {
+			err = ecode.MartheBuglyErr
+		}
+		log.Error("Status url(%s) res(%v) err(%v)", "BugVersion", res, err)
+		return
+	}
+
+	ret = res.Ret.BugVersionList
+	return
+}
+
+// BuglyIssueAndRetry Bugly Issue And Retry.
+func (d *Dao) BuglyIssueAndRetry(c context.Context, buglyCookie *model.BuglyCookie, bugIssueRequest *model.BugIssueRequest) (ret *model.BugRet, err error) {
+	for i := 0; i < d.c.Bugly.UrlRetryCount; i++ {
+		if ret, err = d.BuglyIssue(c, buglyCookie, bugIssueRequest); err == nil {
+			break
+		}
+	}
+	return
+}
+
+// BuglyIssue Get Issue.
+func (d *Dao) BuglyIssue(c context.Context, buglyCookie *model.BuglyCookie, bugIssueRequest *model.BugIssueRequest) (ret *model.BugRet, err error) {
+	var (
+		req     *http.Request
+		res     *model.BugIssueResponse
+		hostStr string
+	)
+
+	hostStr = d.c.Bugly.Host + fmt.Sprintf(_issueList, bugIssueRequest.ProjectID, bugIssueRequest.PlatformID, bugIssueRequest.Version, strconv.Itoa(bugIssueRequest.StartNum), strconv.Itoa(bugIssueRequest.Rows), bugIssueRequest.ExceptionType)
+
+	if req, err = d.newRequest("GET", hostStr, nil); err != nil {
+		return
+	}
+
+	req.Header.Set("Cookie", buglyCookie.Cookie)
+	req.Header.Set("x-token", buglyCookie.Token)
+	req.Header.Set("content-type", "application/json;charset=utf-8")
+	req.Header.Set("x-csrf-token", "undefined")
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.BuglyIssue url(%s) err(%v)", "BuglyIssue", err)
+		return
+	}
+
+	if res.Status != _buglyOkCode {
+		if res.Code == _buglyCookieExpiredCode {
+			err = ecode.MartheCookieExpired
+			log.Error("maybe need to update cookie and token")
+		} else {
+			err = ecode.MartheBuglyErr
+		}
+		log.Error("Status url(%s) res(%v) err(%v)", "BuglyIssue", res, err)
+		return
+	}
+
+	ret = res.Ret
+	return
+}
+
+// BuglyIssueDetailAndRetry Bugly Issue Detail And Retry.
+func (d *Dao) BuglyIssueDetailAndRetry(c context.Context, buglyCookie *model.BuglyCookie, projectID, platformID, issueNo string) (bugIssueDetail *model.BugIssueDetail, err error) {
+	for i := 0; i < d.c.Bugly.UrlRetryCount; i++ {
+		if bugIssueDetail, err = d.BuglyIssueDetail(c, buglyCookie, projectID, platformID, issueNo); err == nil {
+			break
+		}
+	}
+	return
+}
+
+// BuglyIssueDetail Get Issue Detail.
+func (d *Dao) BuglyIssueDetail(c context.Context, buglyCookie *model.BuglyCookie, projectID, platformID, issueNo string) (bugIssueDetail *model.BugIssueDetail, err error) {
+	var (
+		req     *http.Request
+		res     *model.BugIssueDetailResponse
+		hostStr string
+	)
+
+	hostStr = d.c.Bugly.Host + fmt.Sprintf(_issueDetailList, projectID, platformID, issueNo)
+
+	if req, err = d.newRequest("GET", hostStr, nil); err != nil {
+		return
+	}
+
+	req.Header.Set("Cookie", buglyCookie.Cookie)
+	req.Header.Set("x-token", buglyCookie.Token)
+	req.Header.Set("content-type", "application/json;charset=utf-8")
+	req.Header.Set("x-csrf-token", "undefined")
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.BuglyIssue url(%s) err(%v)", "BuglyIssue", err)
+		return
+	}
+
+	if res.Code != _issueDetailCode {
+		err = ecode.MartheBuglyErr
+		log.Error("Status url(%s) res(%v) err(%v)", "BuglyIssue", res, err)
+		return
+	}
+
+	bugIssueDetail = res.Data
+	return
+}
+
+// BuglyIssueExceptionList Bugly Issue Exception List.
+func (d *Dao) BuglyIssueExceptionList(c context.Context, buglyCookie *model.BuglyCookie, projectID, platformID, issueNo string) (bugIssueException *model.IssueException, err error) {
+	var (
+		req     *http.Request
+		res     *model.BugIssueExceptionListResponse
+		hostStr string
+	)
+
+	hostStr = d.c.Bugly.Host + fmt.Sprintf(_issueExceptionList, projectID, platformID, issueNo)
+
+	if req, err = d.newRequest("GET", hostStr, nil); err != nil {
+		return
+	}
+
+	req.Header.Set("Cookie", buglyCookie.Cookie)
+	req.Header.Set("x-token", buglyCookie.Token)
+	req.Header.Set("content-type", "application/json;charset=utf-8")
+	req.Header.Set("x-csrf-token", "undefined")
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.BuglyIssueExceptionList url(%s) err(%v)", "BuglyIssueExceptionList", err)
+		return
+	}
+
+	if res.Status != _buglyOkCode {
+		err = ecode.MartheBuglyErr
+		log.Error("Status url(%s) res(%v) err(%v)", "BuglyIssueExceptionList", res, err)
+		return
+	}
+
+	if res.Ret != nil && len(res.Ret.IssueException) != 0 && res.Ret.IssueException[0].IssueID == issueNo {
+		bugIssueException = res.Ret.IssueException[0]
+	}
+
+	return
+}

app/admin/ep/marthe/dao/dao.go

@@ -0,0 +1,100 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"go-common/app/admin/ep/marthe/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/orm"
+	"go-common/library/log"
+	xhttp "go-common/library/net/http/blademaster"
+	"go-common/library/sync/pipeline/fanout"
+
+	"github.com/jinzhu/gorm"
+	"gopkg.in/gomail.v2"
+)
+
+const _wildcards = "%"
+
+// Dao dao
+type Dao struct {
+	c          *conf.Config
+	httpClient *xhttp.Client
+	email      *gomail.Dialer
+	db         *gorm.DB
+	cache      *fanout.Fanout
+	mc         *memcache.Pool
+	expire     int32
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:          c,
+		email:      gomail.NewDialer(c.Mail.Host, c.Mail.Port, c.Mail.Username, c.Mail.Password),
+		httpClient: xhttp.NewClient(c.HTTPClient),
+		cache:      fanout.New("mcCache", fanout.Worker(1), fanout.Buffer(1024)),
+		mc:         memcache.NewPool(c.Memcache.Config),
+		expire:     int32(time.Duration(c.Memcache.Expire) / time.Second),
+	}
+	if c.ORM != nil {
+		dao.db = orm.NewMySQL(c.ORM)
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+
+	if d.mc != nil {
+		d.mc.Close()
+	}
+}
+
+// Ping verify server is ok.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.db != nil {
+		if err = d.db.DB().Ping(); err != nil {
+			log.Info("dao.cloudDB.Ping() error(%v)", err)
+		}
+	}
+	return
+}
+
+func (d *Dao) newRequest(method, url string, v interface{}) (req *http.Request, err error) {
+	body := &bytes.Buffer{}
+	if method != http.MethodGet {
+		if err = json.NewEncoder(body).Encode(v); err != nil {
+			log.Error("json encode value(%s) err(%v) ", v, err)
+			return
+		}
+	}
+	if req, err = http.NewRequest(method, url, body); err != nil {
+		log.Error("http new request url(%s) err(%v)", url, err)
+	}
+	return
+}
+
+// cacheSave cache Save.
+func (d *Dao) cacheSave(c context.Context, cacheItem *memcache.Item) {
+	var f = func(ctx context.Context) {
+		var (
+			conn = d.mc.Get(c)
+			err  error
+		)
+		defer conn.Close()
+		if err = conn.Set(cacheItem); err != nil {
+			log.Error("Add Cache conn.Set(%s) error(%v)", cacheItem.Key, err)
+		}
+	}
+	if err := d.cache.Do(c, f); err != nil {
+		log.Error("ReleaseName cache save err(%v)", err)
+	}
+}

app/admin/ep/marthe/dao/dao_test.go

@@ -0,0 +1,30 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+
+	"go-common/app/admin/ep/marthe/conf"
+
+	_ "github.com/go-sql-driver/mysql"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	d *Dao
+	c context.Context
+)
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/convey-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	d.httpClient.SetTransport(gock.DefaultTransport)
+	c = ctx()
+}
+
+func ctx() context.Context {
+	return context.Background()
+}

app/admin/ep/marthe/dao/mail.go

@@ -0,0 +1,35 @@
+package dao
+
+import (
+	"context"
+	"strings"
+
+	"gopkg.in/gomail.v2"
+)
+
+const (
+	_MailBoxNotFound = "Mailbox not found"
+)
+
+// SendMail asynchronous send mail.
+func (d *Dao) SendMail(message *gomail.Message) {
+	message.SetAddressHeader("From", d.email.Username, "merlin")
+	d.cache.Do(context.TODO(), func(ctx context.Context) {
+		d.SendMailIfFailed(message)
+	})
+}
+
+// SendMailIfFailed Send Mail If Failed
+func (d *Dao) SendMailIfFailed(message *gomail.Message) {
+	if err := d.email.DialAndSend(message); err != nil {
+		if strings.Contains(err.Error(), _MailBoxNotFound) {
+			headerMsg := message.GetHeader("Subject")
+			headerMsg = append(headerMsg, "Mail Send Error:"+err.Error()+",Receiver:")
+			headerMsg = append(headerMsg, message.GetHeader("To")...)
+
+			message.SetHeader("To", d.c.Mail.NoticeOwner...)
+			message.SetHeader("Subject", headerMsg...)
+			d.email.DialAndSend(message)
+		}
+	}
+}

app/admin/ep/marthe/dao/mysql_bugly_batch_run.go

@@ -0,0 +1,92 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertBuglyBatchRuns Insert Bugly Batch Runs.
+func (d *Dao) InsertBuglyBatchRuns(buglyBatchRuns []*model.BuglyBatchRun) (err error) {
+	tx := d.db.Begin()
+
+	defer func() {
+		if err != nil {
+			if err == ecode.NothingFound {
+				err = nil
+			} else {
+				err = pkgerr.WithStack(err)
+			}
+		}
+	}()
+
+	if err = tx.Error; err != nil {
+		return
+	}
+
+	for _, buglyBatchRun := range buglyBatchRuns {
+		if err = d.db.Create(buglyBatchRun).Error; err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+
+	if err = tx.Commit().Error; err != nil {
+		tx.Rollback()
+	}
+	return
+}
+
+// InsertBuglyBatchRun Insert Bugly Batch Run.
+func (d *Dao) InsertBuglyBatchRun(buglyBatchRun *model.BuglyBatchRun) error {
+	return pkgerr.WithStack(d.db.Create(buglyBatchRun).Error)
+}
+
+// UpdateBuglyBatchRun Update Bugly Batch Run.
+func (d *Dao) UpdateBuglyBatchRun(buglyBatchRun *model.BuglyBatchRun) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyBatchRun{}).Where("id=?", buglyBatchRun.ID).Updates(buglyBatchRun).Error)
+}
+
+// FindBuglyBatchRuns Find Bugly Batch Runs.
+func (d *Dao) FindBuglyBatchRuns(req *model.QueryBuglyBatchRunsRequest) (total int64, buglyBatchRuns []*model.BuglyBatchRun, err error) {
+	gDB := d.db.Model(&model.BuglyBatchRun{})
+
+	if req.Version != "" {
+		gDB = gDB.Where("version=?", req.Version)
+	}
+
+	if req.Status != 0 {
+		gDB = gDB.Where("status=?", req.Status)
+	}
+
+	if req.BatchID != "" {
+		gDB = gDB.Where("batch_id=?", req.BatchID)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&buglyBatchRuns).Error)
+	return
+}
+
+// QueryBuglyBatchRunsByStatus Find Bugly Batch Runs By Status.
+func (d *Dao) QueryBuglyBatchRunsByStatus(status int) (buglyBatchRuns []*model.BuglyBatchRun, err error) {
+	err = pkgerr.WithStack(d.db.Where("status = ?", status).Find(&buglyBatchRuns).Error)
+	return
+}
+
+// QueryLastSuccessBatchRunByVersion Find Last Success Batch Run By Version.
+func (d *Dao) QueryLastSuccessBatchRunByVersion(version string) (buglyBatchRun *model.BuglyBatchRun, err error) {
+	buglyBatchRun = &model.BuglyBatchRun{}
+	if err = d.db.Where("version = ? and status = ?", version, model.BuglyBatchRunStatusDone).Order("id desc").First(&buglyBatchRun).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}

app/admin/ep/marthe/dao/mysql_bugly_batch_run_test.go

@@ -0,0 +1,58 @@
+package dao
+
+import (
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	"github.com/satori/go.uuid"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmpVersion    = time.Now().Format("2006_01_02_15_04_05")
+	buglyBatchRun = &model.BuglyBatchRun{
+		BuglyVersionID: 1,
+		Version:        tmpVersion,
+		BatchID:        uuid.NewV4().String(),
+		RetryCount:     0,
+		Status:         model.BuglyBatchRunStatusRunning,
+		ErrorMsg:       "no",
+	}
+
+	queryBuglyBatchRunsRequest = &model.QueryBuglyBatchRunsRequest{
+		Pagination: model.Pagination{
+			PageSize: 10,
+			PageNum:  1,
+		},
+		Version: tmpVersion,
+	}
+)
+
+func Test_Bugly_batch_run(t *testing.T) {
+	Convey("test insert bugly batch run", t, func() {
+		err := d.InsertBuglyBatchRun(buglyBatchRun)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test update bugly batch run", t, func() {
+		buglyBatchRun.Status = model.BuglyBatchRunStatusDone
+		err := d.UpdateBuglyBatchRun(buglyBatchRun)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Find Bugly Batch Runs", t, func() {
+		buglyBatchRun.Status = model.BuglyBatchRunStatusDone
+		total, buglyBatchRuns, err := d.FindBuglyBatchRuns(queryBuglyBatchRunsRequest)
+		So(err, ShouldBeNil)
+		So(total, ShouldEqual, 1)
+		So(buglyBatchRun.BatchID, ShouldEqual, buglyBatchRuns[0].BatchID)
+	})
+
+	Convey("test Find Last Success Batch Run By Version", t, func() {
+		tmpBuglyBatchRun, err := d.QueryLastSuccessBatchRunByVersion(tmpVersion)
+		So(err, ShouldBeNil)
+		So(buglyBatchRun.BatchID, ShouldEqual, tmpBuglyBatchRun.BatchID)
+	})
+}

app/admin/ep/marthe/dao/mysql_bugly_cookie.go

@@ -0,0 +1,67 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertCookie Insert Cookie.
+func (d *Dao) InsertCookie(buglyCookie *model.BuglyCookie) error {
+	return pkgerr.WithStack(d.db.Create(buglyCookie).Error)
+}
+
+// UpdateCookie Update cookie.
+func (d *Dao) UpdateCookie(buglyCookie *model.BuglyCookie) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyCookie{}).Updates(buglyCookie).Error)
+}
+
+// UpdateCookieStatus Update Cookie Status.
+func (d *Dao) UpdateCookieStatus(id int64, status int) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyCookie{}).Where("id = ?", id).Update("status", status).Error)
+}
+
+// UpdateCookieUsageCount Update Cookie Usage Count.
+func (d *Dao) UpdateCookieUsageCount(id int64, usageCount int) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyCookie{}).Where("id = ?", id).Update("usage_count", usageCount).Error)
+}
+
+// QueryCookieByStatus Query Cookie By Status.
+func (d *Dao) QueryCookieByStatus(status int) (buglyCookies []*model.BuglyCookie, err error) {
+	err = pkgerr.WithStack(d.db.Where("status=?", status).Order("ctime desc").Find(&buglyCookies).Error)
+	return
+}
+
+// QueryCookieByQQAccount Query Cookie By QQ Account.
+func (d *Dao) QueryCookieByQQAccount(qqAccount int) (buglyCookie *model.BuglyCookie, err error) {
+	buglyCookie = &model.BuglyCookie{}
+	if err = d.db.Where("qq_account=?", qqAccount).First(buglyCookie).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// FindCookies Find Cookies.
+func (d *Dao) FindCookies(req *model.QueryBuglyCookiesRequest) (total int64, buglyCookies []*model.BuglyCookie, err error) {
+	gDB := d.db.Model(&model.BuglyCookie{})
+
+	if req.QQAccount != 0 {
+		gDB = gDB.Where("qq_account=?", req.QQAccount)
+	}
+
+	if req.Status != 0 {
+		gDB = gDB.Where("status=?", req.Status)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&buglyCookies).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_bugly_cookie_test.go

@@ -0,0 +1,51 @@
+package dao
+
+import (
+	"testing"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	buglyCookie = &model.BuglyCookie{
+		QQAccount:  246802468,
+		Cookie:     "eas_sid=6105G3k2D0Q428f5u0c6B527B0; pgv_pvi=95820800; RK=kfyEYkBgS6; btcu_id=c64abeb0e4f6485712c0bb79bf16c19d5b6aa5326be74; vc=vc-01c6b914-d8f9-4449-adcb-abba3ebe137c; vc.sig=b8t0PNSdSX1m4wOr-B12whzwaf75BlJjOjz5Jy7YTkE; _ga=GA1.2.1955813367.1533715741; pgv_si=s229603328; _qpsvr_localtk=0.0198901072762101; o_cookie=972360526; pac_uid=1_972360526; csrfToken=gekJ-F5QdGgVTZqLC0NiBEOA; ptui_loginuin=1211712225; ptisp=ctc; ptcz=f45f877d04ce6b659e432a158d35cbc9dea2c565d17eb6ee23640a0c7f82aaf9; uin=o1211712225; skey=@FGItvXrQ6; pt2gguin=o1211712225; IED_LOG_INFO2=userUin%3D1211712225%26nickName%3D%2525E5%2525B0%25258F%2525E7%2525BE%25258E+%26userLoginTime%3D1545802497; midas_openid=1211712225; midas_openkey=@FGItvXrQ6; pgv_info=ssid=s2529006206&pgvReferrer=; pgv_pvid=7939868100; NODINX_SESS=7XIt-RXcFpUaAwKwVFHFbIsssGiryDAw_dF_oP1uVFP2V5vV95jh92eADSSJIq0v; token-skey=771060e7-cd54-f0b3-960c-c8fe485fde10; token-lifeTime=1545828885; bugly_session=eyJpdiI6IldLOHM2V2lhNXFyemdMV1d6YXQ0SHc9PSIsInZhbHVlIjoiekt5UllBZWU4OEltSDVzTzJOeHRESjdQMWY5Y1wveEpYbUlDNmxrV25XTHR3ME5RMkRUdk9VaGlKbGFrQ0cxc2xoUzBOVXdCM0hzVWZIemlFR1BLZXJnPT0iLCJtYWMiOiJhZTI5ZmVjNmVjNzZjMWI2MTMyM2U4NWE5MGZiNWMxMjQzZmEzMWEyMGZhMTcxZjg1N2FiOTY4OTgxNWZjMDExIn0%3D; referrer=eyJpdiI6Im9FZ00yMHdsS2hIeHp3UERSaFVhWlE9PSIsInZhbHVlIjoiZXN6dmZFWmJ4V3R6UmordnowVXZkMXdhbm8zN3QrNzVcL2NSc1I0eWw1ZUVYbVFvTnlwdDB2QWVoaXp4VmZxY2tFV2VSdDIrWG40bEpqb3hvWTZmaVAwXC9vR1JqNEE5NG1MQnlkR1dvV1dkWitSakV6RjV1dWF4dEtzbGpXRFhsNW10SEhrSDVrZk1tRE9EXC9zUEVBRGxwSzhoTHRzSHhuTktFV1g1ckpOTEo0PSIsIm1hYyI6IjAzZWJiMjQ0YjkyNmUyYTk2MDRmNTdjYjY2OWYwNzIzZjZjMmNiMzU0NWRhZmExZWFhYWUzMGFiMTI2MDI4NzIifQ%3D%3F",
+		Token:      "1768129694",
+		UsageCount: 0,
+		Status:     model.BuglyCookieStatusEnable,
+	}
+
+	queryBuglyCookiesRequest = &model.QueryBuglyCookiesRequest{
+		Pagination: model.Pagination{
+			PageSize: 10,
+			PageNum:  1,
+		},
+		QQAccount: buglyCookie.QQAccount,
+	}
+)
+
+func Test_Bugly_cookie(t *testing.T) {
+	Convey("test insert bugly cookie", t, func() {
+		err := d.InsertCookie(buglyCookie)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Update Cookie Status", t, func() {
+		err := d.UpdateCookieStatus(buglyCookie.ID, model.BuglyCookieStatusDisable)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Update Cookie Usage Count", t, func() {
+		err := d.UpdateCookieUsageCount(buglyCookie.ID, 5)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Find Cookies", t, func() {
+		total, buglyCookies, err := d.FindCookies(queryBuglyCookiesRequest)
+		So(err, ShouldBeNil)
+		So(total, ShouldBeGreaterThan, 0)
+		So(len(buglyCookies), ShouldBeGreaterThan, 0)
+	})
+}

app/admin/ep/marthe/dao/mysql_bugly_issue.go

@@ -0,0 +1,104 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// GetBuglyIssue Get Issue Record.
+func (d *Dao) GetBuglyIssue(issueNo, version string) (buglyIssue *model.BuglyIssue, err error) {
+	buglyIssue = &model.BuglyIssue{}
+	if err = d.db.Where("issue_no = ? and version = ?", issueNo, version).First(buglyIssue).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// UpdateBuglyIssue Update Issue Record.
+func (d *Dao) UpdateBuglyIssue(buglyIssue *model.BuglyIssue) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyIssue{}).Where("issue_no = ? and version = ?", buglyIssue.IssueNo, buglyIssue.Version).UpdateColumn(map[string]interface{}{
+		"last_time":    buglyIssue.LastTime,
+		"happen_times": buglyIssue.HappenTimes,
+		"user_times":   buglyIssue.UserTimes,
+	}).Error)
+}
+
+// InsertBuglyIssue Insert Issue Record.
+func (d *Dao) InsertBuglyIssue(buglyIssue *model.BuglyIssue) (err error) {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyIssue{}).Create(buglyIssue).Error)
+}
+
+// GetBuglyIssuesByFilterSQL  Get Bugly Issues By Filter SQL.
+func (d *Dao) GetBuglyIssuesByFilterSQL(issueFilterSQL string) (buglyIssues []*model.BuglyIssue, err error) {
+	if err = d.db.Raw(issueFilterSQL).Order("id asc").Find(&buglyIssues).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// UpdateBuglyIssueTapdBugID Update Issue Record Tapd Bug ID.
+func (d *Dao) UpdateBuglyIssueTapdBugID(id int64, tapdBugID string) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyIssue{}).Where("id=?", id).Update("tapd_bug_id", tapdBugID).Error)
+}
+
+// FindBuglyIssues Find Bugly Issues.
+func (d *Dao) FindBuglyIssues(req *model.QueryBuglyIssueRequest) (total int64, buglyIssues []*model.BuglyIssue, err error) {
+	gDB := d.db.Model(&model.BuglyIssue{})
+
+	if req.IssueNo != "" {
+		gDB = gDB.Where("issue_no = ?", req.IssueNo)
+	}
+	if req.Title != "" {
+		gDB = gDB.Where("title like ?", _wildcards+req.Title+_wildcards)
+	}
+	if req.ExceptionMsg != "" {
+		gDB = gDB.Where("exception_msg like ?", _wildcards+req.ExceptionMsg+_wildcards)
+	}
+	if req.KeyStack != "" {
+		gDB = gDB.Where("key_stack like ?", _wildcards+req.KeyStack+_wildcards)
+	}
+	if req.Detail != "" {
+		gDB = gDB.Where("detail like ?", _wildcards+req.Detail+_wildcards)
+	}
+	if req.Tags != "" {
+		gDB = gDB.Where("tags like ?", _wildcards+req.Tags+_wildcards)
+	}
+	if req.Version != "" {
+		gDB = gDB.Where("version like ?", _wildcards+req.Version+_wildcards)
+	}
+	if req.ProjectID != "" {
+		gDB = gDB.Where("project_id like ?", _wildcards+req.ProjectID+_wildcards)
+	}
+	if req.TapdBugID != "" {
+		gDB = gDB.Where("tapd_bug_id = ?", req.TapdBugID)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("mtime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&buglyIssues).Error)
+	return
+}
+
+// GetBuglyIssuesHasInTapd Get Bugly Issues Has In Tapd.
+func (d *Dao) GetBuglyIssuesHasInTapd() (buglyIssues []*model.BuglyIssue, err error) {
+	if err = d.db.Where("tapd_bug_id<>''").Find(&buglyIssues).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}

app/admin/ep/marthe/dao/mysql_bugly_issue_test.go

@@ -0,0 +1,78 @@
+package dao
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmpIssueNoStr = strconv.FormatInt(time.Now().Unix(), 10)
+	tmpTapdBugID  = "bug" + tmpIssueNoStr
+
+	buglyIssue = &model.BuglyIssue{
+		IssueNo:      tmpIssueNoStr,
+		Title:        "Title" + tmpIssueNoStr,
+		ExceptionMsg: "ExceptionMsg" + tmpIssueNoStr,
+		KeyStack:     "KeyStack" + tmpIssueNoStr,
+		Detail:       "Detail" + tmpIssueNoStr,
+		Tags:         "Tags" + tmpIssueNoStr,
+		LastTime:     time.Now(),
+		HappenTimes:  10,
+		UserTimes:    20,
+		Version:      "Version" + tmpIssueNoStr,
+		ProjectID:    "ProjectID" + tmpIssueNoStr,
+		IssueLink:    "IssueLink" + tmpIssueNoStr,
+	}
+
+	queryBuglyIssueRequest = &model.QueryBuglyIssueRequest{
+		Pagination: model.Pagination{
+			PageSize: 10,
+			PageNum:  1,
+		},
+		IssueNo: buglyIssue.IssueNo,
+	}
+)
+
+func Test_Bugly_Issue(t *testing.T) {
+	Convey("test insert bugly issue", t, func() {
+		err := d.InsertBuglyIssue(buglyIssue)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test update Bugly Issue", t, func() {
+		buglyIssue.ExceptionMsg = "update exception message"
+		err := d.UpdateBuglyIssue(buglyIssue)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test update Bugly Issue tapd bug id", t, func() {
+		err := d.UpdateBuglyIssueTapdBugID(buglyIssue.ID, tmpTapdBugID)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Get Bugly Issue", t, func() {
+		tmpBuglyIssue, err := d.GetBuglyIssue(buglyIssue.IssueNo, buglyIssue.Version)
+		So(err, ShouldBeNil)
+		So(tmpBuglyIssue.ID, ShouldEqual, buglyIssue.ID)
+	})
+
+	Convey("test Get Bugly Issues By Filter SQL", t, func() {
+		sql := "select * from bugly_issues where issue_no = '" + buglyIssue.IssueNo + "'"
+		tmpBuglyIssues, err := d.GetBuglyIssuesByFilterSQL(sql)
+		So(err, ShouldBeNil)
+		So(tmpBuglyIssues[0].IssueNo, ShouldEqual, buglyIssue.IssueNo)
+	})
+
+	Convey("test Find Bugly Issues", t, func() {
+		total, tmpBuglyIssues, err := d.FindBuglyIssues(queryBuglyIssueRequest)
+		So(err, ShouldBeNil)
+		So(total, ShouldBeGreaterThan, 0)
+		So(len(tmpBuglyIssues), ShouldBeGreaterThan, 0)
+	})
+
+}

app/admin/ep/marthe/dao/mysql_bugly_project.go

@@ -0,0 +1,89 @@
+package dao
+
+import (
+	"database/sql"
+
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertBuglyProject Insert Bugly Project.
+func (d *Dao) InsertBuglyProject(buglyProject *model.BuglyProject) error {
+	return pkgerr.WithStack(d.db.Create(buglyProject).Error)
+}
+
+// UpdateBuglyProject Update Bugly Project.
+func (d *Dao) UpdateBuglyProject(buglyProject *model.BuglyProject) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyProject{}).Updates(buglyProject).Error)
+}
+
+// QueryBuglyProject Query Bugly Project.
+func (d *Dao) QueryBuglyProject(id int64) (buglyProject *model.BuglyProject, err error) {
+	buglyProject = &model.BuglyProject{}
+	err = pkgerr.WithStack(d.db.Where("id = ?", id).First(buglyProject).Error)
+	return
+}
+
+// QueryBuglyProjectByName Query Bugly Project.
+func (d *Dao) QueryBuglyProjectByName(projectName string) (buglyProject *model.BuglyProject, err error) {
+	buglyProject = &model.BuglyProject{}
+	if err = d.db.Where("project_name = ?", projectName).First(buglyProject).Error; err == ecode.NothingFound {
+		err = nil
+	}
+	return
+}
+
+// QueryAllBuglyProjects Query All Bugly Project.
+func (d *Dao) QueryAllBuglyProjects() (buglyProjects []*model.BuglyProject, err error) {
+	err = pkgerr.WithStack(d.db.Model(&model.BuglyProject{}).Find(&buglyProjects).Error)
+	return
+}
+
+// FindBuglyProjects Find Bugly Project.
+func (d *Dao) FindBuglyProjects(req *model.QueryBuglyProjectRequest) (total int64, buglyProject []*model.BuglyProject, err error) {
+	gDB := d.db.Model(&model.BuglyProject{})
+
+	if req.ProjectID != "" {
+		gDB = gDB.Where("project_id=?", req.ProjectID)
+	}
+	if req.ProjectName != "" {
+		gDB = gDB.Where("project_name like ?", _wildcards+req.ProjectName+_wildcards)
+	}
+	if req.PlatformID != "" {
+		gDB = gDB.Where("platform_id=?", req.PlatformID)
+	}
+
+	if req.UpdateBy != "" {
+		gDB = gDB.Where("update_by=?", req.UpdateBy)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&buglyProject).Error)
+	return
+}
+
+// QueryBuglyProjectList Query Bugly Project List.
+func (d *Dao) QueryBuglyProjectList() (projectList []string, err error) {
+	var (
+		rows *sql.Rows
+	)
+	sql := "select DISTINCT project_name from bugly_projects"
+	if rows, err = d.db.Raw(sql).Rows(); err != nil {
+		return
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		var ver string
+		if err = rows.Scan(&ver); err != nil {
+			return
+		}
+		projectList = append(projectList, ver)
+	}
+	return
+}

app/admin/ep/marthe/dao/mysql_bugly_version.go

@@ -0,0 +1,139 @@
+package dao
+
+import (
+	"database/sql"
+	"fmt"
+
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+const (
+	_versionInnerJoinProjectSql      = "select a.id,a.version,a.bugly_project_id,a.action,a.task_status,a.update_by,a.ctime,a.mtime,b.project_name,b.exception_type from bugly_versions as a inner join bugly_projects as b on a.bugly_project_id = b.id"
+	_versionInnerJoinProjectSqlCount = "select count(-1) as totalCount from bugly_versions as a inner join bugly_projects as b on a.bugly_project_id = b.id"
+	_where                           = "WHERE"
+	_and                             = "AND"
+)
+
+// InsertBuglyVersion Insert Bugly Version.
+func (d *Dao) InsertBuglyVersion(buglyVersion *model.BuglyVersion) error {
+	return pkgerr.WithStack(d.db.Create(buglyVersion).Error)
+}
+
+// UpdateBuglyVersion Update Bugly Version.
+func (d *Dao) UpdateBuglyVersion(buglyVersion *model.BuglyVersion) error {
+	return pkgerr.WithStack(d.db.Model(&model.BuglyVersion{}).Updates(buglyVersion).Error)
+}
+
+// QueryBuglyVersionByVersion Query Bugly Version By Version.
+func (d *Dao) QueryBuglyVersionByVersion(version string) (buglyVersion *model.BuglyVersion, err error) {
+	buglyVersion = &model.BuglyVersion{}
+	if err = d.db.Where("version = ?", version).First(buglyVersion).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryBuglyVersion Query Bugly Version .
+func (d *Dao) QueryBuglyVersion(id int64) (buglyVersion *model.BuglyVersion, err error) {
+	buglyVersion = &model.BuglyVersion{}
+	if err = d.db.Where("id = ?", id).First(buglyVersion).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryBuglyVersionList Query Bugly Version List.
+func (d *Dao) QueryBuglyVersionList() (versionList []string, err error) {
+	var (
+		rows *sql.Rows
+	)
+	sql := "select DISTINCT version from bugly_versions"
+	if rows, err = d.db.Raw(sql).Rows(); err != nil {
+		return
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		var ver string
+		if err = rows.Scan(&ver); err != nil {
+			return
+		}
+		versionList = append(versionList, ver)
+	}
+	return
+}
+
+// FindBuglyProjectVersions Find Bugly Project Versions.
+func (d *Dao) FindBuglyProjectVersions(req *model.QueryBuglyVersionRequest) (total int64, buglyProjectVersions []*model.BuglyProjectVersion, err error) {
+	var (
+		qSQL = _versionInnerJoinProjectSql
+		cSQL = _versionInnerJoinProjectSqlCount
+		rows *sql.Rows
+	)
+
+	if req.UpdateBy != "" || req.ProjectName != "" || req.Action > 0 || req.Version != "" {
+		var (
+			partSql     string
+			logicalWord = _where
+		)
+
+		if req.UpdateBy != "" {
+			partSql = fmt.Sprintf("%s %s a.update_by = '%s'", partSql, logicalWord, req.UpdateBy)
+			logicalWord = _and
+		}
+
+		if req.ProjectName != "" {
+			partSql = fmt.Sprintf("%s %s b.project_name like '%s'", partSql, logicalWord, _wildcards+req.ProjectName+_wildcards)
+			logicalWord = _and
+		}
+
+		if req.Action > 0 {
+			partSql = fmt.Sprintf("%s %s a.action = %d", partSql, logicalWord, req.Action)
+			logicalWord = _and
+		}
+
+		if req.Version != "" {
+			partSql = fmt.Sprintf("%s %s a.version like '%s'", partSql, logicalWord, _wildcards+req.Version+_wildcards)
+			logicalWord = _and
+		}
+
+		qSQL = qSQL + partSql
+		cSQL = cSQL + partSql
+	}
+
+	cDB := d.db.Raw(cSQL)
+	if err = pkgerr.WithStack(cDB.Count(&total).Error); err != nil {
+		return
+	}
+	gDB := d.db.Raw(qSQL)
+	if rows, err = gDB.Order("a.ctime DESC").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Rows(); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		pv := &model.BuglyProjectVersion{}
+		if err = rows.Scan(&pv.ID, &pv.Version, &pv.BuglyProjectID, &pv.Action, &pv.TaskStatus, &pv.UpdateBy, &pv.CTime, &pv.MTime, &pv.ProjectName, &pv.ExceptionType); err != nil {
+			return
+		}
+		buglyProjectVersions = append(buglyProjectVersions, pv)
+	}
+
+	return
+}
+
+// FindEnableAndReadyVersions Find Enable And Ready Versions.
+func (d *Dao) FindEnableAndReadyVersions() (buglyVersions []*model.BuglyVersion, err error) {
+	err = pkgerr.WithStack(d.db.Where("action = ? and task_status = ?", model.BuglyVersionActionEnable, model.BuglyVersionTaskStatusReady).Find(&buglyVersions).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_bugly_version_test.go

@@ -0,0 +1,49 @@
+package dao
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmpIssueNoStr2 = strconv.FormatInt(time.Now().Unix(), 10)
+
+	buglyVersion = &model.BuglyVersion{
+		Version:        "Version" + tmpIssueNoStr2,
+		BuglyProjectID: 1,
+		Action:         model.BuglyVersionActionDisable,
+		TaskStatus:     1,
+		UpdateBy:       "fengyifeng",
+	}
+)
+
+func Test_Bugly_Version(t *testing.T) {
+	Convey("test insert bugly Version", t, func() {
+		err := d.InsertBuglyVersion(buglyVersion)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test update bugly Version", t, func() {
+		buglyVersion.Version = "update" + tmpIssueNoStr2
+		err := d.UpdateBuglyVersion(buglyVersion)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Query Bugly Version By Version", t, func() {
+		tmpBuglyVersion, err := d.QueryBuglyVersionByVersion(buglyVersion.Version)
+		So(err, ShouldBeNil)
+		So(tmpBuglyVersion.Version, ShouldEqual, buglyVersion.Version)
+	})
+
+	Convey("test Query Bugly Version By Id", t, func() {
+		tmpBuglyVersion, err := d.QueryBuglyVersion(buglyVersion.ID)
+		So(err, ShouldBeNil)
+		So(tmpBuglyVersion.Version, ShouldEqual, buglyVersion.Version)
+	})
+
+}

app/admin/ep/marthe/dao/mysql_contact_info.go

@@ -0,0 +1,50 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertContactInfo Insert Contact Info.
+func (d *Dao) InsertContactInfo(contactInfo *model.ContactInfo) error {
+	return pkgerr.WithStack(d.db.Create(contactInfo).Error)
+}
+
+// UpdateContactInfo Update Contact Info.
+func (d *Dao) UpdateContactInfo(contactInfo *model.ContactInfo) error {
+	return pkgerr.WithStack(d.db.Save(&contactInfo).Error)
+}
+
+// QueryContactInfoByUserID Query Contact Info By User ID
+func (d *Dao) QueryContactInfoByUserID(userID string) (contactInfo *model.ContactInfo, err error) {
+	contactInfo = &model.ContactInfo{}
+	if err = d.db.Where("user_id = ?", userID).First(contactInfo).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryContactInfoByUsername Query Contact Info By Username
+func (d *Dao) QueryContactInfoByUsername(username string) (contactInfo *model.ContactInfo, err error) {
+	contactInfo = &model.ContactInfo{}
+	if err = d.db.Where("username = ?", username).First(contactInfo).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryAllContactInfos Query All Contact Infos
+func (d *Dao) QueryAllContactInfos() (contactInfos []*model.ContactInfo, err error) {
+	err = pkgerr.WithStack(d.db.Find(&contactInfos).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_schedule_task.go

@@ -0,0 +1,17 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertScheduleTask Insert Schedule Task.
+func (d *Dao) InsertScheduleTask(scheduleTask *model.ScheduleTask) error {
+	return pkgerr.WithStack(d.db.Create(scheduleTask).Error)
+}
+
+// UpdateScheduleTask Update Schedule Task.
+func (d *Dao) UpdateScheduleTask(scheduleTask *model.ScheduleTask) error {
+	return pkgerr.WithStack(d.db.Model(&model.ScheduleTask{}).Updates(scheduleTask).Error)
+}

app/admin/ep/marthe/dao/mysql_schedule_task_test.go

@@ -0,0 +1,33 @@
+package dao
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmpIssueNoStr3 = strconv.FormatInt(time.Now().Unix(), 10)
+
+	scheduleTask = &model.ScheduleTask{
+		Name:   tmpIssueNoStr3,
+		Status: model.TaskStatusRunning,
+	}
+)
+
+func Test_Schedule_task(t *testing.T) {
+	Convey("test insert schedule task", t, func() {
+		err := d.InsertScheduleTask(scheduleTask)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test update schedule task", t, func() {
+		scheduleTask.Status = model.TaskStatusDone
+		err := d.UpdateScheduleTask(scheduleTask)
+		So(err, ShouldBeNil)
+	})
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_priority_conf.go

@@ -0,0 +1,47 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertTapdBugPriorityConf Insert Tapd Bug Priority Conf.
+func (d *Dao) InsertTapdBugPriorityConf(tapdBugPriorityConf *model.TapdBugPriorityConf) error {
+	return pkgerr.WithStack(d.db.Create(tapdBugPriorityConf).Error)
+}
+
+// UpdateTapdBugPriorityConf Update Tapd Bug Priority Conf.
+func (d *Dao) UpdateTapdBugPriorityConf(tapdBugPriorityConf *model.TapdBugPriorityConf) error {
+	return pkgerr.WithStack(d.db.Save(&tapdBugPriorityConf).Error)
+}
+
+// QueryTapdBugPriorityConfsByProjectTemplateIdAndStatus Query Tapd Bug Priority Confs By Project TemplateId And tatus.
+func (d *Dao) QueryTapdBugPriorityConfsByProjectTemplateIdAndStatus(projectTemplateID int64, status int) (tapdBugPriorityConfs []*model.TapdBugPriorityConf, err error) {
+	err = pkgerr.WithStack(d.db.Where("project_template_id = ? and status = ?", projectTemplateID, status).Find(&tapdBugPriorityConfs).Error)
+	return
+}
+
+// FindTapdBugPriorityConfs Find Tapd Bug Priority Confs.
+func (d *Dao) FindTapdBugPriorityConfs(req *model.QueryTapdBugPriorityConfsRequest) (total int64, tapdBugPriorityConfs []*model.TapdBugPriorityConf, err error) {
+	gDB := d.db.Model(&model.TapdBugPriorityConf{})
+
+	if req.ProjectTemplateID > 0 {
+		gDB = gDB.Where("project_template_id=?", req.ProjectTemplateID)
+	}
+
+	if req.UpdateBy != "" {
+		gDB = gDB.Where("update_by=?", req.UpdateBy)
+	}
+
+	if req.Status > 0 {
+		gDB = gDB.Where("status=?", req.Status)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&tapdBugPriorityConfs).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_priority_confg_test.go

@@ -0,0 +1,52 @@
+package dao
+
+import (
+	"testing"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"time"
+)
+
+var (
+	tapdBugPriorityConf = &model.TapdBugPriorityConf{
+		ProjectTemplateID: 1000,
+		Urgent:            123,
+		High:              321,
+		Medium:            111,
+		UpdateBy:          "fengyifeng",
+		StartTime:         time.Now(),
+		EndTime:           time.Now().AddDate(0, 1, 0),
+		Status:            model.TapdBugPriorityConfDisable,
+	}
+
+	queryTapdBugPriorityConfsRequest = &model.QueryTapdBugPriorityConfsRequest{
+		Pagination: model.Pagination{
+			PageSize: 10,
+			PageNum:  1,
+		},
+		ProjectTemplateID: 1000,
+	}
+)
+
+func Test_Tapd_Bug_Priority_Conf(t *testing.T) {
+	Convey("test Insert Tapd Bug Priority Conf", t, func() {
+		err := d.InsertTapdBugPriorityConf(tapdBugPriorityConf)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Update Tapd Bug Priority Conf", t, func() {
+		tapdBugPriorityConf.Urgent = 10010
+		err := d.UpdateTapdBugPriorityConf(tapdBugPriorityConf)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Find Tapd Bug Priority Confs", t, func() {
+		total, tapdBugPriorityConfs, err := d.FindTapdBugPriorityConfs(queryTapdBugPriorityConfsRequest)
+		So(err, ShouldBeNil)
+		So(total, ShouldBeGreaterThan, 0)
+		So(len(tapdBugPriorityConfs), ShouldBeGreaterThan, 0)
+	})
+
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_record.go

@@ -0,0 +1,57 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertTapdBugRecord Insert Tapd Bug Insert Log.
+func (d *Dao) InsertTapdBugRecord(tapdBugRecord *model.TapdBugRecord) error {
+	return pkgerr.WithStack(d.db.Create(tapdBugRecord).Error)
+}
+
+// UpdateTapdBugRecord Update Tapd Bug Insert Log.
+func (d *Dao) UpdateTapdBugRecord(tapdBugRecord *model.TapdBugRecord) error {
+	return pkgerr.WithStack(d.db.Save(&tapdBugRecord).Error)
+}
+
+// QueryTapdBugRecordByProjectIDAndStatus Query Tapd Bug Record By Project ID and status
+func (d *Dao) QueryTapdBugRecordByProjectIDAndStatus(projectID int64, status int) (tapdBugRecords []*model.TapdBugRecord, err error) {
+	err = pkgerr.WithStack(d.db.Where("project_template_id = ? and status = ?", projectID, status).Find(&tapdBugRecords).Error)
+	return
+}
+
+// QueryTapdBugRecordByStatus Query Tapd Bug Record By and status
+func (d *Dao) QueryTapdBugRecordByStatus(status int) (tapdBugRecords []*model.TapdBugRecord, err error) {
+	err = pkgerr.WithStack(d.db.Where("status = ?", status).Find(&tapdBugRecords).Error)
+	return
+}
+
+// FindBugRecords Find Bug Records.
+func (d *Dao) FindBugRecords(req *model.QueryBugRecordsRequest) (total int64, tapdBugRecords []*model.TapdBugRecord, err error) {
+	gDB := d.db.Model(&model.TapdBugRecord{})
+
+	if req.ProjectTemplateID > 0 {
+		gDB = gDB.Where("project_template_id=?", req.ProjectTemplateID)
+	}
+
+	if req.VersionTemplateID > 0 {
+		gDB = gDB.Where("version_template_id=?", req.VersionTemplateID)
+	}
+
+	if req.Operator != "" {
+		gDB = gDB.Where("operator=?", req.Operator)
+	}
+
+	if req.Status > 0 {
+		gDB = gDB.Where("status=?", req.Status)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&tapdBugRecords).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_record_test.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmpID = time.Now().Unix()
+
+	tapdBugRecord = &model.TapdBugRecord{
+		ProjectTemplateID: tmpID,
+		VersionTemplateID: tmpID + 1,
+		Operator:          "fengyifeng",
+		Count:             10,
+		Status:            model.InsertBugStatusRunning,
+		IssueFilterSQL:    "SELECT * FROM bugly_issues WHERE issue_no = '265'",
+	}
+)
+
+func Test_Tapd_bug_record(t *testing.T) {
+	Convey("test Insert Tapd Bug Record", t, func() {
+		err := d.InsertTapdBugRecord(tapdBugRecord)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Update Tapd Bug Record", t, func() {
+		tapdBugRecord.Status = model.InsertBugStatusDone
+		err := d.UpdateTapdBugRecord(tapdBugRecord)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Query Tapd Bug Record By Project ID And Status", t, func() {
+		tapdBugRecords, err := d.QueryTapdBugRecordByProjectIDAndStatus(tapdBugRecord.ProjectTemplateID, model.InsertBugStatusDone)
+		So(err, ShouldBeNil)
+		So(len(tapdBugRecords), ShouldEqual, 1)
+	})
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_template.go

@@ -0,0 +1,66 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertTapdBugTemplate Insert Tapd Bug Template.
+func (d *Dao) InsertTapdBugTemplate(tapdBugTemplate *model.TapdBugTemplate) error {
+	return pkgerr.WithStack(d.db.Create(tapdBugTemplate).Error)
+}
+
+// UpdateTapdBugTemplate Update Tapd Bug Template.
+func (d *Dao) UpdateTapdBugTemplate(tapdBugTemplate *model.TapdBugTemplate) error {
+	return pkgerr.WithStack(d.db.Save(&tapdBugTemplate).Error)
+}
+
+// QueryTapdBugTemplate Query Tapd Bug Template.
+func (d *Dao) QueryTapdBugTemplate(id int64) (tapdBugTemplate *model.TapdBugTemplate, err error) {
+	tapdBugTemplate = &model.TapdBugTemplate{}
+	if err = d.db.Where("id=?", id).First(&tapdBugTemplate).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryTapdBugTemplateByProjectID Query Tapd Bug Template by project id.
+func (d *Dao) QueryTapdBugTemplateByProjectID(projectID string) (tapdBugTemplate *model.TapdBugTemplate, err error) {
+	tapdBugTemplate = &model.TapdBugTemplate{}
+	if err = d.db.Where("project_id=?", projectID).First(&tapdBugTemplate).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryAllTapdBugTemplates Query All Tapd Bug Templates.
+func (d *Dao) QueryAllTapdBugTemplates() (tapdBugTemplates []*model.TapdBugTemplate, err error) {
+	err = pkgerr.WithStack(d.db.Model(&model.TapdBugTemplate{}).Find(&tapdBugTemplates).Error)
+	return
+}
+
+// FindTapdBugTemplates Find tapd Bug Templates.
+func (d *Dao) FindTapdBugTemplates(req *model.QueryTapdBugTemplateRequest) (total int64, tapdBugTemplates []*model.TapdBugTemplate, err error) {
+	gDB := d.db.Model(&model.TapdBugTemplate{})
+
+	if req.UpdateBy != "" {
+		gDB = gDB.Where("update_by=?", req.UpdateBy)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&tapdBugTemplates).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_template_test.go

@@ -0,0 +1,75 @@
+package dao
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmp5 = strconv.FormatInt(time.Now().Unix(), 10)
+
+	tapdBugTemplate = &model.TapdBugTemplate{
+		WorkspaceID:    tmp5,
+		IssueFilterSQL: "SELECT * FROM bugly_issues WHERE issue_no = '265'",
+		SeverityKey:    "SeverityKey" + tmp5,
+		UpdateBy:       "fengyifeng",
+
+		TapdProperty: model.TapdProperty{
+			Title:            "Title" + tmp5,
+			Description:      "Description" + tmp5,
+			CurrentOwner:     "CurrentOwner" + tmp5,
+			Platform:         "Platform" + tmp5,
+			Module:           "Module" + tmp5,
+			IterationID:      "IterationID" + tmp5,
+			ReleaseID:        "ReleaseID" + tmp5,
+			Priority:         "Priority" + tmp5,
+			Severity:         "Severity" + tmp5,
+			Source:           "Source" + tmp5,
+			CustomFieldFour:  "CustomFieldFour" + tmp5,
+			BugType:          "BugType" + tmp5,
+			OriginPhase:      "OriginPhase" + tmp5,
+			CustomFieldThree: "CustomFieldThree" + tmp5,
+			Reporter:         "Reporter" + tmp5,
+			Status:           "Status" + tmp5,
+		},
+	}
+
+	queryTapdBugTemplateRequest = &model.QueryTapdBugTemplateRequest{
+		Pagination: model.Pagination{
+			PageSize: 10,
+			PageNum:  1,
+		},
+	}
+)
+
+func Test_Tapd_bug_template(t *testing.T) {
+	Convey("test Insert Tapd Bug Template", t, func() {
+		err := d.InsertTapdBugTemplate(tapdBugTemplate)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Update Tapd Bug Template", t, func() {
+		tapdBugTemplate.UpdateBy = "xuneng"
+		err := d.UpdateTapdBugTemplate(tapdBugTemplate)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Query Tapd Bug Template", t, func() {
+		tmpTapdBugTemplate, err := d.QueryTapdBugTemplate(tapdBugTemplate.ID)
+		So(err, ShouldBeNil)
+		So(tmpTapdBugTemplate.ID, ShouldEqual, tapdBugTemplate.ID)
+	})
+
+	Convey("test Find Tapd Bug Templates", t, func() {
+		total, tapdBugTemplates, err := d.FindTapdBugTemplates(queryTapdBugTemplateRequest)
+		So(err, ShouldBeNil)
+		So(total, ShouldBeGreaterThan, 0)
+		So(len(tapdBugTemplates), ShouldBeGreaterThan, 0)
+	})
+
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_version_template.go

@@ -0,0 +1,68 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// InsertTapdBugVersionTemplate Insert TapdBug Version Template.
+func (d *Dao) InsertTapdBugVersionTemplate(tapdBugVersionTemplate *model.TapdBugVersionTemplate) error {
+	return pkgerr.WithStack(d.db.Create(tapdBugVersionTemplate).Error)
+}
+
+// UpdateTapdBugVersionTemplate Update Tapd Bug Version Template.
+func (d *Dao) UpdateTapdBugVersionTemplate(tapdBugVersionTemplate *model.TapdBugVersionTemplate) error {
+	return pkgerr.WithStack(d.db.Save(&tapdBugVersionTemplate).Error)
+}
+
+// QueryTapdBugVersionTemplate Query Tapd Bug Version Template.
+func (d *Dao) QueryTapdBugVersionTemplate(id int64) (tapdBugVersionTemplate *model.TapdBugVersionTemplate, err error) {
+	tapdBugVersionTemplate = &model.TapdBugVersionTemplate{}
+	if err = d.db.Where("id=?", id).First(&tapdBugVersionTemplate).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// QueryTapdBugVersionTemplateByVersion Query Tapd Bug Version Template.
+func (d *Dao) QueryTapdBugVersionTemplateByVersion(version string) (tapdBugVersionTemplate *model.TapdBugVersionTemplate, err error) {
+	tapdBugVersionTemplate = &model.TapdBugVersionTemplate{}
+	if err = d.db.Where("version=?", version).First(&tapdBugVersionTemplate).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// FindTapdBugVersionTemplates Find Tapd Bug Version Templates.
+func (d *Dao) FindTapdBugVersionTemplates(req *model.QueryTapdBugVersionTemplateRequest) (total int64, tapdBugVersionTemplate []*model.TapdBugVersionTemplate, err error) {
+	gDB := d.db.Model(&model.TapdBugVersionTemplate{})
+
+	if req.ProjectID > 0 {
+		gDB = gDB.Where("project_template_id = ?", req.ProjectID)
+	}
+
+	if req.Version != "" {
+		gDB = gDB.Where("version like ?", req.Version+_wildcards)
+	}
+
+	if req.UpdateBy != "" {
+		gDB = gDB.Where("update_by = ?", req.UpdateBy)
+	}
+
+	if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
+		return
+	}
+
+	err = pkgerr.WithStack(gDB.Order("ctime desc").Offset((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).Find(&tapdBugVersionTemplate).Error)
+	return
+}

app/admin/ep/marthe/dao/mysql_tapd_bug_version_template_test.go

@@ -0,0 +1,82 @@
+package dao
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/marthe/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	tmp6 = strconv.FormatInt(time.Now().Unix(), 10)
+
+	tapdBugVersionTemplate = &model.TapdBugVersionTemplate{
+		Version:           "version" + tmp6,
+		ProjectTemplateID: 10,
+		IssueFilterSQL:    "SELECT * FROM bugly_issues WHERE issue_no = '265'",
+		SeverityKey:       "SeverityKey" + tmp6,
+		UpdateBy:          "fengyifeng",
+
+		TapdProperty: model.TapdProperty{
+			Title:            "Title" + tmp6,
+			Description:      "Description" + tmp6,
+			CurrentOwner:     "CurrentOwner" + tmp6,
+			Platform:         "Platform" + tmp6,
+			Module:           "Module" + tmp6,
+			IterationID:      "IterationID" + tmp6,
+			ReleaseID:        "ReleaseID" + tmp6,
+			Priority:         "Priority" + tmp6,
+			Severity:         "Severity" + tmp6,
+			Source:           "Source" + tmp6,
+			CustomFieldFour:  "CustomFieldFour" + tmp6,
+			BugType:          "BugType" + tmp6,
+			OriginPhase:      "OriginPhase" + tmp6,
+			CustomFieldThree: "CustomFieldThree" + tmp6,
+			Reporter:         "Reporter" + tmp6,
+			Status:           "Status" + tmp6,
+		},
+	}
+
+	queryTapdBugVersionTemplateRequest = &model.QueryTapdBugVersionTemplateRequest{
+		Pagination: model.Pagination{
+			PageSize: 10,
+			PageNum:  1,
+		},
+		Version: tapdBugVersionTemplate.Version,
+	}
+)
+
+func Test_Tapd_bug_version_template(t *testing.T) {
+	Convey("test Insert Tapd Bug version Template", t, func() {
+		err := d.InsertTapdBugVersionTemplate(tapdBugVersionTemplate)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Update Tapd Bug version Template", t, func() {
+		tapdBugTemplate.UpdateBy = "xuneng"
+		err := d.UpdateTapdBugVersionTemplate(tapdBugVersionTemplate)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test Query Tapd Bug version Template", t, func() {
+		tmpTapdBugVersionTemplate, err := d.QueryTapdBugVersionTemplate(tapdBugVersionTemplate.ID)
+		So(err, ShouldBeNil)
+		So(tmpTapdBugVersionTemplate.ID, ShouldEqual, tapdBugVersionTemplate.ID)
+	})
+
+	Convey("test Query Tapd Bug Version Template By version", t, func() {
+		tmpTapdBugVersionTemplate, err := d.QueryTapdBugVersionTemplateByVersion(tapdBugVersionTemplate.Version)
+		So(err, ShouldBeNil)
+		So(tmpTapdBugVersionTemplate.ID, ShouldEqual, tapdBugVersionTemplate.ID)
+	})
+
+	Convey("test Find Tapd Bug version Templates", t, func() {
+		total, tapdBugVersionTemplate, err := d.FindTapdBugVersionTemplates(queryTapdBugVersionTemplateRequest)
+		So(err, ShouldBeNil)
+		So(total, ShouldBeGreaterThan, 0)
+		So(len(tapdBugVersionTemplate), ShouldBeGreaterThan, 0)
+	})
+}

app/admin/ep/marthe/dao/mysql_user.go

@@ -0,0 +1,43 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// FindUserByUserName find user by username.
+func (d *Dao) FindUserByUserName(name string) (user *model.User, err error) {
+	user = &model.User{}
+	if err = d.db.Where("name = ?", name).First(user).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		} else {
+			err = pkgerr.WithStack(err)
+		}
+	}
+	return
+}
+
+// FindUserByID find user by id.
+func (d *Dao) FindUserByID(ID int64) (user *model.User, err error) {
+	user = &model.User{}
+	err = pkgerr.WithStack(d.db.Where("id = ?", ID).First(user).Error)
+	return
+}
+
+// CreateUser create user.
+func (d *Dao) CreateUser(user *model.User) error {
+	return pkgerr.WithStack(d.db.Create(user).Error)
+}
+
+// DelUser delete user.
+func (d *Dao) DelUser(user *model.User) error {
+	return pkgerr.WithStack(d.db.Delete(user).Error)
+}
+
+// UpdateUserVisibleBugly Update User Visible Bugly.
+func (d *Dao) UpdateUserVisibleBugly(ID int64, visibleBugly bool) error {
+	return pkgerr.WithStack(d.db.Model(&model.User{}).Where("id = ?", ID).Update("visible_bugly", visibleBugly).Error)
+}

app/admin/ep/marthe/dao/mysql_user_test.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"go-common/app/admin/ep/marthe/model"
+)
+
+var (
+	testTime = time.Now().Format("2006_01_02_15_04_05")
+	testUser = model.User{
+		Name:  testTime,
+		EMail: testTime + "@bilibili.com"}
+)
+
+func Test_User(t *testing.T) {
+	Convey("test CreateUser", t, func() {
+		err := d.CreateUser(&testUser)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("find user by user name", t, func() {
+		userInDb, err := d.FindUserByUserName(testUser.Name)
+		So(userInDb.EMail, ShouldEqual, testUser.EMail)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("find user by id", t, func() {
+		userID := testUser.ID
+		userInDb, err := d.FindUserByID(userID)
+		So(userInDb.EMail, ShouldEqual, testUser.EMail)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("delete user", t, func() {
+		err := d.DelUser(&testUser)
+		So(err, ShouldBeNil)
+	})
+
+}

app/admin/ep/marthe/dao/tapd.go

@@ -0,0 +1,221 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"go-common/app/admin/ep/marthe/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_userName    = "bilibilinik"
+	_password    = "0989D4F0-AF9D-949F-C950-E22A3F891NIK"
+	_successCode = 1
+
+	_releaseURL       = "https://api.tapd.cn/releases?workspace_id=%s&id=%s"
+	_bugPreURL        = "https://api.tapd.cn/bugs?workspace_id=%s&id=%s"
+	_createBugURL     = "https://api.tapd.cn/bugs"
+	_workspaceUserURL = "https://api.tapd.cn/workspaces/users?workspace_id=%s&fields=user"
+)
+
+//Bug Bug
+func (d *Dao) Bug(bugURL string) (res *model.BugResponse, err error) {
+	var req *http.Request
+	res = &model.BugResponse{}
+	if req, err = d.newTapdRequest(http.MethodGet, bugURL, nil); err != nil {
+		log.Error("Bug url(%s) res(%v) err(%v)", bugURL, res, err)
+		return nil, ecode.MartheTapdErr
+	}
+	if err = d.httpClient.Do(context.TODO(), req, res); err != nil {
+		log.Error("WorkspaceUser url(%s) res(%v) err(%v)", bugURL, res, err)
+		err = ecode.MartheTapdResDataErr
+		return
+	}
+
+	if res.Status != _successCode {
+		log.Error("WorkspaceUser url(%s) res(%v) err(%v)", bugURL, res, err)
+		err = ecode.MartheTapdResDataErr
+	}
+	return
+}
+
+//BugPre Bug Pre
+func (d *Dao) BugPre(workSpaceID, bugID string) (bug *model.Bug, err error) {
+	var (
+		req *http.Request
+		res = &model.BugSingleResponse{}
+	)
+
+	url := fmt.Sprintf(_bugPreURL, workSpaceID, bugID)
+	if req, err = d.newTapdRequest(http.MethodGet, url, nil); err != nil {
+		log.Error("BugPre url(%s) res(%v) err(%v)", url, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+	if err = d.httpClient.Do(context.TODO(), req, res); err != nil || res.Data == nil {
+		log.Error("BugPre url(%s) res(%v) err(%v)", url, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if res.Status != _successCode || res.Data == nil {
+		log.Error("BugPre url(%s) res(%v) err(%v)", url, res, err)
+		err = ecode.MartheTapdResDataErr
+		return
+	}
+
+	bug = res.Data.Bug
+	return
+}
+
+//Release Release
+func (d *Dao) Release(workSpaceID, releaseID string) (release *model.Release, err error) {
+	var (
+		req *http.Request
+		res = &model.ReleaseResponse{}
+	)
+
+	releaseURL := fmt.Sprintf(_releaseURL, workSpaceID, releaseID)
+	if req, err = d.newTapdRequest(http.MethodGet, releaseURL, nil); err != nil {
+		log.Error("Release url(%s) res(%v) err(%v)", _releaseURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+	if err = d.httpClient.Do(context.TODO(), req, res); err != nil || res.Data == nil {
+		log.Error("Release url(%s) res(%v) err(%v)", _releaseURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if res.Status != _successCode || res.Data == nil {
+		log.Error("Release url(%s) res(%v) err(%v)", _releaseURL, res, err)
+		err = ecode.MartheTapdResDataErr
+		return
+	}
+
+	release = res.Data.Release
+	return
+}
+
+// ReleaseName ReleaseName
+func (d *Dao) ReleaseName(workspaceID, releaseID string) (releaseName string, err error) {
+	var (
+		item    *memcache.Item
+		conn    = d.mc.Get(context.Background())
+		release *model.Release
+	)
+	defer conn.Close()
+
+	if item, err = conn.Get(workspaceID + releaseID); err == nil {
+		if err = json.Unmarshal(item.Value, &releaseName); err != nil {
+			log.Error("Json unmarshal err(%v)", err)
+		}
+		return
+	}
+
+	if release, err = d.Release(workspaceID, releaseID); err != nil {
+		return
+	}
+	releaseName = release.Name
+	item = &memcache.Item{Key: workspaceID + releaseID, Object: release.Name, Flags: memcache.FlagJSON, Expiration: d.expire}
+	d.cacheSave(context.Background(), item)
+	return
+}
+
+//newTapdRequest new tapd request
+func (d *Dao) newTapdRequest(method, url string, v interface{}) (req *http.Request, err error) {
+	req, err = d.newRequest(method, url, v)
+	req.SetBasicAuth(_userName, _password)
+	return
+}
+
+// CreateBug Create Bug.
+func (d *Dao) CreateBug(bug *model.Bug) (bugID string, err error) {
+	var (
+		req *http.Request
+		res = &model.BugSingleResponse{}
+	)
+
+	if req, err = d.newTapdRequest(http.MethodPost, _createBugURL, bug); err != nil {
+		log.Error("CreateBug url(%s) res(%v) err(%v)", _createBugURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if err = d.httpClient.Do(context.TODO(), req, res); err != nil {
+		log.Error("CreateBug url(%s) res(%v) err(%v)", _createBugURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if res.Status != _successCode {
+		log.Error("CreateBug url(%s) res(%v) err(%v)", _createBugURL, res, err)
+		err = ecode.MartheTapdResDataErr
+	}
+
+	bugID = res.Data.Bug.ID
+	return
+}
+
+// UpdateBug Update Bug.
+func (d *Dao) UpdateBug(bug *model.UpdateBug) (err error) {
+	var (
+		req *http.Request
+		res = &model.BugSingleResponse{}
+	)
+
+	if req, err = d.newTapdRequest(http.MethodPost, _createBugURL, bug); err != nil {
+		log.Error("UpdateBug url(%s) res(%v) err(%v)", _createBugURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if err = d.httpClient.Do(context.TODO(), req, res); err != nil {
+		log.Error("UpdateBug url(%s) res(%v) err(%v)", _createBugURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if res.Status != _successCode {
+		log.Error("UpdateBug url(%s) res(%v) err(%v)", _createBugURL, res, err)
+		err = ecode.MartheTapdResDataErr
+	}
+
+	return
+}
+
+// WorkspaceUser Workspace User
+func (d *Dao) WorkspaceUser(workspaceID string) (usernames []string, err error) {
+	var (
+		req *http.Request
+		res = &model.WorkspaceUserResponse{}
+	)
+
+	workspaceUserURL := fmt.Sprintf(_workspaceUserURL, workspaceID)
+	if req, err = d.newTapdRequest(http.MethodGet, workspaceUserURL, nil); err != nil {
+		log.Error("WorkspaceUser url(%s) res(%v) err(%v)", workspaceUserURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+	if err = d.httpClient.Do(context.TODO(), req, res); err != nil {
+		log.Error("WorkspaceUser url(%s) res(%v) err(%v)", workspaceUserURL, res, err)
+		err = ecode.MartheTapdErr
+		return
+	}
+
+	if res.Status != _successCode || res.Data == nil {
+		log.Error("WorkspaceUser url(%s) res(%v) err(%v)", workspaceUserURL, res, err)
+		err = ecode.MartheTapdResDataErr
+		return
+	}
+
+	for _, workspaceUser := range res.Data {
+		usernames = append(usernames, workspaceUser.UserWrapper.User)
+	}
+	return
+}

app/admin/ep/marthe/dao/wechat.go

@@ -0,0 +1,80 @@
+package dao
+
+import (
+	"context"
+	"net/url"
+
+	"go-common/app/admin/ep/marthe/model"
+)
+
+const (
+	_qyWechatURL  = "https://qyapi.weixin.qq.com"
+	_corpID       = "wx0833ac9926284fa5" // 企业微信：Bilibili的企业ID
+	_departmentID = "12"                 // 公司统一用部门ID
+	_corpsecret   = "WveODxk3xpT9box48wcxkmArx3mu6d4vJHdJkNy_iTk"
+
+	_getToken = "/cgi-bin/gettoken"
+	_userList = "/cgi-bin/user/list"
+)
+
+// WechatAccessToken query access token with the specified secret 企业微信api获取公司token
+func (d *Dao) WechatAccessToken(c context.Context) (token string, err error) {
+	var (
+		u      string
+		params = url.Values{}
+		res    struct {
+			ErrCode     int    `json:"errcode"`
+			ErrMsg      string `json:"errmsg"`
+			AccessToken string `json:"access_token"`
+			ExpiresIn   int32  `json:"expires_in"`
+		}
+	)
+	u = _qyWechatURL + _getToken
+	params.Set("corpid", _corpID)
+	params.Set("corpsecret", _corpsecret)
+
+	if err = d.httpClient.Get(c, u, "", params, &res); err != nil {
+		return
+	}
+
+	if res.ErrCode != 0 {
+		return
+	}
+
+	token = res.AccessToken
+	return
+}
+
+// WechatContacts Wechat Contacts 获取用户信息列表
+func (d *Dao) WechatContacts(c context.Context) (contacts []*model.WechatContact, err error) {
+	var (
+		token  string
+		u      string
+		params = url.Values{}
+		res    struct {
+			ErrCode  int                    `json:"errcode"`
+			ErrMsg   string                 `json:"errmsg"`
+			UserList []*model.WechatContact `json:"userlist"`
+		}
+	)
+	//get token
+	if token, err = d.WechatAccessToken(c); err != nil {
+		return
+	}
+
+	u = _qyWechatURL + _userList
+	params.Set("access_token", token)
+	params.Set("department_id", _departmentID)
+	params.Set("fetch_child", "1")
+
+	if err = d.httpClient.Get(c, u, "", params, &res); err != nil {
+		return
+	}
+
+	if res.ErrCode != 0 {
+		return
+	}
+
+	contacts = res.UserList
+	return
+}