Create & Init Project...

app/admin/ep/melloi/dao/BUILD

@@ -0,0 +1,89 @@
+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",
+        "order_admin_test.go",
+        "order_test.go",
+        "rank_test.go",
+        "scene_test.go",
+        "user_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/ep/melloi/conf:go_default_library",
+        "//app/admin/ep/melloi/model:go_default_library",
+        "//vendor/github.com/go-sql-driver/mysql:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "apply.go",
+        "bfs.go",
+        "clientmoni.go",
+        "cluster.go",
+        "comment.go",
+        "dao.go",
+        "dapper.go",
+        "job.go",
+        "label.go",
+        "mail.go",
+        "mysql_grpc.go",
+        "mysql_grpc_snap.go",
+        "order.go",
+        "order_admin.go",
+        "order_report.go",
+        "ptestjob.go",
+        "rank.go",
+        "report.go",
+        "reportgraph.go",
+        "scene.go",
+        "script.go",
+        "tree.go",
+        "user.go",
+        "wechat.go",
+    ],
+    importpath = "go-common/app/admin/ep/melloi/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/ep/melloi/conf:go_default_library",
+        "//app/admin/ep/melloi/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/stat/prom: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"],
+)

app/admin/ep/melloi/dao/apply.go

@@ -0,0 +1,46 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// QueryApply query apply list
+func (d *Dao) QueryApply(apply *model.Apply, pn, ps int32) (qar *model.QueryApplyResponse, err error) {
+	qar = &model.QueryApplyResponse{}
+	err = d.DB.Table(model.Apply{}.TableName()).Where(model.Apply{
+		ID: apply.ID, From: apply.From, To: apply.To, Status: apply.Status, Active: model.ApplyValid}).
+		Count(&qar.TotalSize).Offset((pn - 1) * ps).Limit(ps).Order("id desc").Find(&qar.ApplyList).Error
+	qar.PageSize = ps
+	qar.PageNum = pn
+	return
+}
+
+// QueryUserApplyList query user apply list
+func (d *Dao) QueryUserApplyList(userName string) (applyList []*model.Apply, err error) {
+	applyList = []*model.Apply{}
+	err = d.DB.Table(model.Apply{}.TableName()).Where("`from`=?", userName).
+		Where("`active`=?", 1).Where("`status`=?", model.ApplyValid).Find(&applyList).Error
+	return
+}
+
+//QueryApplyByID query apply by id
+func (d *Dao) QueryApplyByID(id int64) (apply *model.Apply, err error) {
+	apply = &model.Apply{}
+	err = d.DB.Table(model.Apply{}.TableName()).Where("id = ?", id).First(apply).Error
+	return
+}
+
+//AddApply add apply
+func (d *Dao) AddApply(apply *model.Apply) error {
+	return d.DB.Model(&model.Apply{}).Create(apply).Error
+}
+
+// UpdateApply update apply info
+func (d *Dao) UpdateApply(apply *model.Apply) error {
+	return d.DB.Model(&model.Apply{}).Updates(apply).Where("ID=?", apply.ID).Error
+}
+
+// DeleteApply delete apply info
+func (d *Dao) DeleteApply(id int64) error {
+	return d.DB.Model(&model.Apply{}).Where("ID=?", id).Update("active", model.ApplyInvalid).Error
+}

app/admin/ep/melloi/dao/bfs.go

@@ -0,0 +1,102 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"hash"
+	"net/http"
+	"strconv"
+	"time"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_bucketName = "melloi"
+	_melloiURI  = "/bfs/" + _bucketName
+)
+
+// UploadImg upload img
+func (d *Dao) UploadImg(c context.Context, imgContent []byte, imgName string) (location string, err error) {
+
+	var (
+		req    *http.Request
+		reqURL = d.c.BfsConf.Host + _melloiURI + "/" + imgName
+		resp   *http.Response
+		code   int
+	)
+	buf := new(bytes.Buffer)
+	if _, err = buf.Write(imgContent); err != nil {
+		log.Error("Upload.buf.Write.error(%v)", err)
+		return
+	}
+
+	if req, err = http.NewRequest("PUT", reqURL, buf); err != nil {
+		err = ecode.RequestErr
+		return
+	}
+
+	authorization := d.Authorize(d.c.BfsConf.AccessKey, d.c.BfsConf.AccessSecret, http.MethodPut, _bucketName, imgName, time.Now().Unix())
+	req.Header.Set("Authorization", authorization)
+	req.Header.Set("Content-Type", "image/png")
+
+	if resp, err = d.client.Do(req); err != nil {
+		log.Error("Upload.client.Do.error(%v)", err)
+		return
+	}
+	defer resp.Body.Close()
+	switch resp.StatusCode {
+	case http.StatusOK:
+	case http.StatusBadRequest:
+		err = ecode.RequestErr
+		return
+	case http.StatusUnauthorized:
+		// 验证不通过
+		err = ecode.BfsUploadAuthErr
+		return
+	case http.StatusRequestEntityTooLarge:
+		err = ecode.FileTooLarge
+		return
+	case http.StatusNotFound:
+		err = ecode.NothingFound
+		return
+	case http.StatusMethodNotAllowed:
+		err = ecode.MethodNotAllowed
+		return
+	case http.StatusServiceUnavailable:
+		err = ecode.BfsUploadServiceUnavailable
+		return
+	case http.StatusInternalServerError:
+		err = ecode.ServerErr
+		return
+	default:
+		err = ecode.BfsUploadStatusErr
+		return
+	}
+	if code, err = strconv.Atoi(resp.Header.Get("code")); err != nil || code != 200 {
+		err = ecode.BfsUploadCodeErr
+		return
+	}
+	location = resp.Header.Get("location")
+	return
+}
+
+// Authorize .
+func (d *Dao) Authorize(key, secret, method, bucket, fileName string, expire int64) (authorization string) {
+	var (
+		content   string
+		mac       hash.Hash
+		signature string
+	)
+	content = fmt.Sprintf("%s\n%s\n%s\n%d\n", method, bucket, fileName, expire)
+	mac = hmac.New(sha1.New, []byte(secret))
+	mac.Write([]byte(content))
+	signature = base64.StdEncoding.EncodeToString(mac.Sum(nil))
+	authorization = fmt.Sprintf("%s:%s:%d", key, signature, expire)
+	return
+}

app/admin/ep/melloi/dao/clientmoni.go

@@ -0,0 +1,16 @@
+package dao
+
+import "go-common/app/admin/ep/melloi/model"
+
+//AddClientMoni add ClientMoni
+func (d *Dao) AddClientMoni(clientMoni *model.ClientMoni) (clientMoniID int, err error) {
+	err = d.DB.Create(clientMoni).Error
+	clientMoniID = clientMoni.ID
+	return
+}
+
+//QueryClientMoni query ClientMoni
+func (d *Dao) QueryClientMoni(clientMoni *model.ClientMoni) (clm []*model.ClientMoni, err error) {
+	err = d.DB.Table(model.ClientMoni{}.TableName()).Where(clientMoni).Find(&clm).Error
+	return
+}

app/admin/ep/melloi/dao/cluster.go

@@ -0,0 +1,70 @@
+package dao
+
+import (
+	"context"
+	"net/http"
+
+	"go-common/app/admin/ep/melloi/conf"
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_rmTokenURI     = "/api/v1/auth"
+	_clusterNodeURI = "/api/v1/clusters?env=uat"
+)
+
+//RmToken get PaaS token
+func (d *Dao) RmToken(c context.Context) (token string, err error) {
+	var (
+		req         *http.Request
+		tokenURL    = d.c.ServiceCluster.TestHost + _rmTokenURI
+		res         = &model.ClusterRmTokenResponse{}
+		rmTokenPost = &model.RmTokenPost{
+			APIToken:   conf.Conf.Paas.APIToken,
+			PlatformID: conf.Conf.Paas.PlatformID,
+		}
+	)
+	if req, err = d.newRequest(http.MethodPost, tokenURL, rmTokenPost); err != nil {
+		log.Error("query paas machine url(%s) err(%v)", tokenURL, err)
+		return
+	}
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("RmToken error :(%v)", err)
+		err = ecode.MelloiPaasRequestErr
+		return
+	}
+	if err = res.CheckStatus(); err != nil {
+		return
+	}
+	token = res.Data.Token
+	return
+}
+
+//NetInfo get melloi server use
+func (d *Dao) NetInfo(c context.Context, token string) (cluster []*model.ClusterResponseItemsSon, err error) {
+	var (
+		url        = d.c.ServiceCluster.UatHost + _clusterNodeURI
+		req        *http.Request
+		resCluster = &model.ClusterResponse{}
+	)
+
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+
+	if err = d.httpClient.Do(c, req, &resCluster); err != nil {
+		log.Error("d.Token url(%s) res($s) err(%v)", url, err)
+		err = ecode.MelloiPaasRequestErr
+		return
+	}
+	if err = resCluster.CheckStatus(); err != nil {
+		return
+	}
+	cluster = resCluster.Data.Items
+	return
+}

app/admin/ep/melloi/dao/comment.go

@@ -0,0 +1,30 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+//AddComment add comment for performance test task
+func (d *Dao) AddComment(comment *model.Comment) error {
+	//comment.Status = 1
+	return d.DB.Table(model.Comment{}.TableName()).Create(comment).Error
+}
+
+//QueryComment query comment
+func (d *Dao) QueryComment(comment *model.Comment) (res *model.QueryCommentResponse, err error) {
+	res = &model.QueryCommentResponse{}
+	//comment.Status = 1
+	err = d.DB.Table(model.Comment{}.TableName()).Where(comment).Count(&res.Total).Order("id desc").Find(&res.Comments).Error
+	return
+}
+
+//UpdateComment update comment
+func (d *Dao) UpdateComment(comment *model.Comment) error {
+	//return d.DB.Table(model.Comment{}.TableName()).Update(comment).Where("ID=?", comment.ID).Error
+	return d.DB.Model(&model.Comment{}).Update(comment).Where("ID=?", comment.ID).Error
+}
+
+//DeleteComment delete comment
+func (d *Dao) DeleteComment(id int64) error {
+	return d.DB.Model(&model.Comment{}).Where("ID=?", id).Update("status", 2).Error
+}

app/admin/ep/melloi/dao/dao.go

@@ -0,0 +1,79 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"go-common/app/admin/ep/melloi/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/stat/prom"
+
+	"github.com/jinzhu/gorm"
+	"gopkg.in/gomail.v2"
+)
+
+// Prometheus
+var (
+	errorsCount = prom.BusinessErrCount
+)
+
+// Dao dao
+type Dao struct {
+	c          *conf.Config
+	DB         *gorm.DB
+	httpClient *xhttp.Client
+	client     *http.Client
+	MC         *memcache.Pool
+	email      *gomail.Dialer
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:          c,
+		httpClient: xhttp.NewClient(c.HTTPClient),
+		email:      gomail.NewDialer(c.Mail.Host, c.Mail.Port, c.Mail.Username, c.Mail.Password),
+		client:     new(http.Client),
+		DB:         orm.NewMySQL(c.ORM),
+		MC:         memcache.NewPool(c.Memcache),
+	}
+	return
+}
+
+// Ping verify server is ok.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if err = d.DB.DB().Ping(); err != nil {
+		log.Error("dao.cloudDB.Ping() error(%v)", err)
+		return
+	}
+	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), error(%v) ", v, err)
+			return
+		}
+	}
+	if req, err = http.NewRequest(method, url, body); err != nil {
+		log.Error("http new request url(%s), error(%v)", url, err)
+	}
+	return
+}
+
+// PromError prom error
+func PromError(name string) {
+	errorsCount.Incr(name)
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.DB.Close()
+}

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

@@ -0,0 +1,30 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+
+	"go-common/app/admin/ep/melloi/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/melloi/dao/dapper.go

@@ -0,0 +1,48 @@
+package dao
+
+import (
+	"context"
+	"net/http"
+
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_dapperDependUri = "/x/internal/dapper/service-depend?service_name="
+	_dapperRspCode   = 0
+)
+
+// QueryServiceDepend query service depend
+func (d *Dao) QueryServiceDepend(c context.Context, serviceName string) (ret []string, err error) {
+	var (
+		req       *http.Request
+		DependURL = d.c.Dapper.Host + _dapperDependUri + serviceName
+		res       struct {
+			Code    int                   `json:"code"`
+			Data    *model.DependResponse `json:"data"`
+			Message string                `json:"message"`
+		}
+	)
+
+	if req, err = d.newRequest(http.MethodGet, DependURL, nil); err != nil {
+		return
+	}
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.Depend url(%s) res($s) error(%v)", DependURL, res, err)
+		return
+	}
+	if res.Code != _dapperRspCode {
+		err = ecode.MelloiTreeRequestErr
+		log.Error("d.Tree.Response url(%s) resCode(%s) error(%v)", DependURL, res.Code, err)
+		return
+	}
+
+	for _, item := range res.Data.Items {
+		ret = append(ret, item.ServiceName)
+	}
+
+	return
+}

app/admin/ep/melloi/dao/job.go

@@ -0,0 +1,226 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"go-common/app/admin/ep/melloi/conf"
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_rmJob            = "/api/rm/job"
+	_jobNodeURI       = "/api/rm/jobs"
+	statsPort         = "8999"
+	statsPath         = "/ep/docker/stats"
+	_clearableDockers = "/ep/docker/get"
+	_dockerKeyword    = "run"
+)
+
+//AddJob add perf job
+func (d *Dao) AddJob(c context.Context, token string, jobInfo *model.Job) (cluster *model.PaasJobResponse, err error) {
+	var (
+		url        = d.c.ServiceCluster.TestHost + _jobNodeURI
+		req        *http.Request
+		passDetail []byte
+	)
+
+	paasJobDetail := &model.PaasJobDetail{
+		BusinessUnit:   conf.Conf.Paas.BusinessUnit,
+		Project:        conf.Conf.Paas.Project,
+		App:            conf.Conf.Paas.App,
+		Env:            conf.Conf.Paas.Env,
+		Name:           jobInfo.Name,
+		Image:          conf.Conf.Paas.Image,
+		ImageVersion:   conf.Conf.Paas.ImageVersion,
+		Volumes:        conf.Conf.Paas.Volumes,
+		CPURequest:     jobInfo.CPU / 4,
+		CPULimit:       jobInfo.CPU,
+		MemoryRequest:  jobInfo.Memory,
+		Command:        jobInfo.Command,
+		ResourcePoolID: conf.Conf.Paas.ResourcePoolID,
+		Parallelism:    jobInfo.Parallelism,
+		Completions:    conf.Conf.Paas.Completions,
+		RetriesLimit:   conf.Conf.Paas.RetriesLimit,
+		NetworkID:      conf.Conf.Paas.NetworkID,
+		ClusterID:      conf.Conf.Paas.ClusterID,
+		TreeID:         conf.Conf.Paas.TreeID,
+		HostInfo:       conf.Conf.Paas.HostInfo,
+		EnvInfo:        jobInfo.EnvInfo,
+	}
+
+	log.Info("Command:(%s)", paasJobDetail.Command)
+
+	if passDetail, err = json.Marshal(paasJobDetail); err != nil {
+		return
+	}
+	log.Info("passDetail:(%s)", string(passDetail))
+
+	if req, err = d.newRequest(http.MethodPost, url, paasJobDetail); err != nil {
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+	if err = d.httpClient.Do(c, req, &cluster); err != nil {
+		log.Error("d.AddJob url(%s) res($s) error(%v)", url, err)
+		return
+	}
+	return
+}
+
+//DeleteJob force stop perf job
+func (d *Dao) DeleteJob(c context.Context, token, name string) (cluster *model.PaasJobResponse, err error) {
+	log.Info("删除job -------- token:(%s), job_name(%s)： ", token, name)
+	var (
+		url = d.c.ServiceCluster.TestHost + _rmJob
+		req *http.Request
+	)
+
+	if req, err = d.newRequest(http.MethodDelete, url, nil); err != nil {
+		return
+	}
+	req.Header.Set("X-Authorization-Token", token)
+	q := req.URL.Query()
+	q.Add("business_unit", "test")
+	q.Add("project", "ep")
+	q.Add("app", "melloi-launch")
+	q.Add("env", "dev")
+	q.Add("name", name)
+	q.Add("cluster_id", "1")
+	q.Add("tree_id", "39400")
+	req.URL.RawQuery = q.Encode()
+	if err = d.httpClient.Do(c, req, &cluster); err != nil {
+		log.Error("d.Job url(%s) res($s) error(%v)", url, err)
+		err = ecode.MelloiPaasRequestErr
+		return
+	}
+	// 此处不return
+	if err = d.DeletePtestJobByJobName(name); err != nil {
+		log.Error("d.DeletePtestJobByJobName uerror(%v)", name)
+	}
+	return
+}
+
+// QueryCleanableDocker query clearable docker list
+func (d *Dao) QueryCleanableDocker(c context.Context) (dockers []*model.CleanableDocker, err error) {
+	var (
+		url    = fmt.Sprintf("%s:%d%s", d.c.DockerStatus.Host, d.c.DockerStatus.Port, _clearableDockers)
+		req    *http.Request
+		bs     []byte
+		result []string
+	)
+
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+	if bs, err = d.httpClient.Raw(c, req, ""); err != nil {
+		log.Error("d.job query clearable docker url(%s) error (%v)", url, err)
+		return
+	}
+	result = strings.Split(string(bs), "\n")
+	for _, item := range result {
+		var docker = &model.CleanableDocker{}
+		if strings.Contains(item, _dockerKeyword) {
+			docker.Name = item
+			dockers = append(dockers, docker)
+		}
+	}
+	return
+}
+
+//QueryJobCPU query job cpu status
+func (d *Dao) QueryJobCPU(c context.Context, token, jobName string) (responseBody *model.PaasQueryJobCPUResult, err error) {
+
+	Query := strings.Replace(conf.Conf.Paas.Query, "JobNamed", jobName, -1)
+	var (
+		url                       = d.c.ServiceCluster.QueryJobCPUHost
+		req                       *http.Request
+		paasQueryJobPostCPUDetail = &model.PaasQueryJobCPUPostDetail{
+			Action:     conf.Conf.Paas.Action,
+			PublicKey:  conf.Conf.Paas.PublicKey,
+			Signature:  conf.Conf.Paas.Signature,
+			DataSource: conf.Conf.Paas.DataSource,
+			Query:      Query,
+		}
+	)
+	if req, err = d.newRequest(http.MethodPost, url, paasQueryJobPostCPUDetail); err != nil {
+		return
+	}
+	req.Header.Set("X-Authorization-Token", token)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+	if err = d.httpClient.Do(c, req, &responseBody); err != nil {
+		log.Error("d.Job url(%s) res($s) error(%v)", url, err)
+		err = ecode.MelloiPaasRequestErr
+		return
+	}
+	return
+}
+
+//QueryJobCPUByEP query job cup by ep
+func (d *Dao) QueryJobCPUByEP(c context.Context, id, hostIP string) (dokcerStats *model.DockerStats, err error) {
+	var (
+		req *http.Request
+	)
+	url := "http://" + hostIP + ":" + statsPort + statsPath
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+	q := req.URL.Query()
+	q.Add("id", id)
+	req.URL.RawQuery = q.Encode()
+	if err = d.httpClient.Do(c, req, &dokcerStats); err != nil {
+		log.Error("d.queryJobCPU By EP err : url(%s)  error(%v)", url, err)
+		return
+	}
+	return
+}
+
+//Job get job info
+func (d *Dao) Job(c context.Context, token, name string) (responseBody *model.PaasJobQueryStatus, err error) {
+	var (
+		url = d.c.ServiceCluster.TestHost + _rmJob
+		req *http.Request
+	)
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+	q := req.URL.Query()
+	q.Add("business_unit", "test")
+	q.Add("project", "ep")
+	q.Add("app", "melloi-launch")
+	q.Add("env", "dev")
+	q.Add("name", name)
+	q.Add("cluster_id", "1")
+	q.Add("tree_id", "39400")
+	req.Header.Set("X-Authorization-Token", token)
+	req.URL.RawQuery = q.Encode()
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+	if err = d.httpClient.Do(c, req, &responseBody); err != nil {
+		log.Error("d.Job url(%s) res($s) error(%v)", url, err)
+		err = ecode.MelloiPaasRequestErr
+		return
+	}
+	return
+}
+
+//ForceDeleteJob Force Delete Job
+func (d *Dao) ForceDeleteJob(reportSuId int) (jobList *model.JobInfoList, err error) {
+	jobList = &model.JobInfoList{}
+	err = d.DB.Table("ptest_job").Select("host_ip, job_name").Where("report_su_id = ?", reportSuId).Find(&jobList.JobList).Error
+	return
+}
+
+//UpdateJobStatus Update Job Status
+func (d *Dao) UpdateJobStatus(reportSuId int) (err error) {
+	if err = d.DB.Model(&model.PtestJob{}).Where("report_su_id = ?", reportSuId).Update("active", -1).Error; err != nil {
+		return
+	}
+	return d.DB.Table("report_summary").Where("id = ?", reportSuId).Update("test_status", 3).Error
+}

app/admin/ep/melloi/dao/label.go

@@ -0,0 +1,76 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// AddLabel  add new label
+func (d *Dao) AddLabel(label *model.Label) error {
+	return d.DB.Table(model.Label{}.LabelName()).Create(label).Error
+}
+
+// QueryLabels  query all labels
+func (d *Dao) QueryLabels(c context.Context) (labels []*model.Label, err error) {
+	err = d.DB.Table(model.Label{}.LabelName()).Where("active = ?", 1).Find(&labels).Error
+	return
+}
+
+// QueryLabel query label by label name and id
+func (d *Dao) QueryLabel(lb *model.Label) (label *model.Label, err error) {
+	label = &model.Label{}
+	err = d.DB.Table(model.Label{}.LabelName()).Where("active = ?", 1).
+		Where(model.Label{Name: lb.Name, ID: lb.ID}).First(label).Error
+	return
+}
+
+// DeleteLabel delete label
+func (d *Dao) DeleteLabel(id int64) error {
+	return d.DB.Table(model.Label{}.LabelName()).Where("id = ?", id).Update("active", 0).Error
+}
+
+// AddLabelRelation add label relation of target
+func (d *Dao) AddLabelRelation(relation *model.LabelRelation) error {
+	return d.DB.Table(model.LabelRelation{}.LabelRelationName()).Create(relation).Error
+}
+
+// QueryLabelRelation query label relation
+func (d *Dao) QueryLabelRelation(lre *model.LabelRelation) (lr []*model.LabelRelation, err error) {
+	err = d.DB.Table(model.LabelRelation{}.LabelRelationName()).
+		Where("active = ?", 1).
+		Where(model.LabelRelation{Type: lre.Type, LabelID: lre.LabelID, TargetID: lre.TargetID}).Find(&lr).Error
+	return
+}
+
+// QueryLabelRelationByIDs  Query label relation by ids
+func (d *Dao) QueryLabelRelationByIDs(ids []int64) (lr []*model.LabelRelation, err error) {
+	err = d.DB.Table(model.LabelRelation{}.LabelRelationName()).Where(" active = ? ", 1).
+		Where("id in (?)", ids).Find(lr).Error
+	return
+}
+
+// CheckLabelRelationExist check label relation exist
+func (d *Dao) CheckLabelRelationExist(id int64) (result bool, err error) {
+	result = false
+	lr := &model.LabelRelation{}
+	err = d.DB.Table(model.LabelRelation{}.LabelRelationName()).Where("active = ?", 1).Where(" id = ?", id).First(lr).Error
+	if lr.ID > 0 {
+		result = true
+	}
+	return
+}
+
+// QueryLabelExist check label exist
+func (d *Dao) QueryLabelExist(lre *model.LabelRelation) (lr *model.LabelRelation, err error) {
+	lr = &model.LabelRelation{}
+	err = d.DB.Table(model.LabelRelation{}.LabelRelationName()).
+		Where("active = ?", 1).
+		Where(model.LabelRelation{Type: lre.Type, LabelID: lre.LabelID, TargetID: lre.TargetID}).First(lr).Error
+	return
+}
+
+// DeleteLabelRelation delete relation of label
+func (d *Dao) DeleteLabelRelation(id int64) (err error) {
+	return d.DB.Table(model.LabelRelation{}.LabelRelationName()).Where(" id = ?", id).Update("active", 0).Error
+}

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

@@ -0,0 +1,17 @@
+package dao
+
+import (
+	"go-common/library/log"
+
+	"gopkg.in/gomail.v2"
+)
+
+// SendMail asynchronous send mail.
+func (d *Dao) SendMail(message *gomail.Message) (err error) {
+	message.SetAddressHeader("From", d.email.Username, "melloi")
+	err = d.email.DialAndSend(message)
+	if err != nil {
+		log.Error("send email error :(%v)", err)
+	}
+	return
+}

app/admin/ep/melloi/dao/mysql_grpc.go

@@ -0,0 +1,62 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// QueryGRPC Query grpc
+func (d *Dao) QueryGRPC(grpc *model.GRPC, pn, ps int32, treeNodes []string) (qgr *model.QueryGRPCResponse, err error) {
+	qgr = &model.QueryGRPCResponse{}
+	grpc.Active = 1
+
+	gDB := d.DB.Table(model.GRPC{}.TableName()).Where("app in (?)", treeNodes)
+	if grpc.Department != "" && grpc.Project != "" && grpc.APP != "" {
+		gDB = gDB.Where("department = ? and project = ? and app = ?", grpc.Department, grpc.Project, grpc.APP)
+	} else if grpc.Department != "" && grpc.Project != "" {
+		gDB = gDB.Where("department = ? and project = ?", grpc.Department, grpc.Project)
+	} else if grpc.Department != "" {
+		gDB = gDB.Where("department = ?", grpc.Department)
+	}
+
+	err = gDB.Where(grpc).Count(&qgr.TotalSize).Offset((pn - 1) * ps).
+		Limit(ps).Order("id desc").Find(&qgr.GRPCS).Error
+	qgr.PageNum = pn
+	qgr.PageSize = ps
+	return
+}
+
+// QueryGRPCByWhiteName Query grpc By WhiteName
+func (d *Dao) QueryGRPCByWhiteName(grpc *model.GRPC, pn, ps int32) (qgr *model.QueryGRPCResponse, err error) {
+	qgr = &model.QueryGRPCResponse{}
+	grpc.Active = 1
+	err = d.DB.Table(model.GRPC{}.TableName()).Where(grpc).Count(&qgr.TotalSize).Offset((pn - 1) * ps).
+		Limit(ps).Order("id desc").Find(&qgr.GRPCS).Error
+	qgr.PageNum = pn
+	qgr.PageSize = ps
+	return
+}
+
+// QueryGRPCByID Query GRPC By ID
+func (d *Dao) QueryGRPCByID(id int) (grpc *model.GRPC, err error) {
+	grpc = &model.GRPC{}
+	err = pkgerr.WithStack(d.DB.Where("id = ?", id).First(grpc).Error)
+	return
+}
+
+// UpdateGRPC Update grpc
+func (d *Dao) UpdateGRPC(grpc *model.GRPC) error {
+	return d.DB.Table(model.GRPC{}.TableName()).Where("id=?", grpc.ID).Update(grpc).Error
+}
+
+//CreateGRPC  new grpc
+func (d *Dao) CreateGRPC(grpc *model.GRPC) (g *model.GRPC, err error) {
+	grpc.Active = 1
+	return grpc, pkgerr.WithStack(d.DB.Create(grpc).Error)
+}
+
+// DeleteGRPC Delete grpc
+func (d *Dao) DeleteGRPC(id int) error {
+	return d.DB.Table(model.GRPC{}.TableName()).Where("id=?", id).Update("active", -1).Error
+}

app/admin/ep/melloi/dao/mysql_grpc_snap.go

@@ -0,0 +1,30 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+// QueryGRPCSnapByID  query grpcsnap by id
+func (d *Dao) QueryGRPCSnapByID(id int) (grpcSnap *model.GRPCSnap, err error) {
+	grpcSnap = &model.GRPCSnap{}
+	err = pkgerr.WithStack(d.DB.Table(model.GRPCSnap{}.TableName()).Where("id = ?", id).First(grpcSnap).Error)
+	return
+}
+
+// UpdateGRPCSnap Update grpc
+func (d *Dao) UpdateGRPCSnap(grpcSnap *model.GRPCSnap) error {
+	return d.DB.Table(model.GRPCSnap{}.TableName()).Where("id=?", grpcSnap.ID).Update(grpcSnap).Error
+}
+
+// CreateGRPCSnap CreateGRPC  new grpc
+func (d *Dao) CreateGRPCSnap(grpcSnap *model.GRPCSnap) (err error) {
+	grpcSnap.Active = 1
+	return pkgerr.WithStack(d.DB.Table(model.GRPCSnap{}.TableName()).Create(grpcSnap).Error)
+}
+
+// DeleteGRPCSnap Delete grpc snap
+func (d *Dao) DeleteGRPCSnap(id int) error {
+	return pkgerr.WithStack(d.DB.Table(model.GRPCSnap{}.TableName()).Where("id=?", id).Update("active", -1).Error)
+}

app/admin/ep/melloi/dao/order.go

@@ -0,0 +1,32 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// QueryOrder query order info: ps : pageNumber pn: pageSize
+func (d *Dao) QueryOrder(order *model.Order, pn int32, ps int32) (qor *model.QueryOrderResponse, err error) {
+	qor = &model.QueryOrderResponse{}
+	err = d.DB.Table(model.Order{}.TableName()).Where(model.Order{
+		ID: order.ID, Name: order.Name, Broker: order.Broker, Type: order.Type, TestType: order.TestType,
+		Project: order.Project, Department: order.Department, App: order.App, Status: order.Status, UpdateBy: order.UpdateBy,
+		Active: 1, Handler: order.Handler}).Count(&qor.TotalSize).Offset((pn - 1) * ps).Limit(ps).Order("id desc").Find(&qor.Orders).Error
+	qor.PageSize = ps
+	qor.PageNum = pn
+	return
+}
+
+// AddOrder add order by order object
+func (d *Dao) AddOrder(order *model.Order) error {
+	return d.DB.Table(model.Order{}.TableName()).Create(order).Error
+}
+
+// UpdateOrder update order by order object
+func (d *Dao) UpdateOrder(order *model.Order) error {
+	return d.DB.Model(&model.Order{}).Update(order).Where("ID=?", order.ID).Error
+}
+
+// DelOrder delete order by orderID
+func (d *Dao) DelOrder(id int64) error {
+	return d.DB.Model(&model.Order{}).Where("ID=?", id).Update("active", -1).Error
+}

app/admin/ep/melloi/dao/order_admin.go

@@ -0,0 +1,17 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// QueryOrderAdmin get administrator for Order of this project
+func (d *Dao) QueryOrderAdmin(userName string) (admin *model.OrderAdmin, err error) {
+	admin = &model.OrderAdmin{}
+	err = d.DB.Table(model.OrderAdmin{}.TableName()).Where("user_name = ?", userName).First(admin).Error
+	return
+}
+
+// AddOrderAdmin add order of admin
+func (d *Dao) AddOrderAdmin(admin *model.OrderAdmin) error {
+	return d.DB.Create(admin).Error
+}

app/admin/ep/melloi/dao/order_admin_test.go

@@ -0,0 +1,29 @@
+package dao
+
+import (
+	"testing"
+
+	"go-common/app/admin/ep/melloi/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	oa = model.OrderAdmin{
+		UserName: "hujianping",
+	}
+)
+
+func Test_OrderAdmin(t *testing.T) {
+
+	Convey("test AddOrderAdmin", t, func() {
+		err := d.AddOrderAdmin(&oa)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test QueryOrderAdmin", t, func() {
+		var admin *model.OrderAdmin
+		admin, _ = d.QueryOrderAdmin(oa.UserName)
+		So(admin, ShouldNotBeNil)
+	})
+}

app/admin/ep/melloi/dao/order_report.go

@@ -0,0 +1,22 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// AddReport add manual report
+func (d *Dao) AddReport(report *model.OrderReport) (err error) {
+	return d.DB.Model(&model.OrderReport{}).Create(report).Error
+}
+
+// QueryReportByOrderID query report  by order id
+func (d *Dao) QueryReportByOrderID(orderID int64) (report *model.OrderReport, err error) {
+	report = &model.OrderReport{}
+	err = d.DB.Table(model.OrderReport{}.TableName()).Where("order_id=? ", orderID).Find(&report).Error
+	return
+}
+
+// UpdateReportByID update report by id
+func (d *Dao) UpdateReportByID(report *model.OrderReport) error {
+	return d.DB.Table(model.OrderReport{}.TableName()).Where("ID=?", report.ID).Update("content", report.Content).Error
+}

app/admin/ep/melloi/dao/order_test.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"testing"
+	"time"
+
+	"go-common/app/admin/ep/melloi/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	testOrder = model.Order{
+		ApplyDate: time.Now(),
+		ID:        1,
+	}
+	pageNum  int32 = 1
+	pageSize int32 = 2
+)
+
+func Test_Order(t *testing.T) {
+	Convey("test QueryOrder", t, func() {
+
+		var workOrders *model.QueryOrderResponse
+		order := model.Order{ID: testOrder.ID}
+		workOrders, _ = d.QueryOrder(&order, pageNum, pageSize)
+		So(workOrders, ShouldBeEmpty)
+	})
+
+	Convey("test DeleteOrder", t, func() {
+		order := model.Order{ID: testOrder.ID}
+		err := d.DelOrder(order.ID)
+		So(err, ShouldBeNil)
+	})
+
+	Convey("test UpdateOrder", t, func() {
+		order := model.Order{ID: testOrder.ID, ApplyDate: testOrder.ApplyDate}
+		err := d.UpdateOrder(&order)
+		So(err, ShouldBeNil)
+	})
+
+}

app/admin/ep/melloi/dao/ptestjob.go

@@ -0,0 +1,37 @@
+package dao
+
+import "go-common/app/admin/ep/melloi/model"
+
+//AddPtestJob add PtestJob
+func (d *Dao) AddPtestJob(ptestJob *model.PtestJob) (ptestJobID int, err error) {
+	err = d.DB.Create(ptestJob).Error
+	ptestJobID = ptestJob.ID
+	return
+}
+
+//CountPtestJob add PtestJob
+func (d *Dao) CountPtestJob(ptestJob *model.PtestJob) (total int, err error) {
+	err = d.DB.Table(model.PtestJob{}.TableName()).Where(ptestJob).Count(&total).Error
+	return
+}
+
+//QueryPtestJob query PtestJob
+func (d *Dao) QueryPtestJob(ptestJob *model.PtestJob) (pJob []*model.PtestJob, err error) {
+	err = d.DB.Table(model.PtestJob{}.TableName()).Where(ptestJob).Order("ctime asc").Find(&pJob).Error
+	return
+}
+
+//DeletePtestJob delete PtestJob
+func (d *Dao) DeletePtestJob(id int) error {
+	return d.DB.Model(&model.PtestJob{}).Where("ID = ?", id).Update("active", -1).Error
+}
+
+//DeletePtestJobByJobName delete PtestJob
+func (d *Dao) DeletePtestJobByJobName(jobName string) error {
+	return d.DB.Model(&model.PtestJob{}).Where("job_name = ?", jobName).Update("active", -1).Error
+}
+
+//UpdatePtestJob Update PtestJob
+func (d *Dao) UpdatePtestJob(ptestJob model.PtestJob) error {
+	return d.DB.Model(&model.PtestJob{}).Where("id = ?", ptestJob.ID).Updates(ptestJob).Error
+}

app/admin/ep/melloi/dao/rank.go

@@ -0,0 +1,147 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+//TreesQuery query department and performance test count of department
+func (d *Dao) TreesQuery() (res *model.TreeList, err error) {
+	res = &model.TreeList{}
+	//select department, count(department) as count from report_summary where department != '' GROUP BY department ORDER BY count desc
+	err = d.DB.Table("report_summary").Select("department, project, app").Group("app").
+		Having("department != ''").Order("department").Scan(&res.TreeList).Error
+	return
+}
+
+//TreeNumQuery query department
+func (d *Dao) TreeNumQuery() (res *model.NumList, err error) { /**/
+	res = &model.NumList{}
+	//select count(DISTINCT department) as count from report_summary where department != ''
+	if err = d.DB.Table("report_summary").Select("department, count(DISTINCT department) as dept_num").
+		Where("department != ''").Scan(&res.NumList).Error; err != nil {
+		return
+	}
+	if err = d.DB.Table("report_summary").Select("project, count(DISTINCT project) as pro_num").
+		Where("project != ''").Scan(&res.NumList).Error; err != nil {
+		return
+	}
+	if err = d.DB.Table("report_summary").Select("app, count(DISTINCT app) as app_num").
+		Where("app != ''").Scan(&res.NumList).Error; err != nil {
+		return
+	}
+	return
+}
+
+//TopHttpQuery query performance test top api
+func (d *Dao) TopHttpQuery() (res *model.TopAPIRes, err error) {
+	res = &model.TopAPIRes{}
+	//select s.url, count(r.script_id) as count from report_summary r INNER JOIN script s on r.script_id = s.id GROUP BY s.url having url != '' ORDER BY count desc
+	err = d.DB.Limit(10).Table("report_summary").Select("script.url, count(report_summary.script_id) as count").
+		Joins("inner join script on report_summary.script_id = script.id").
+		Where("report_summary.active = 1 and report_summary.debug != 1 and script.test_type = 1 and report_summary.type = 0").
+		Group("script.url").Having("script.url != ''").Order("count desc").Scan(&res.APIList).Error
+	return
+}
+
+//TopGrpcQuery Top Grpc Query
+func (d *Dao) TopGrpcQuery() (res *model.GrpcRes, err error) {
+	res = &model.GrpcRes{}
+	//select g.service_name, g.request_method, count(r.script_id) as count from report_summary r INNER JOIN grpc g on r.script_id = g.id
+	//where g.service_name != '' and r.active = 1 and r.debug != 1 and r.type = 1
+	//GROUP BY g.service_name ORDER BY count desc
+	err = d.DB.Limit(10).Table("report_summary").Select("grpc.service_name, grpc.request_method, count(report_summary.script_id) as count").
+		Joins("inner join grpc on report_summary.script_id = grpc.id").
+		Where("report_summary.active = 1 and report_summary.debug != 1 and grpc.service_name != '' and report_summary.type = 1").
+		Group("grpc.service_name").Order("count desc").Scan(&res.GrpcList).Error
+	return
+}
+
+//TopSceneQuery Top Scene Query
+func (d *Dao) TopSceneQuery() (res *model.SceneRes, err error) {
+	res = &model.SceneRes{}
+	//select s.scene_name, count(r.script_id) as count from report_summary r INNER JOIN scene s on r.scene_id = s.id
+	//where s.scene_name != '' and s.is_active = 1 and s.is_draft = 0 and r.active = 1 and r.debug != 1 and r.scene_id != 0 and r.type = 2
+	//GROUP BY s.scene_name ORDER BY count desc
+	err = d.DB.Limit(10).Table("report_summary").Select("scene.department, scene.scene_name, count(report_summary.script_id) as count").
+		Joins("inner join scene on report_summary.scene_id = scene.id").
+		Where("report_summary.active = 1 and report_summary.debug != 1 and scene.scene_name != '' and scene.is_active = 1 and scene.is_draft = 0 and report_summary.scene_id != 0 and report_summary.type = 2").
+		Group("scene.scene_name").Order("count desc").Scan(&res.SceneList).Error
+	return
+}
+
+//TopDeptQuery query performance test top department
+func (d *Dao) TopDeptQuery() (res *model.TopDeptRes, err error) {
+	res = &model.TopDeptRes{}
+	//select department, count(department) as count from report_summary where department != '' GROUP BY department ORDER BY count desc
+	err = d.DB.Limit(10).Table("report_summary").Select("department, count(department) as count").
+		Where("report_summary.active = 1 and report_summary.debug != 1").
+		Group("department").Having("department != ''").Order("count desc").Scan(&res.DeptList).Error
+	return
+}
+
+//BuildLineQuery query performance test count by time
+func (d *Dao) BuildLineQuery(rank *model.Rank, summary *model.ReportSummary) (res *model.BuildLineRes, err error) {
+	res = &model.BuildLineRes{}
+	//select DATE_FORMAT(ctime, '%H') as count from report_summary where ctime >= date_sub(now(), interval 24 hour) AND ctime <= NOW()
+	//switch rank.TimeDegree {
+	//case "H":
+	//	err = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m-%d %H') as date").
+	//		Where(summary).Where("active = 1 and debug != 1").
+	//		Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime).Order("date").
+	//		Scan(&res.BuildList).Error
+	//case "d":
+	//	err = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m-%d') as date").Where(summary).
+	//		Where("active = 1 and debug != 1").
+	//		Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime).Order("date").Scan(&res.BuildList).Error
+	//case "m":
+	//	err = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m') as date").Where(summary).
+	//		Where("active = 1 and debug != 1").
+	//		Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime).Order("date").Scan(&res.BuildList).Error
+	//case "Y":
+	//	err = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y') as date").Where(summary).
+	//		Where("active = 1 and debug != 1").
+	//		Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime).Order("date").Scan(&res.BuildList).Error
+	//default:
+	//	err = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m-%d %H') as date").Where(summary).
+	//		Where("active = 1 and debug != 1").
+	//		Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime).Order("date").Scan(&res.BuildList).Error
+	//}
+	gDB := d.DB.Table(model.ReportSummary{}.TableName())
+	switch rank.TimeDegree {
+	case "H":
+		gDB = gDB.Select("DATE_FORMAT(ctime, '%Y-%m-%d %H') as date").
+			Where("active = 1 and debug != 1").
+			Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime)
+	case "d":
+		gDB = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m-%d') as date").
+			Where("active = 1 and debug != 1").
+			Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime)
+	case "m":
+		gDB = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m') as date").
+			Where("active = 1 and debug != 1").
+			Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime)
+	case "Y":
+		gDB = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y') as date").
+			Where("active = 1 and debug != 1").
+			Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime)
+	default:
+		gDB = d.DB.Table("report_summary").Select("DATE_FORMAT(ctime, '%Y-%m-%d %H') as date").
+			Where("active = 1 and debug != 1").
+			Where("ctime >= ? AND ctime <= ?", rank.StartTime, rank.EndTime)
+	}
+	if rank.SearchAll {
+		err = gDB.Where("type in (0, 1, 2)").Order("date").Scan(&res.BuildList).Error
+	} else {
+		err = gDB.Where("type = ?", summary.Type).Order("date").Scan(&res.BuildList).Error
+	}
+	return
+}
+
+//StateLineQuery query statistic of state
+func (d *Dao) StateLineQuery() (res *model.StateLineRes, err error) {
+	res = &model.StateLineRes{}
+	//select test_status, count(test_status) as count from report_summary GROUP BY test_status
+	err = d.DB.Table("report_summary").Select("test_status, count(test_status) as count").Where("test_status != 0").
+		Where("active = 1 and debug != 1").Group("test_status").Scan(&res.StateList).Error
+	return
+}

app/admin/ep/melloi/dao/rank_test.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoTreesQuery(t *testing.T) {
+	convey.Convey("TreesQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.TreesQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTreeNumQuery(t *testing.T) {
+	convey.Convey("TreeNumQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.TreeNumQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTopHttpQuery(t *testing.T) {
+	convey.Convey("TopHttpQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.TopHttpQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTopGrpcQuery(t *testing.T) {
+	convey.Convey("TopGrpcQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.TopGrpcQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTopSceneQuery(t *testing.T) {
+	convey.Convey("TopSceneQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.TopSceneQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTopDeptQuery(t *testing.T) {
+	convey.Convey("TopDeptQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.TopDeptQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBuildLineQuery(t *testing.T) {
+	convey.Convey("BuildLineQuery", t, func(convCtx convey.C) {
+		var (
+			rank    = &model.Rank{}
+			summary = &model.ReportSummary{}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.BuildLineQuery(rank, summary)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoStateLineQuery(t *testing.T) {
+	convey.Convey("StateLineQuery", t, func(convCtx convey.C) {
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.StateLineQuery()
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/ep/melloi/dao/report.go

@@ -0,0 +1,137 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// QueryReportSummarys query reportSummarys
+func (d *Dao) QueryReportSummarys(reportSummary *model.ReportSummary, searchAll bool, pn, ps int32, treeNodes []string) (qrsr *model.QueryReportSuResponse, err error) {
+	qrsr = &model.QueryReportSuResponse{}
+	reportSummary.Active = 1
+	reportSummary.Debug = -1
+
+	gDB := d.DB.Table(model.ReportSummary{}.TableName()) //.Where("app in (?)", treeNodes)
+	if reportSummary.TestName != "" && reportSummary.ScriptID != 0 {
+		gDB = gDB.Where("test_name LIKE ? and active = ? and debug = ? and script_id = ?", "%"+reportSummary.TestName+"%", 1, -1, reportSummary.ScriptID)
+	}
+	if reportSummary.UserName != "" && reportSummary.ScriptID != 0 {
+		gDB = gDB.Where("user_name LIKE ? and active = ? and debug = ? and script_id = ?", "%"+reportSummary.UserName+"%", 1, -1, reportSummary.ScriptID)
+	}
+	if reportSummary.TestName != "" {
+		gDB = gDB.Where("test_name LIKE ? and active = ? and debug = ?", "%"+reportSummary.TestName+"%", 1, -1)
+	}
+	if reportSummary.UserName != "" {
+		gDB = gDB.Where("user_name LIKE ? and active = ? and debug = ?", "%"+reportSummary.UserName+"%", 1, -1)
+	}
+	if searchAll {
+		gDB = gDB.Where("type in (0, 1, 2)")
+	} else {
+		if reportSummary.ID == 0 {
+			gDB = gDB.Where("type = ?", reportSummary.Type)
+		}
+	}
+	if reportSummary.TestName == "" && reportSummary.UserName == "" {
+		gDB = gDB.Where(reportSummary)
+	}
+	err = gDB.Count(&qrsr.TotalSize).
+		Order("ctime desc").Offset((pn - 1) * ps).Limit(ps).Find(&qrsr.ReportSummarys).Error
+
+	qrsr.PageSize = ps /**/
+	qrsr.PageNum = pn
+	return
+}
+
+// QueryReportSummarysWhiteName query reportSummarys by whiteName
+func (d *Dao) QueryReportSummarysWhiteName(reportSummary *model.ReportSummary, searchAll bool, pn, ps int32) (qrsr *model.QueryReportSuResponse, err error) {
+	qrsr = &model.QueryReportSuResponse{}
+	reportSummary.Active = 1
+	reportSummary.Debug = -1
+
+	gDB := d.DB.Table(model.ReportSummary{}.TableName())
+	if reportSummary.TestName != "" && reportSummary.ScriptID != 0 {
+		gDB = gDB.Where("test_name LIKE ? and active = ? and debug = ? and script_id = ?", "%"+reportSummary.TestName+"%", 1, -1, reportSummary.ScriptID)
+	}
+	if reportSummary.UserName != "" && reportSummary.ScriptID != 0 {
+		gDB = gDB.Where("user_name LIKE ? and active = ? and debug = ? and script_id = ?", "%"+reportSummary.UserName+"%", 1, -1, reportSummary.ScriptID)
+	}
+	if reportSummary.TestName != "" {
+		gDB = gDB.Where("test_name LIKE ? and active = ? and debug = ?", "%"+reportSummary.TestName+"%", 1, -1)
+	}
+	if reportSummary.UserName != "" {
+		gDB = gDB.Where("user_name LIKE ? and active = ? and debug = ?", "%"+reportSummary.UserName+"%", 1, -1)
+	}
+	if searchAll {
+		gDB = gDB.Where("type in (0, 1, 2)")
+	} else {
+		if reportSummary.ID == 0 {
+			gDB = gDB.Where("type = ?", reportSummary.Type)
+		}
+	}
+	if reportSummary.TestName == "" && reportSummary.UserName == "" {
+		gDB = gDB.Where(reportSummary)
+	}
+	err = gDB.Count(&qrsr.TotalSize).
+		Order("ctime desc").Offset((pn - 1) * ps).Limit(ps).Find(&qrsr.ReportSummarys).Error
+
+	qrsr.PageSize = ps /**/
+	qrsr.PageNum = pn
+	return
+}
+
+// QueryReportSurys query reportSummarys
+func (d *Dao) QueryReportSurys(reportSummary *model.ReportSummary) (res []*model.ReportSummary, err error) {
+	err = d.DB.Table(model.ReportSummary{}.TableName()).Where(reportSummary).Find(&res).Error
+	return
+}
+
+// QueryReportSuryByID query reportSummary by id
+func (d *Dao) QueryReportSuryByID(id int) (res *model.ReportSummary, err error) {
+	reportSummary := model.ReportSummary{ID: id}
+	res = &model.ReportSummary{}
+	err = d.DB.Table(model.ReportSummary{}.TableName()).Where(reportSummary).First(&res).Error
+	return
+}
+
+//CountQueryReportSummarys count queryReportSummarys
+func (d *Dao) CountQueryReportSummarys(reportSummary *model.ReportSummary) (total int, err error) {
+	err = d.DB.Table(model.ReportSummary{}.TableName()).Where(reportSummary).Count(&total).Error
+	return
+}
+
+//AddReportSummary add reportSummary
+func (d *Dao) AddReportSummary(reportSummary *model.ReportSummary) (reportSuID int, err error) {
+	err = d.DB.Create(reportSummary).Error
+	reportSuID = reportSummary.ID
+	return
+}
+
+//UpdateReportSummary update Report
+func (d *Dao) UpdateReportSummary(reportSummary *model.ReportSummary) error {
+	return d.DB.Model(&model.ReportSummary{}).Where("id = ?", reportSummary.ID).Updates(reportSummary).Error
+}
+
+//UpdateReportStatusByID update report status
+func (d *Dao) UpdateReportStatusByID(ID, testStatus int) error {
+	return d.DB.Exec("update report_summary set test_status = ? where id = ? ", testStatus, ID).Error
+}
+
+//UpdateReportStatus update Report
+func (d *Dao) UpdateReportStatus(status int) error {
+	return d.DB.Model(&model.ReportSummary{}).Where("test_status = 2").Update("test_status", 1).Error
+}
+
+//UpdateReportDockByID update Report
+func (d *Dao) UpdateReportDockByID(ID, dockerSum int) error {
+	return d.DB.Model(&model.ReportSummary{}).Where("id =?", ID).Updates(model.ReportSummary{DockerSum: dockerSum}).Error
+}
+
+//DelReportSummary delete reportSummary
+func (d *Dao) DelReportSummary(id int) error {
+	return d.DB.Model(&model.ReportSummary{}).Where("ID=?", id).Update("active", 0).Error
+}
+
+//QueryReTimely query rueryReTimely
+func (d *Dao) QueryReTimely(testName, beginTime, afterTime string, podNames []string) (reportTimelys []*model.ReportTimely, err error) {
+	err = d.DB.Model(&model.ReportTimely{}).Where("test_name = ? and mtime >= ? and mtime <= ? and pod_name in (?)", testName, beginTime, afterTime, podNames).Find(&reportTimelys).Error
+	return
+}

app/admin/ep/melloi/dao/reportgraph.go

@@ -0,0 +1,16 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+)
+
+//AddReportGraph add reportGraph
+func (d *Dao) AddReportGraph(reportGraph *model.ReportGraph) error {
+	return d.DB.Create(reportGraph).Error
+}
+
+//QueryReportGraph query reportGraph
+func (d *Dao) QueryReportGraph(testNameNicks []string) (reportGraphs []model.ReportGraph, err error) {
+	err = d.DB.Model(&model.ReportGraph{}).Where(" test_name_nick in (?) ", testNameNicks).Order("elapsd_time asc").Find(&reportGraphs).Error
+	return
+}

app/admin/ep/melloi/dao/scene.go

@@ -0,0 +1,278 @@
+package dao
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/app/admin/ep/melloi/conf"
+	"go-common/app/admin/ep/melloi/model"
+)
+
+// AddScene Add Scene
+func (d *Dao) AddScene(scene *model.Scene) (sceneId int, err error) {
+	scene.IsActive = true
+	err = d.DB.Table("scene").Create(scene).Error
+	sceneId = scene.ID
+	return
+}
+
+// QueryDraft Query Draft
+func (d *Dao) QueryDraft(scene *model.Scene) (res *model.QueryDraft, err error) {
+	res = &model.QueryDraft{}
+	err = d.DB.Table("scene").Select("id as scene_id, scene_name").Where(scene).Where("is_draft = 1 and is_active = 1").Count(&res.Total).Order("mtime desc").Find(&res.Drafts).Error
+	return
+}
+
+// UpdateScene Update Scene
+func (d *Dao) UpdateScene(scene *model.Scene, scriptIDList []int) (fusing int, err error) {
+	if err = d.DB.Exec("update scene set fusing = ? where id = ?", scene.Fusing, scene.ID).Error; err != nil {
+		return
+	}
+	if err = d.DB.Model(&model.Scene{}).Where("ID = ?", scene.ID).Update(scene).Error; err != nil {
+		return
+	}
+	if scene.IsBatch { //选择已有接口点击确定时执行
+		if scene.Fusing == 0 {
+			err = d.DB.Model(&model.Script{}).Where("scene_id = ? and id in (?)", scene.ID, scriptIDList).Update("fusing", conf.Conf.Melloi.DefaultFusing).Error
+		} else {
+			err = d.DB.Model(&model.Script{}).Where("scene_id = ? and id in (?)", scene.ID, scriptIDList).Update("fusing", scene.Fusing).Error
+		}
+	} else if scene.IsUpdate { //
+		err = d.DB.Model(&model.Script{}).Where("scene_id = ?", scene.ID).Update("fusing", scene.Fusing).Error
+	}
+	fusing = scene.Fusing
+	return
+}
+
+// SaveScene Save Scene
+func (d *Dao) SaveScene(scene *model.Scene) error {
+	return d.DB.Model(&model.Scene{}).Where("ID = ?", scene.ID).Update("is_draft", 0).Update("scene_type", scene.SceneType).Error
+}
+
+// SaveOrder Save Order
+func (d *Dao) SaveOrder(reqList []*model.GroupOrder, scene *model.Scene) (err error) {
+	for _, req := range reqList {
+		if scene.SceneType == 1 {
+			err = d.DB.Model(&model.Script{}).Where("ID = ?", req.ID).Update("group_id", req.GroupID).Error
+		} else {
+			err = d.DB.Model(&model.Script{}).Where("ID = ?", req.ID).Update("run_order", req.RunOrder).Error
+		}
+	}
+	return
+}
+
+// QueryGroupId Query GroupId
+func (d *Dao) QueryGroupId(script *model.Script) (res *model.QueryRelation, groupId int, err error) {
+	res = &model.QueryRelation{}
+	//select group_id, count(group_id) as count from script where scene_id = 1 and group_id in (select group_id from script where id = 777) group by group_id
+	err = d.DB.Table("script").Select("group_id").Where("id = ?", script.ID).Find(&res.RelationList).Error
+	groupId = res.RelationList[0].GroupID
+	return
+}
+
+// QueryRelation Query Relation
+func (d *Dao) QueryRelation(groupId int, script *model.Script) (res *model.QueryRelation, err error) {
+	res = &model.QueryRelation{}
+	err = d.DB.Table("script").Select("group_id, count(group_id) as count").Where("scene_id = ? and group_id = ?", script.SceneID, groupId).Find(&res.RelationList).Error
+	return
+}
+
+// QueryAPI Query API
+func (d *Dao) QueryAPI(scene *model.Scene) (res *model.QueryAPIs, err error) {
+	res = &model.QueryAPIs{}
+	if err = d.DB.Table(model.Script{}.TableName()).Select("id").Where("scene_id = ? and active = 1", scene.ID).Count(&res.Total).Error; err != nil {
+		return
+	}
+	if res.Total > 0 {
+		//select scene.scene_name, scene.scene_type, scene.department, scene.project, scene.app, script.group_id, script.run_order, script.id as test_id, script.test_name
+		//from scene INNER JOIN script on scene.id = script.scene_id and script.active = 1 where script.scene_id = 1
+		gDB := d.DB.Table(model.Scene{}.TableName()).Select("scene.id as scene_id, scene.scene_name, scene.scene_type, scene.department, " +
+			"scene.project, scene.app, script.group_id, script.run_order, script.id, script.test_name, script.url, script.output_params, script.threads_sum, script.load_time").
+			Joins("inner join script on scene.id = script.scene_id and script.active = 1")
+		if scene.SceneType == 2 {
+			err = gDB.Where(scene).Count(&res.Total).Order("group_id, run_order").Find(&res).Find(&res.APIs).Error
+			res.SceneType = 2
+		} else {
+			err = gDB.Where(scene).Count(&res.Total).Order("script.id").Find(&res).Find(&res.APIs).Error
+			res.SceneType = 1
+		}
+	} else {
+		gDB := d.DB.Table(model.Scene{}.TableName()).Select("id as scene_id, scene_name, department, project, app")
+		err = gDB.Where("id = ?", scene.ID).Find(&res).Error
+		//查询无结果时，APIs返回空数组
+		res.APIs = []*model.TestAPI{}
+	}
+	return
+}
+
+// DeleteAPI Delete API
+func (d *Dao) DeleteAPI(script *model.Script) error {
+	return d.DB.Model(&model.Script{}).Where("ID = ?", script.ID).Update("active", 0).Error
+}
+
+// AddConfig Add Config
+func (d *Dao) AddConfig(script *model.Script) error {
+	return d.DB.Exec("update script set threads_sum = ?, load_time = ?, ready_time = ? where scene_id = ? and group_id = ?", script.ThreadsSum, script.LoadTime, script.ReadyTime, script.SceneID, script.GroupID).Error
+}
+
+// QueryTree Query Tree
+func (d *Dao) QueryTree(script *model.Script) (res *model.ShowTree, err error) {
+	res = &model.ShowTree{}
+	err = d.DB.Table(model.Script{}.TableName()).Select("department, project, app").Where(script).Count(&res.IsShow).Order("id").Limit(1).Find(&res.Tree).Error
+	if res.IsShow > 1 {
+		res.IsShow = 1
+	}
+	return
+}
+
+//QueryScenesByPage query scripts by page
+func (d *Dao) QueryScenesByPage(scene *model.Scene, pn, ps int32, treeNodes []string) (qsr *model.QuerySceneResponse, err error) {
+	qsr = &model.QuerySceneResponse{}
+	gDB := d.DB.Table(model.Scene{}.TableName()).Where("app in (?)", treeNodes).Where("is_draft = 0")
+	if scene.Department != "" && scene.Project != "" && scene.APP != "" {
+		gDB = gDB.Where("department = ? and project = ? and app = ?", scene.Department, scene.Project, scene.APP)
+	}
+	if scene.Department != "" && scene.Project != "" {
+		gDB = gDB.Where("department = ? and project = ?", scene.Department, scene.Project)
+	}
+	if scene.Department != "" {
+		gDB = gDB.Where("department = ?", scene.Department)
+	}
+	if scene.SceneName != "" {
+		gDB = gDB.Where("scene_name LIKE ? ", "%"+scene.SceneName+"%")
+	}
+	if scene.UserName != "" {
+		gDB = gDB.Where("user_name LIKE ? ", "%"+scene.UserName+"%")
+	}
+
+	if scene.SceneName == "" && scene.UserName == "" && scene.Department == "" && scene.Project == "" && scene.APP == "" {
+		gDB = gDB.Where(scene)
+	}
+
+	err = gDB.Where("is_active = 1").Count(&qsr.TotalSize).Order("ctime desc").Offset((pn - 1) * ps).Limit(ps).
+		Find(&qsr.Scenes).Error
+	qsr.PageSize = ps /**/
+	qsr.PageNum = pn
+	return
+}
+
+//QueryScenesByPageWhiteName query scripts by page white name
+func (d *Dao) QueryScenesByPageWhiteName(scene *model.Scene, pn, ps int32) (qsr *model.QuerySceneResponse, err error) {
+	qsr = &model.QuerySceneResponse{}
+	gDB := d.DB.Table(model.Scene{}.TableName()).Where("is_draft = 0")
+	if scene.SceneName != "" {
+		gDB = gDB.Where("scene_name LIKE ? ", "%"+scene.SceneName+"%")
+	}
+	if scene.UserName != "" {
+		gDB = gDB.Where("user_name LIKE ? ", "%"+scene.UserName+"%")
+	}
+
+	if scene.SceneName == "" && scene.UserName == "" {
+		gDB = gDB.Where(scene)
+	}
+
+	err = gDB.Where("is_active = 1").Count(&qsr.TotalSize).Order("mtime desc").Offset((pn - 1) * ps).Limit(ps).
+		Find(&qsr.Scenes).Error
+	qsr.PageSize = ps /**/
+	qsr.PageNum = pn
+	return
+}
+
+//QueryScenes query scene
+func (d *Dao) QueryScenes(scene *model.Scene, pn int, ps int) (scenes []*model.Scene, err error) {
+	err = d.DB.Table(model.Scene{}.TableName()).Where(scene).Order("mtime desc").Offset((pn - 1) * ps).Limit(ps).Find(&scenes).Error
+	return
+}
+
+// QueryExistAPI Query Exist API
+func (d *Dao) QueryExistAPI(script *model.Script, pageNum int32, pageSize int32, sceneId int, treeNodes []string) (res *model.APIInfoList, err error) {
+	res = &model.APIInfoList{}
+	gDB := d.DB.Table(model.Script{}.TableName()).Where("app in (?)", treeNodes)
+	if pageSize == 0 && pageNum == 0 {
+		err = gDB.Where(script).Where("active = 1 and scene_id = 0").Count(&res.TotalSize).Order("id desc").Find(&res.ScriptList).Error
+	} else {
+		err = gDB.Where(script).Where("active = 1 and scene_id = 0").Count(&res.TotalSize).Order("id desc").Offset((pageNum - 1) * pageSize).Limit(pageSize).Find(&res.ScriptList).Error
+		res.PageNum = pageNum
+		res.PageSize = pageSize
+	}
+	res.SceneID = sceneId
+	return
+}
+
+// QueryGroup Query Group
+func (d *Dao) QueryGroup(sceneId int) (res *model.GroupList, err error) {
+	res = &model.GroupList{}
+	gDB := d.DB.Table(model.Script{}.TableName())
+	//select group_id, count(group_id) from script where scene_id = 1 GROUP BY group_id order by group_id
+	err = gDB.Select("group_id, threads_sum, load_time, ready_time").Where("scene_id = ? and active = 1", sceneId).Group("group_id").Order("group_id").Find(&res.GroupList).Error
+	return
+}
+
+// QueryPreview Query Preview
+func (d *Dao) QueryPreview(sceneId, groupId int) (res *model.PreviewList, err error) {
+	res = &model.PreviewList{}
+	gDB := d.DB.Table(model.Script{}.TableName())
+	//select id as test_id, test_name, run_order from script where scene_id = 1 and group_id = 1 order by run_order
+	err = gDB.Select("id, test_name, run_order, group_id, const_timer, random_timer").Where("scene_id = ? and group_id = ? and active = 1", sceneId, groupId).Order("run_order").Find(&res.PreList).Error
+	return
+}
+
+// QueryUsefulParams Query Useful Params
+func (d *Dao) QueryUsefulParams(sceneId int) (res *model.UsefulParamsList, err error) {
+	res = &model.UsefulParamsList{}
+	gDB := d.DB.Table(model.Script{}.TableName())
+	err = gDB.Select("output_params").Where("scene_id = ?", sceneId).Where("active = 1 and output_params != '[{\"\":\"\"}]'").Order("id desc").Find(&res.ParamsList).Error
+	return
+}
+
+// UpdateBindScene Update Bind Scene
+func (d *Dao) UpdateBindScene(bindScene *model.BindScene) (err error) {
+	var id int
+	tempList := strings.Split(bindScene.ID, ",")
+	for _, tempId := range tempList {
+		if id, err = strconv.Atoi(tempId); err != nil {
+			return err
+		}
+		err = d.DB.Model(&model.Script{}).Where("id =?", id).Updates(model.Script{SceneID: bindScene.SceneID}).Error
+	}
+	return
+}
+
+// QueryDrawRelation Query Draw Relation
+func (d *Dao) QueryDrawRelation(scene *model.Scene) (res *model.SaveOrderReq, err error) {
+	res = &model.SaveOrderReq{}
+	gDB := d.DB.Table(model.Script{}.TableName())
+	err = gDB.Select("id, test_name, group_id, run_order").Where("scene_id = ? and active = 1", scene.ID).Order("group_id, run_order").Find(&res.GroupOrderList).Error
+	return
+}
+
+// DeleteDraft Delete Draft
+func (d *Dao) DeleteDraft(scene *model.Scene) error {
+	if scene.ID == 0 {
+		return d.DB.Model(&model.Scene{}).Where("user_name = ? and is_draft = 1", scene.UserName).Update("is_active", 0).Error
+	}
+	return d.DB.Model(&model.Scene{}).Where("user_name = ? and id = ? and is_draft = 1", scene.UserName, scene.ID).Update("is_active", 0).Error
+}
+
+// QueryConfig Query Config
+func (d *Dao) QueryConfig(script *model.Script) (res *model.GroupInfo, err error) {
+	res = &model.GroupInfo{}
+	gDB := d.DB.Table(model.Script{}.TableName())
+	// select distinct group_id, threads_sum, ready_time, load_time from script where scene_id = 282 and active = 1 and group_id = 2
+	err = gDB.Select("distinct group_id, threads_sum, ready_time, load_time").Where("scene_id = ? and group_id = ? and active = 1", script.SceneID, script.GroupID).Find(&res).Error
+	return
+}
+
+// DeleteScene Delete Scene
+func (d *Dao) DeleteScene(scene *model.Scene) error {
+	return d.DB.Model(&model.Scene{}).Where("id = ?", scene.ID).Update("is_active", 0).Error
+}
+
+// QueryFusing Query Fusing
+func (d *Dao) QueryFusing(script *model.Script) (res *model.FusingInfoList, err error) {
+	res = &model.FusingInfoList{}
+	gDB := d.DB.Table(model.Script{}.TableName())
+	//select id as test_id, test_name, run_order from script where scene_id = 1 and group_id = 1 order by run_order
+	err = gDB.Select("fusing").Where("scene_id = ? and active = 1", script.SceneID).Find(&res.FusingList).Error
+	return
+}

app/admin/ep/melloi/dao/scene_test.go

@@ -0,0 +1,470 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddScene(t *testing.T) {
+	convey.Convey("AddScene", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				SceneName:  "CMTest001",
+				UserName:   "chenmeng",
+				Department: "test",
+				Project:    "ep",
+				APP:        "melloi",
+				IsDraft:    1,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			sceneId, err := d.AddScene(scene)
+			convCtx.Convey("Then err should be nil.sceneId should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(sceneId, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryDraft(t *testing.T) {
+	convey.Convey("QueryDraft", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				UserName: "chenmeng",
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryDraft(scene)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateScene(t *testing.T) {
+	convey.Convey("UpdateScene", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				ID: 66,
+			}
+			scriptIDList = []int{1831, 1832, 1833, 1834, 1835}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			fusing, err := d.UpdateScene(scene, scriptIDList)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(fusing, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSaveScene(t *testing.T) {
+	convey.Convey("SaveScene", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				ID:        66,
+				IsDraft:   0,
+				SceneType: 2,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.SaveScene(scene)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSaveOrderAuto(t *testing.T) {
+	convey.Convey("SaveOrder", t, func(convCtx convey.C) {
+		var (
+			reqList = []*model.GroupOrder{
+				{
+					GroupID:  1,
+					RunOrder: 2,
+					ID:       980,
+					TestName: "cm-test",
+				},
+				{
+					GroupID:  1,
+					RunOrder: 1,
+					ID:       973,
+					TestName: "status111",
+				},
+			}
+			sceneAuto = &model.Scene{
+				SceneType: 1,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.SaveOrder(reqList, sceneAuto)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSaveOrderGroup(t *testing.T) {
+	convey.Convey("SaveOrder", t, func(convCtx convey.C) {
+		var (
+			reqList = []*model.GroupOrder{
+				{
+					GroupID:  1,
+					RunOrder: 2,
+					ID:       980,
+					TestName: "cm-test",
+				},
+				{
+					GroupID:  1,
+					RunOrder: 1,
+					ID:       973,
+					TestName: "status111",
+				},
+			}
+			sceneGroup = &model.Scene{
+				SceneType: 2,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.SaveOrder(reqList, sceneGroup)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryGroupId(t *testing.T) {
+	convey.Convey("QueryGroupId", t, func(convCtx convey.C) {
+		var (
+			script = &model.Script{
+				ID: 1568,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, groupId, err := d.QueryGroupId(script)
+			convCtx.Convey("Then err should be nil.res,groupId should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(groupId, convey.ShouldNotBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryRelation(t *testing.T) {
+	convey.Convey("QueryRelation", t, func(convCtx convey.C) {
+		var (
+			groupId = 11
+			script  = &model.Script{
+				ID: 1568,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryRelation(groupId, script)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryAPI(t *testing.T) {
+	convey.Convey("QueryAPI", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				ID:        325,
+				SceneType: 1,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryAPI(scene)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDeleteAPI(t *testing.T) {
+	d.DB.Model(&model.Script{}).Where("ID = 1568").Update("active", 1)
+	convey.Convey("DeleteAPI", t, func(convCtx convey.C) {
+		var (
+			script = &model.Script{
+				ID: 1568,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.DeleteAPI(script)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddConfig(t *testing.T) {
+	d.DB.Exec("update script set threads_sum = 10, load_time = 10, ready_time = 10 where scene_id = 325 and group_id = 1")
+	convey.Convey("AddConfig", t, func(convCtx convey.C) {
+		var (
+			script = &model.Script{
+				ThreadsSum: 120,
+				LoadTime:   300,
+				ReadyTime:  10,
+				SceneID:    325,
+				GroupID:    1,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.AddConfig(script)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryTree(t *testing.T) {
+	convey.Convey("QueryTree", t, func(convCtx convey.C) {
+		var (
+			script = &model.Script{
+				SceneID: 325,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryTree(script)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryScenesByPage(t *testing.T) {
+	convey.Convey("QueryScenesByPage", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				Department: "test",
+				Project:    "ep",
+				APP:        "melloi",
+				SceneName:  "场景压测cmtest01",
+				UserName:   "chenmeng",
+			}
+			pn        = int32(1)
+			ps        = int32(20)
+			treeNodes = []string{}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			qsr, err := d.QueryScenesByPage(scene, pn, ps, treeNodes)
+			convCtx.Convey("Then err should be nil.qsr should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(qsr, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryScenesByPageWhiteName(t *testing.T) {
+	convey.Convey("QueryScenesByPageWhiteName", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				Department: "test",
+				Project:    "ep",
+				APP:        "melloi",
+				SceneName:  "场景压测cmtest01",
+				UserName:   "chenmeng",
+			}
+			pn = int32(1)
+			ps = int32(20)
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			qsr, err := d.QueryScenesByPageWhiteName(scene, pn, ps)
+			convCtx.Convey("Then err should be nil.qsr should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(qsr, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryScenes(t *testing.T) {
+	convey.Convey("QueryScenes", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				UserName: "chenmeng",
+			}
+			pn = 1
+			ps = 10
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			scenes, err := d.QueryScenes(scene, pn, ps)
+			convCtx.Convey("Then err should be nil.scenes should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(scenes, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryExistAPI(t *testing.T) {
+	convey.Convey("QueryExistAPI", t, func(convCtx convey.C) {
+		var (
+			script = &model.Script{
+				SceneID: 325,
+			}
+			pageNum   = int32(1)
+			pageSize  = int32(10)
+			sceneId   = int(325)
+			treeNodes = []string{}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryExistAPI(script, pageNum, pageSize, sceneId, treeNodes)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryGroup(t *testing.T) {
+	convey.Convey("QueryGroup", t, func(convCtx convey.C) {
+		var (
+			sceneId = 325
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryGroup(sceneId)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryPreview(t *testing.T) {
+	convey.Convey("QueryPreview", t, func(convCtx convey.C) {
+		var (
+			sceneId = 325
+			groupId = 1
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryPreview(sceneId, groupId)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryUsefulParams(t *testing.T) {
+	convey.Convey("QueryUsefulParams", t, func(convCtx convey.C) {
+		var (
+			sceneId = 325
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryUsefulParams(sceneId)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateBindScene(t *testing.T) {
+	convey.Convey("UpdateBindScene", t, func(convCtx convey.C) {
+		var (
+			bindScene = &model.BindScene{
+				SceneID: 325,
+				ID:      "2000",
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.UpdateBindScene(bindScene)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryDrawRelation(t *testing.T) {
+	convey.Convey("QueryDrawRelation", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				ID: 980,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryDrawRelation(scene)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDeleteDraft(t *testing.T) {
+	convey.Convey("DeleteDraft", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				UserName: "chenmeng",
+				ID:       980,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.DeleteDraft(scene)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoQueryConfig(t *testing.T) {
+	convey.Convey("QueryConfig", t, func(convCtx convey.C) {
+		var (
+			script = &model.Script{
+				SceneID: 325,
+				GroupID: 1,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.QueryConfig(script)
+			convCtx.Convey("Then err should be nil.res should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDeleteScene(t *testing.T) {
+	convey.Convey("DeleteScene", t, func(convCtx convey.C) {
+		var (
+			scene = &model.Scene{
+				ID: 325,
+			}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.DeleteScene(scene)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/ep/melloi/dao/script.go

@@ -0,0 +1,197 @@
+package dao
+
+import (
+	"time"
+
+	"go-common/app/admin/ep/melloi/model"
+)
+
+//QueryScripts query script
+func (d *Dao) QueryScripts(script *model.Script, pn int, ps int) (scripts []*model.Script, err error) {
+	script.Active = 1
+	err = d.DB.Table(model.Script{}.TableName()).Where(script).Order("id asc").Offset((pn - 1) * ps).Limit(ps).Find(&scripts).Error
+	return
+}
+
+//QueryScriptsByPage query scripts by page
+func (d *Dao) QueryScriptsByPage(script *model.Script, pn, ps int32, treeNodes []string) (qsr *model.QueryScriptResponse, err error) {
+	script.TestType = 1
+	qsr = &model.QueryScriptResponse{}
+	gDB := d.DB.Table(model.Script{}.TableName()).Where("app in (?)", treeNodes)
+	if script.Department != "" && script.Project != "" && script.App != "" {
+		gDB = gDB.Where("department = ? and project = ? and app = ?", script.Department, script.Project, script.App)
+	}
+	if script.Department != "" && script.Project != "" {
+		gDB = gDB.Where("department = ? and project = ?", script.Department, script.Project)
+	}
+	if script.Department != "" {
+		gDB = gDB.Where("department = ?", script.Department)
+	}
+	if script.TestName != "" {
+		gDB = gDB.Where("test_name LIKE ? and test_type = ?", "%"+script.TestName+"%", 1)
+	}
+	if script.UpdateBy != "" {
+		gDB = gDB.Where("update_by LIKE ? and test_type = ?", "%"+script.UpdateBy+"%", 1)
+	}
+
+	if script.TestName == "" && script.UpdateBy == "" {
+		gDB = gDB.Where(script)
+	}
+
+	err = gDB.Where("active = 1").Count(&qsr.TotalSize).Order("ctime desc").Offset((pn - 1) * ps).Limit(ps).
+		Find(&qsr.Scripts).Error
+
+	qsr.PageSize = ps /**/
+	qsr.PageNum = pn
+	return
+}
+
+//QueryScriptsByPageWhiteName query by whiteName
+func (d *Dao) QueryScriptsByPageWhiteName(script *model.Script, pn, ps int32) (qsr *model.QueryScriptResponse, err error) {
+	qsr = &model.QueryScriptResponse{}
+	script.TestType = 1
+	gDB := d.DB.Table(model.Script{}.TableName())
+	if script.TestName != "" {
+		gDB = gDB.Where("test_name LIKE ? and test_type = ?", "%"+script.TestName+"%", 1)
+	}
+	if script.UpdateBy != "" {
+		gDB = gDB.Where("update_by LIKE ? and test_type = ?", "%"+script.UpdateBy+"%", 1)
+	}
+
+	if script.TestName == "" && script.UpdateBy == "" {
+		gDB = gDB.Where(script)
+	}
+
+	err = gDB.Where("active = 1").Count(&qsr.TotalSize).Order("ctime desc").Offset((pn - 1) * ps).Limit(ps).
+		Find(&qsr.Scripts).Error
+	qsr.PageSize = ps /**/
+	qsr.PageNum = pn
+	return
+}
+
+//QueryScriptByID get script by id
+func (d *Dao) QueryScriptByID(id int) (script *model.Script, err error) {
+	script = &model.Script{}
+	err = d.DB.Table(model.Script{}.TableName()).Where("id = ? and active = 1", id).First(script).Error
+	return
+}
+
+//QueryScriptsInID get script by id
+func (d *Dao) QueryScriptsInID(id []int) (scripts []*model.Script, err error) {
+	err = d.DB.Table(model.Script{}.TableName()).Where("id in (?) and active = 1", id).Find(&scripts).Error
+	return
+}
+
+//CountQueryScripts count query scripts
+func (d *Dao) CountQueryScripts(script *model.Script) (total int) {
+	d.DB.Table(model.Script{}.TableName()).Where(script).Count(&total)
+	return
+}
+
+//AddScript add script
+func (d *Dao) AddScript(script *model.Script) (id int, groupId int, runOrder int, err error) {
+	if script.OutputParams == "[]" || script.OutputParams == "" {
+		script.OutputParams = "[{\"\":\"\"}]"
+	}
+	if script.APIHeader == "[]" || script.APIHeader == "" {
+		script.APIHeader = "[{\"\":\"\"}]"
+	}
+	if script.ArgumentString == "[]" || script.AssertionString == "" {
+		script.ArgumentString = "[{\"\":\"\"}]"
+	}
+	script.Active = 1
+	err = d.DB.Create(script).Error
+	id = script.ID
+	groupId = script.GroupID
+	runOrder = script.RunOrder
+	return
+}
+
+//QueryParams query params
+func (d *Dao) QueryParams(script *model.Script, scene *model.Scene) (paramList *model.ParamList, err error) {
+	paramList = new(model.ParamList)
+	if scene.SceneType == 1 || scene.SceneType == 0 {
+		err = d.DB.Table(model.Script{}.TableName()).Select("id, group_id, run_order, output_params").Where("scene_id = ? and active = 1", script.SceneID).Order("group_id, run_order").Find(&paramList.ParamList).Error
+	} else if scene.SceneType == 2 {
+		err = d.DB.Table(model.Script{}.TableName()).Select("id, group_id, run_order, output_params").Where("scene_id = ? and group_id = ? and active = 1", script.SceneID, script.GroupID).Order("group_id, run_order").Find(&paramList.ParamList).Error
+	}
+	return
+}
+
+//AddScriptSnap add script snap
+func (d *Dao) AddScriptSnap(scriptSnap *model.ScriptSnap) (id int, err error) {
+	scriptSnap.Ctime = time.Now()
+	scriptSnap.Mtime = time.Now()
+	err = d.DB.Create(scriptSnap).Error
+	id = scriptSnap.ID
+	return
+}
+
+//UpdateScript update script
+func (d *Dao) UpdateScript(script *model.Script) (err error) {
+	script.Mtime = time.Now()
+	if err = d.DB.Exec("update script set is_async = ?, login = ?, keep_alive = ?, use_sign = ?, assertion = ?, conn_time_out = ?, resp_time_out = ?, "+
+		"use_data_file = ?, file_name = ?, params_name = ?, delimiter = ?, fusing = ?, use_business_stop = ?, business_stop_percent = ? where id = ?",
+		script.IsAsync, script.Login, script.KeepAlive, script.UseSign, script.Assertion, script.ConnTimeOut, script.RespTimeOut,
+		script.UseDataFile, script.FileName, script.ParamsName, script.Delimiter, script.Fusing, script.UseBusinessStop, script.BusinessStopPercent, script.ID).Error; err != nil {
+		return
+	}
+
+	if script.OutputParams == "[]" {
+		script.OutputParams = "[{\"\":\"\"}]"
+	}
+	if script.APIHeader == "[]" {
+		script.APIHeader = "[{\"\":\"\"}]"
+	}
+	if script.ArgumentString == "[]" {
+		script.ArgumentString = "[{\"\":\"\"}]"
+	}
+	//script.Active = 1
+	//return d.DB.Model(&model.Script{}).Save(script).Error
+	return d.DB.Model(&model.Script{}).Updates(script).Error
+}
+
+//UpdateScriptPart update scriptPart
+func (d *Dao) UpdateScriptPart(script *model.Script) (err error) {
+	script.Mtime = time.Now()
+	if script.OutputParams == "[]" {
+		script.OutputParams = "[{\"\":\"\"}]"
+	}
+	if script.APIHeader == "[]" {
+		script.APIHeader = "[{\"\":\"\"}]"
+	}
+	if script.ArgumentString == "[]" {
+		script.ArgumentString = "[{\"\":\"\"}]"
+	}
+	//script.Active = 1
+	//return d.DB.Model(&model.Script{}).Save(script).Error
+	return d.DB.Model(&model.Script{}).Updates(script).Error
+}
+
+//AddScriptTimer add script timer
+func (d *Dao) AddScriptTimer(script *model.Script) error {
+	return d.DB.Exec("update script set const_timer = ?, random_timer = ? where id = ?", script.ConstTimer, script.RandomTimer, script.ID).Error
+}
+
+//DelScript delete script
+func (d *Dao) DelScript(id int) error {
+	return d.DB.Model(&model.Script{}).Where("id = ?", id).Update("active", 0).Error
+}
+
+//QueryScriptSnap query script snap
+func (d *Dao) QueryScriptSnap(snap *model.ScriptSnap) (scriptSnap []*model.ScriptSnap, err error) {
+	err = d.DB.Table(model.ScriptSnap{}.TableName()).Where(snap).Find(&scriptSnap).Error
+	return
+}
+
+//ScriptHost query api domain name in script
+func (d *Dao) ScriptHost(script *model.Script) (host string, err error) {
+	err = d.DB.Create(script).Error
+	host = script.Domain
+	return
+}
+
+////UpdateRunOrder Update Run Order
+//func (d *Dao) UpdateRunOrder(runOrder int) error {
+//	return d.DB.Model(&model.Script{}).Where("ID=?", script.ID).Updates(script).Error
+//}

app/admin/ep/melloi/dao/tree.go

@@ -0,0 +1,129 @@
+package dao
+
+import (
+	"context"
+	"net/http"
+
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_treeTokenURI   = "/v1/auth"
+	_treeNodeURI    = "/v1/node/apptree"
+	_ajSessionID    = "_AJSESSIONID"
+	_treeAdminURI   = "/v1/node/role/"
+	_treeRoleAppURI = "/v1/node/role/app"
+	_treeRspCode    = 90000
+)
+
+// QueryServiceTreeToken query service tree token by sessionID
+func (d *Dao) QueryServiceTreeToken(c context.Context, sessionID string) (token string, err error) {
+	var (
+		req      *http.Request
+		tokenURL = d.c.ServiceTree.Host + _treeTokenURI
+		res      struct {
+			Code    int                  `json:"code"`
+			Data    *model.TokenResponse `json:"data"`
+			Message string               `json:"message"`
+			Status  int                  `json:"status"`
+		}
+	)
+
+	if req, err = d.newRequest(http.MethodGet, tokenURL, nil); err != nil {
+		return
+	}
+	req.Header.Set("Cookie", _ajSessionID+"="+sessionID)
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.Token url(%s) res($s) error(%v)", tokenURL, res, err)
+		return
+	}
+	if res.Code != _treeRspCode {
+		err = ecode.MelloiTreeRequestErr
+		log.Error("d.Tree.Response url(%s) resCode(%s) error(%v)", tokenURL, res.Code, err)
+		return
+	}
+	token = res.Data.Token
+	return
+}
+
+// QueryUserTree query user tree by user token
+func (d *Dao) QueryUserTree(c context.Context, token string) (tree *model.UserTree, err error) {
+	var (
+		url = d.c.ServiceTree.Host + _treeNodeURI
+		req *http.Request
+		res = &model.TreeResponse{}
+	)
+
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.Token url(%s) error(%v)", url, err)
+		err = ecode.MerlinTreeRequestErr
+		return
+	}
+	if res.Code != _treeRspCode {
+		err = ecode.MelloiTreeRequestErr
+		log.Error("Get tree error(%v)", err)
+		return
+	}
+	tree = &res.Data
+	return
+}
+
+// QueryUserRoleApp query User role app
+func (d *Dao) QueryUserRoleApp(c context.Context, token string) (ra []*model.RoleApp, err error) {
+	var (
+		url = d.c.ServiceTree.Host + _treeRoleAppURI
+		req *http.Request
+		res = &model.TreeRoleApp{}
+	)
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+	req.Header.Set("Context-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+
+	if err = d.httpClient.Do(c, req, &res); err != nil {
+		log.Error("d.Token url(%s) error(%v)", url, err)
+		return
+	}
+
+	if res.Code != _treeRspCode {
+		err = ecode.MelloiTreeRequestErr
+		log.Error("get tree admin error(%v)", err)
+		return
+	}
+	ra = res.Data
+	return
+}
+
+//QueryTreeAdmin query tree admin
+func (d *Dao) QueryTreeAdmin(c context.Context, path string, token string) (ta *model.TreeAdminResponse, err error) {
+	var (
+		url = d.c.ServiceTree.Host + _treeAdminURI + path
+		req *http.Request
+	)
+	if req, err = d.newRequest(http.MethodGet, url, nil); err != nil {
+		return
+	}
+	req.Header.Set("Context-Type", "application/json")
+	req.Header.Set("X-Authorization-Token", token)
+
+	if err = d.httpClient.Do(c, req, &ta); err != nil {
+		log.Error("d.Token url(%s) error(%v)", url, err)
+		return
+	}
+	if ta.Code != _treeRspCode {
+		err = ecode.MelloiTreeRequestErr
+		log.Error("get tree admin error(%v)", err)
+		return
+	}
+	return
+}

app/admin/ep/melloi/dao/user.go

@@ -0,0 +1,25 @@
+package dao
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/log"
+)
+
+// AddUser add user by user object
+func (d *Dao) AddUser(user *model.User) error {
+	return d.DB.Create(user).Error
+}
+
+// QueryUserByUserName query user info by userName
+func (d *Dao) QueryUserByUserName(userName string) (rows *model.User, err error) {
+	rows = &model.User{}
+	if err = d.DB.Where("name = ?", userName).First(rows).Error; err != nil {
+		log.Error("d.db.Where error(%v)", err)
+	}
+	return
+}
+
+// UpdateUser update user info
+func (d *Dao) UpdateUser(user *model.User) error {
+	return d.DB.Model(&model.User{}).Update(user).Where("ID=?", user.ID).Error
+}

app/admin/ep/melloi/dao/user_test.go

@@ -0,0 +1,14 @@
+package dao
+
+import (
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_User(t *testing.T) {
+	Convey("test QueryUser", t, func() {
+		_, err := d.QueryUserByUserName("hujianping")
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,65 @@
+package dao
+
+import (
+	"context"
+	"net/http"
+
+	"go-common/app/admin/ep/melloi/conf"
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/log"
+)
+
+const (
+	_wechatGroup  = "/ep/admin/saga/v2/wechat/appchat/send"
+	_wechatPerson = "/ep/admin/saga/v2/wechat/message/send"
+)
+
+//AddWechatSend send msg to group
+func (d *Dao) AddWechatSend(c context.Context, cookie, content string) (msgSendRes *model.MsgSendRes, err error) {
+	var (
+		url        = conf.Conf.Wechat.Host + _wechatGroup
+		req        *http.Request
+		msgSendReq = &model.MsgSendReq{
+			ChatID:  conf.Conf.Wechat.Chatid,
+			MsgType: conf.Conf.Wechat.Msgtype,
+			Text:    model.MsgSendReqText{Content: content},
+			Safe:    conf.Conf.Wechat.Safe,
+		}
+	)
+	if req, err = d.newRequest(http.MethodPost, url, msgSendReq); err != nil {
+		return
+	}
+	req.Header.Set("Cookie", cookie)
+	req.Header.Set("Content-Type", "application/json")
+
+	if err = d.httpClient.Do(c, req, &msgSendRes); err != nil {
+		log.Error("d.AddWechatSend url(%s) res($s) error(%v)", url, msgSendRes, err)
+		return
+	}
+	return
+}
+
+// PushWechatMsgToPerson send msg to users
+func (d *Dao) PushWechatMsgToPerson(c context.Context, cookie string, users []string, msg string) (msgSendRes *model.MsgSendRes, err error) {
+	var (
+		url        = conf.Conf.Wechat.Host + _wechatPerson
+		req        *http.Request
+		msgSendReq = &model.MsgSendPersonReq{
+			Users:   users,
+			Content: msg,
+		}
+	)
+
+	if req, err = d.newRequest(http.MethodPost, url, msgSendReq); err != nil {
+		return
+	}
+
+	req.Header.Set("Cookie", cookie)
+	req.Header.Set("Content-Type", "application/json")
+
+	if err = d.httpClient.Do(c, req, &msgSendRes); err != nil {
+		log.Error("d.WeChatPerson url(%s) res($s) error(%v)", url, msgSendRes, err)
+		return
+	}
+	return
+}