Initial commit

app/admin/main/BUILD

@@ -0,0 +1,59 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/activity:all-srcs",
+        "//app/admin/main/aegis:all-srcs",
+        "//app/admin/main/answer:all-srcs",
+        "//app/admin/main/apm:all-srcs",
+        "//app/admin/main/app:all-srcs",
+        "//app/admin/main/appstatic:all-srcs",
+        "//app/admin/main/bfs:all-srcs",
+        "//app/admin/main/block:all-srcs",
+        "//app/admin/main/cache:all-srcs",
+        "//app/admin/main/card:all-srcs",
+        "//app/admin/main/config:all-srcs",
+        "//app/admin/main/coupon:all-srcs",
+        "//app/admin/main/creative:all-srcs",
+        "//app/admin/main/credit:all-srcs",
+        "//app/admin/main/dm:all-srcs",
+        "//app/admin/main/esports:all-srcs",
+        "//app/admin/main/feed:all-srcs",
+        "//app/admin/main/filter:all-srcs",
+        "//app/admin/main/growup:all-srcs",
+        "//app/admin/main/laser:all-srcs",
+        "//app/admin/main/macross:all-srcs",
+        "//app/admin/main/manager:all-srcs",
+        "//app/admin/main/mcn:all-srcs",
+        "//app/admin/main/member:all-srcs",
+        "//app/admin/main/open:all-srcs",
+        "//app/admin/main/passport:all-srcs",
+        "//app/admin/main/point:all-srcs",
+        "//app/admin/main/push:all-srcs",
+        "//app/admin/main/relation:all-srcs",
+        "//app/admin/main/reply:all-srcs",
+        "//app/admin/main/search:all-srcs",
+        "//app/admin/main/sms:all-srcs",
+        "//app/admin/main/space:all-srcs",
+        "//app/admin/main/spy:all-srcs",
+        "//app/admin/main/tag:all-srcs",
+        "//app/admin/main/tv:all-srcs",
+        "//app/admin/main/up:all-srcs",
+        "//app/admin/main/up-rating:all-srcs",
+        "//app/admin/main/upload:all-srcs",
+        "//app/admin/main/usersuit:all-srcs",
+        "//app/admin/main/videoup:all-srcs",
+        "//app/admin/main/videoup-task:all-srcs",
+        "//app/admin/main/vip:all-srcs",
+        "//app/admin/main/workflow:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/OWNERS

@@ -0,0 +1,6 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+labels:
+- admin
+- main
+- new-admin-main-project

app/admin/main/activity/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/activity/cmd:all-srcs",
+        "//app/admin/main/activity/conf:all-srcs",
+        "//app/admin/main/activity/dao:all-srcs",
+        "//app/admin/main/activity/http:all-srcs",
+        "//app/admin/main/activity/model:all-srcs",
+        "//app/admin/main/activity/service:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/CHANGELOG.md

@@ -0,0 +1,28 @@
+# activity-admin
+
+## v1.1.5
+1. kfc查询券码接口
+
+## v1.1.4
+1. account接入grpc
+
+## v1.1.3
+1. admin ipv4Toipv6
+
+## v1.1.2
+1. 批量上传稿件接口
+
+## v1.1.1
+1. php活动接口转go
+
+## v1.1.0
+
+1. 批量获取稿件信息
+
+## v1.0.1
+
+1. init bws
+
+## v1.0.0
+
+1. 初始化代码

app/admin/main/activity/CONTRIBUTORS.md

@@ -0,0 +1,10 @@
+# Owner
+liweijia
+zhapuyu
+renwei
+
+# Author
+liweijia
+
+# Reviewer
+wuhao

app/admin/main/activity/OWNERS

@@ -0,0 +1,15 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- liweijia
+- renwei
+- zhapuyu
+labels:
+- admin
+- admin/main/activity
+- main
+options:
+  no_parent_owners: true
+reviewers:
+- liweijia
+- wuhao

app/admin/main/activity/README.md

@@ -0,0 +1,4 @@
+# activity-admin
+
+# 项目简介
+1. 活动后台管理相关项目

app/admin/main/activity/cmd/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["activity-admin-test.toml"],
+    importpath = "go-common/app/admin/main/activity/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/http:go_default_library",
+        "//app/admin/main/activity/service:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/os/signal:go_default_library",
+        "//library/syscall:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/cmd/activity-admin-test.toml

@@ -0,0 +1,57 @@
+[Log]
+  dir = "/data/log/activity-admin/"
+[HTTPServer]
+    addr = "0.0.0.0:7741"
+    maxListen = 1000
+    timeout = "10m"
+    readTimeout = "10m"
+    writeTimeout = "10m"
+
+[httpClient]
+    key = "b1014d7c339a5649"
+    secret = "75b74b612aa792b112e6504cae44c319"
+    dial = "10s"
+    timeout = "10s"
+    keepAlive = "60s"
+
+[orm]
+    dsn = "test:test@tcp(172.16.33.205:3308)/bilibili_lottery?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    active = 5
+    idle = 5
+    idleTimeout = "4h"
+
+
+[auth]
+    managerHost = "http://uat-manager.bilibili.co"
+    dashboardHost = "http://dashboard-mng.bilibili.co"
+    dashboardCaller = "manager-go"
+    [auth.DsHTTPClient]
+    key = "manager-go"
+    secret = "949bbb2dd3178252638c2407578bc7ad"
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    [auth.MaHTTPClient]
+    key = "f6433799dbd88751"
+    secret = "36f8ddb1806207fe07013ab6a77a3935"
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    [auth.session]
+    sessionIDLength = 32
+    cookieLifeTime = 1800
+    cookieName = "mng-go"
+    domain = ".bilibili.co"
+    [auth.session.Memcache]
+    name = "go-business/auth"
+    proto = "tcp"
+    addr = "172.16.33.54:11211"
+    active = 10
+    idle = 10
+    dialTimeout = "1s"
+    readTimeout = "1s"
+    writeTimeout = "1s"
+    idleTimeout = "80s"
+
+[Host]
+  API = "http://uat-api.bilibili.co"

app/admin/main/activity/cmd/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"time"
+
+	"go-common/app/admin/main/activity/conf"
+	"go-common/app/admin/main/activity/http"
+	"go-common/app/admin/main/activity/service"
+	"go-common/library/log"
+	"go-common/library/net/trace"
+	"go-common/library/os/signal"
+	"go-common/library/syscall"
+)
+
+var (
+	s *service.Service
+)
+
+func main() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		log.Error("conf.Init() error(%v)", err)
+		panic(err)
+	}
+	log.Init(conf.Conf.Log)
+	defer log.Close()
+	trace.Init(conf.Conf.Tracer)
+	defer trace.Close()
+	s = service.New(conf.Conf)
+	http.Init(conf.Conf, s)
+	log.Info("push-admin start")
+	signalHandler()
+}
+
+func signalHandler() {
+	var (
+		ch = make(chan os.Signal, 1)
+	)
+	signal.Notify(ch, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
+	for {
+		si := <-ch
+		switch si {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGINT:
+			time.Sleep(time.Second * 2)
+			log.Info("get a signal %s, stop the push-admin process", si.String())
+			s.Close()
+			s.Wait()
+			time.Sleep(time.Second)
+			return
+		case syscall.SIGHUP:
+		default:
+			return
+		}
+	}
+}

app/admin/main/activity/conf/BUILD

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["conf.go"],
+    importpath = "go-common/app/admin/main/activity/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/conf:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//vendor/github.com/BurntSushi/toml:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/conf/conf.go

@@ -0,0 +1,98 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"go-common/library/conf"
+	"go-common/library/database/orm"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/warden"
+	"go-common/library/net/trace"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	// config
+	confPath string
+	client   *conf.Client
+	// Conf .
+	Conf = &Config{}
+)
+
+// Config def.
+type Config struct {
+	Auth       *permit.Config
+	HTTPServer *bm.ServerConfig
+	HTTPClient *bm.ClientConfig
+	ORM        *orm.Config
+	Log        *log.Config
+	Tracer     *trace.Config
+	Host       *Host
+	// tag rpc client
+	TagRPC *rpc.ClientConfig
+	//article rpc client
+	ArticlrRPC *rpc.ClientConfig
+	ArcClient  *warden.ClientConfig
+	AccClient  *warden.ClientConfig
+}
+
+// Host remote host
+type Host struct {
+	API string
+}
+
+func local() (err error) {
+	_, err = toml.DecodeFile(confPath, &Conf)
+	return
+}
+
+func remote() (err error) {
+	if client, err = conf.New(); err != nil {
+		return
+	}
+	if err = load(); err != nil {
+		return
+	}
+	go func() {
+		for range client.Event() {
+			log.Info("config reload")
+			if load() != nil {
+				log.Error("config reload error (%v)", err)
+			}
+		}
+	}()
+	return
+}
+
+func load() (err error) {
+	var (
+		s       string
+		ok      bool
+		tmpConf *Config
+	)
+	if s, ok = client.Toml2(); !ok {
+		return errors.New("load config center error")
+	}
+	if _, err = toml.Decode(s, &tmpConf); err != nil {
+		return errors.New("could not decode config")
+	}
+	*Conf = *tmpConf
+	return
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default config path")
+}
+
+// Init int config
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}

app/admin/main/activity/dao/BUILD

@@ -0,0 +1,63 @@
+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",
+        "likes_test.go",
+        "subject_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "likes.go",
+        "subject.go",
+    ],
+    importpath = "go-common/app/admin/main/activity/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/activity/dao/kfc:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/dao/dao.go

@@ -0,0 +1,63 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/admin/main/activity/conf"
+	"go-common/library/database/orm"
+	xhttp "go-common/library/net/http/blademaster"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_actURLAddTags = "/x/internal/tag/activity/add"
+	_songsURL      = "/x/internal/v1/audio/songs/activity/filter/info"
+)
+
+// Dao struct user of Dao.
+type Dao struct {
+	c             *conf.Config
+	DB            *gorm.DB
+	client        *xhttp.Client
+	actURLAddTags string
+	songsURL      string
+}
+
+// New create a instance of Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:             c,
+		DB:            orm.NewMySQL(c.ORM),
+		client:        xhttp.NewClient(c.HTTPClient),
+		actURLAddTags: c.Host.API + _actURLAddTags,
+		songsURL:      c.Host.API + _songsURL,
+	}
+	d.initORM()
+	return
+}
+
+func (d *Dao) initORM() {
+	gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
+		if defaultTableName == "act_matchs" {
+			return defaultTableName
+		}
+		return defaultTableName
+	}
+	d.DB.LogMode(true)
+}
+
+// Ping check connection of db , mc.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.DB != nil {
+		err = d.DB.DB().PingContext(c)
+	}
+	return
+}
+
+// Close close connection of db , mc.
+func (d *Dao) Close() {
+	if d.DB != nil {
+		d.DB.Close()
+	}
+}

app/admin/main/activity/dao/dao_test.go

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"flag"
+	"go-common/app/admin/main/activity/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.web-svr.activity-admin")
+		flag.Set("conf_token", "a0c33c892e0c08476ecbb5d28e5880cf")
+		flag.Set("tree_id", "34245")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../cmd/activity-admin-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/admin/main/activity/dao/kfc/BUILD

@@ -0,0 +1,53 @@
+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",
+        "kfc_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "kfc.go",
+    ],
+    importpath = "go-common/app/admin/main/activity/dao/kfc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/model/kfc:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/dao/kfc/dao.go

@@ -0,0 +1,51 @@
+package kfc
+
+import (
+	"context"
+
+	"go-common/app/admin/main/activity/conf"
+	"go-common/library/database/orm"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Dao struct user of Dao.
+type Dao struct {
+	c  *conf.Config
+	DB *gorm.DB
+}
+
+// New create a instance of Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:  c,
+		DB: orm.NewMySQL(c.ORM),
+	}
+	d.initORM()
+	return
+}
+
+func (d *Dao) initORM() {
+	gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
+		if defaultTableName == "act_matchs" {
+			return defaultTableName
+		}
+		return defaultTableName
+	}
+	d.DB.LogMode(true)
+}
+
+// Ping check connection of db , mc.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.DB != nil {
+		err = d.DB.DB().PingContext(c)
+	}
+	return
+}
+
+// Close close connection of db , mc.
+func (d *Dao) Close() {
+	if d.DB != nil {
+		d.DB.Close()
+	}
+}

app/admin/main/activity/dao/kfc/dao_test.go

@@ -0,0 +1,35 @@
+package kfc
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/activity/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.web-svr.activity-admin")
+		flag.Set("conf_token", "a0c33c892e0c08476ecbb5d28e5880cf")
+		flag.Set("tree_id", "34245")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/activity-admin-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/admin/main/activity/dao/kfc/kfc.go

@@ -0,0 +1,26 @@
+package kfc
+
+import (
+	"context"
+
+	kfcmdl "go-common/app/admin/main/activity/model/kfc"
+
+	"github.com/jinzhu/gorm"
+	"github.com/pkg/errors"
+)
+
+// SearchList .
+func (d *Dao) SearchList(c context.Context, code string, mid int64, pn, ps int) (list []*kfcmdl.BnjKfcCoupon, err error) {
+	db := d.DB
+	if code != "" {
+		db = db.Where("coupon_code = ?", code)
+	}
+	if mid != 0 {
+		db = db.Where("mid = ?", mid)
+	}
+	offset := (pn - 1) * ps
+	if err = db.Offset(offset).Limit(ps).Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		err = errors.Wrap(err, "find error")
+	}
+	return
+}

app/admin/main/activity/dao/kfc/kfc_test.go

@@ -0,0 +1,31 @@
+package kfc
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoSearchList(t *testing.T) {
+	convey.Convey("SearchList", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			code = ""
+			mid  = int64(1505589)
+			pn   = 1
+			ps   = 15
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rp, err := d.SearchList(c, code, mid, pn, ps)
+			ctx.Convey("Then err should be nil.rp should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				for _, v := range rp {
+					fmt.Printf("%+v", v)
+				}
+
+			})
+		})
+	})
+}

app/admin/main/activity/dao/likes.go

@@ -0,0 +1,109 @@
+package dao
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/activity/model"
+	"go-common/library/log"
+	"go-common/library/xstr"
+
+	"github.com/jinzhu/gorm"
+	"github.com/pkg/errors"
+)
+
+const (
+	_likeBatchSQL        = "INSERT INTO likes(`sid`,`wid`,`mid`,`type`,`state`,`stick_top`,`ctime`,`mtime`) VALUES %s"
+	_likeContentBatchSQL = "INSERT INTO like_content(`id`,`ipv6`,`ctime`,`mtime`) VALUES %s"
+)
+
+func imgAddKey(uri string) (url string) {
+	if strings.Contains(uri, "http://drawyoo.hdslb.com") {
+		path := strings.Replace(uri, "http://drawyoo.hdslb.com", "", -1)
+		expire := time.Now().Unix() + 3600
+		md5Byte := md5.Sum([]byte(fmt.Sprintf("rjZOPr8w%s%d", path, expire)))
+		md5Key := md5Byte[:]
+		afterKey := strings.Replace(base64.StdEncoding.EncodeToString(md5Key), "+/", "-_", -1)
+		return uri + "?key=" + strings.Replace(afterKey, "=", "", -1) + "&expires=" + fmt.Sprintf("%d", expire)
+	}
+	return uri
+}
+
+// GetLikeContent .
+func (d *Dao) GetLikeContent(c context.Context, ids []int64) (outRes map[int64]*model.LikeContent, err error) {
+	var likeContent []*model.LikeContent
+	if err = d.DB.Where("id in (?)", ids).Find(&likeContent).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(id in %v).Find(),error(%v)", ids, err)
+		return
+	}
+	outRes = make(map[int64]*model.LikeContent, len(likeContent))
+	for _, item := range likeContent {
+		outRes[item.ID] = item
+		outRes[item.ID].Image = imgAddKey(item.Image)
+	}
+	return
+}
+
+// ActSubject get likesubject from db.
+func (d *Dao) ActSubject(c context.Context, sid int64) (rp *model.ActSubject, err error) {
+	rp = new(model.ActSubject)
+	if err = d.DB.Where("id = ?", sid).First(rp).Error; err != nil {
+		log.Error(" s.DB.Where(id ,%d).First() error(%v)", sid, err)
+	}
+	return
+}
+
+// Musics get music info .
+func (d *Dao) Musics(c context.Context, aids []int64, ip string) (music *model.MusicRes, err error) {
+	params := url.Values{}
+	params.Set("songIds", xstr.JoinInts(aids))
+	if err = d.client.Post(c, d.songsURL, ip, params, &music); err != nil {
+		err = errors.Wrapf(err, "d.client.Post(%s)", d.songsURL)
+	}
+	if music.Code != 0 {
+		err = errors.New("get music error")
+	}
+	return
+}
+
+// BatchLike .
+func (d *Dao) BatchLike(c context.Context, item *model.Like, wids []int64, ipv6 []byte) (err error) {
+	var (
+		likesVal []*model.Like
+	)
+	if len(wids) == 0 {
+		return
+	}
+	lidString := make([]string, 0, len(wids))
+	rowStrings := make([]string, 0, len(wids))
+	ctime := time.Now()
+	for _, v := range wids {
+		rowStrings = append(rowStrings, fmt.Sprintf("(%d,%d,%d,%d,%d,%d,'%s','%s')", item.Sid, v, item.Mid, item.Type, item.State, item.StickTop, ctime, ctime))
+	}
+	tx := d.DB.Begin()
+	if err = tx.Model(&model.Like{}).Exec(fmt.Sprintf(_likeBatchSQL, strings.Join(rowStrings, ","))).Error; err != nil {
+		err = errors.Wrapf(err, " d.DB.Model(&model.Like{}).Exec(%s)", _likeBatchSQL)
+		tx.Rollback()
+		return
+	}
+	if err = tx.Model(&model.Like{}).Where(fmt.Sprintf("sid = ? and wid in (%s)", xstr.JoinInts(wids)), item.Sid).Find(&likesVal).Error; err != nil {
+		err = errors.Wrapf(err, " d.DB.Model(&model.Like{}).find()")
+		tx.Rollback()
+		return
+	}
+	for _, itm := range likesVal {
+		lidString = append(lidString, fmt.Sprintf("(%d,'%s','%s','%s')", itm.ID, ipv6, ctime, ctime))
+	}
+	if err = tx.Model(&model.LikeContent{}).Exec(fmt.Sprintf(_likeContentBatchSQL, strings.Join(lidString, ","))).Error; err != nil {
+		err = errors.Wrapf(err, " d.DB.Model(&model.LikeContent{}).Exec(%s)", _likeContentBatchSQL)
+		tx.Rollback()
+		return
+	}
+	err = tx.Commit().Error
+	return
+}

app/admin/main/activity/dao/likes_test.go

@@ -0,0 +1,92 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"testing"
+
+	"go-common/app/admin/main/activity/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoimgAddKey(t *testing.T) {
+	convey.Convey("imgAddKey", t, func(ctx convey.C) {
+		var (
+			uri = "http://i2.hdslb.com/bfs/face/5d2c92beb774a4bb30762538bb102d23670ae9c0.gif"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			url := imgAddKey(uri)
+			ctx.Convey("Then url should not be nil.", func(ctx convey.C) {
+				ctx.So(url, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetLikeContent(t *testing.T) {
+	convey.Convey("GetLikeContent", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			ids = []int64{1, 2}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			outRes, err := d.GetLikeContent(c, ids)
+			ctx.Convey("Then err should be nil.outRes should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				fmt.Printf("%+v", outRes)
+			})
+		})
+	})
+}
+
+func TestDaoActSubject(t *testing.T) {
+	convey.Convey("ActSubject", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			sid = int64(10256)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rp, err := d.ActSubject(c, sid)
+			ctx.Convey("Then err should be nil.rp should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				fmt.Printf("%+v", rp)
+			})
+		})
+	})
+}
+
+func TestDaoMusics(t *testing.T) {
+	convey.Convey("Musics", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			aids = []int64{1, 2}
+			ip   = "10.248.25.36"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			music, err := d.Musics(c, aids, ip)
+			ctx.Convey("Then err should be nil.music should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				fmt.Printf("%+v", music)
+			})
+		})
+	})
+}
+
+func TestDaoBatchLike(t *testing.T) {
+	convey.Convey("BatchLike", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			item = &model.Like{Sid: 10256, Mid: 55}
+			wids = []int64{}
+			ipv6 = net.ParseIP("192.168.3.32")
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.BatchLike(c, item, wids, ipv6)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/activity/dao/subject.go

@@ -0,0 +1,26 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"github.com/pkg/errors"
+)
+
+// AddTags add tags from http request.
+func (d *Dao) AddTags(c context.Context, tags string, ip string) (err error) {
+	var res struct {
+		Code int `json:"code"`
+	}
+	params := url.Values{}
+	params.Set("tag_name", tags)
+	if err = d.client.Post(c, d.actURLAddTags, ip, params, &res); err != nil {
+		err = errors.Wrapf(err, "d.client.Post(%s)", d.actURLAddTags)
+		return
+	}
+	if res.Code != 0 {
+		err = fmt.Errorf("res code(%v)", res)
+	}
+	return
+}

app/admin/main/activity/dao/subject_test.go

@@ -0,0 +1,26 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"fmt"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddTags(t *testing.T) {
+	convey.Convey("AddTags", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tags = "keai"
+			ip   = "10.256.36.68"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.AddTags(c, tags, ip)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				fmt.Printf("%+v", err)
+			})
+		})
+	})
+}

app/admin/main/activity/http/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive.go",
+        "bws.go",
+        "http.go",
+        "kfc.go",
+        "likes.go",
+        "match.go",
+        "subject.go",
+    ],
+    importpath = "go-common/app/admin/main/activity/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//app/admin/main/activity/model/kfc:go_default_library",
+        "//app/admin/main/activity/service:go_default_library",
+        "//app/admin/main/activity/service/kfc:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/http/archive.go

@@ -0,0 +1,14 @@
+package http
+
+import (
+	"go-common/app/admin/main/activity/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func archives(c *bm.Context) {
+	p := &model.ArchiveParam{}
+	if err := c.Bind(p); err != nil {
+		return
+	}
+	c.JSON(actSrv.Archives(c, p))
+}

app/admin/main/activity/http/bws.go

@@ -0,0 +1,712 @@
+package http
+
+import (
+	"go-common/app/admin/main/activity/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// addBws 增加赛程
+func addBws(c *bm.Context) {
+	arg := new(model.ActBws)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBws(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBws 存储赛程
+func saveBws(c *bm.Context) {
+	arg := new(model.ActBws)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBws{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBws(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// bwsInfo 赛程信息
+func bwsInfo(c *bm.Context) {
+	arg := new(model.ActBws)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsInfo(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsList 比赛对象列表
+func bwsList(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBws
+	)
+	v := new(struct {
+		Del  int8 `form:"del" default:"0"`
+		Page int  `form:"pn" default:"1"`
+		Size int  `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsList(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBws{}).Count(&count).Error; err != nil {
+		log.Error("bwsList count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addBwsAchievement 增加赛程
+func addBwsAchievement(c *bm.Context) {
+	arg := new(model.ActBwsAchievement)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBws(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBwsAchievement 存储赛程
+func saveBwsAchievement(c *bm.Context) {
+	arg := new(model.ActBwsAchievement)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBwsAchievement{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBwsAchievement(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// actBwsAchievement 赛程信息
+func bwsAchievement(c *bm.Context) {
+	arg := new(model.ActBwsAchievement)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsAchievement(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsList 比赛对象列表
+func bwsAchievements(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBwsAchievement
+	)
+	v := new(struct {
+		BID  int64 `form:"bid" default:"0"`
+		Del  int8  `form:"del" default:"0"`
+		Page int   `form:"pn" default:"1"`
+		Size int   `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if v.BID != 0 {
+		db = db.Where("bid = ?", v.BID)
+	}
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsAchievements(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBwsAchievement{}).Count(&count).Error; err != nil {
+		log.Error("bwsAchievements count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addBwsField 增加赛程
+func addBwsField(c *bm.Context) {
+	arg := new(model.ActBwsField)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBwsFieldws(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBwsField 存储赛程
+func saveBwsField(c *bm.Context) {
+	arg := new(model.ActBwsField)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBwsAchievement{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBwsField(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// actBwsAchievement 赛程信息
+func bwsField(c *bm.Context) {
+	arg := new(model.ActBwsField)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsField(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsList 比赛对象列表
+func bwsFields(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBwsField
+	)
+	v := new(struct {
+		BID  int64 `form:"bid" default:"0"`
+		Del  int8  `form:"del" default:"0"`
+		Page int   `form:"pn" default:"1"`
+		Size int   `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if v.BID != 0 {
+		db = db.Where("bid = ?", v.BID)
+	}
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsFields(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBwsField{}).Count(&count).Error; err != nil {
+		log.Error("bwsFields count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addBwsPoint
+func addBwsPoint(c *bm.Context) {
+	arg := new(model.ActBwsPoint)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBaddBwsFieldws(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBwsPoint 存储赛程
+func saveBwsPoint(c *bm.Context) {
+	arg := new(model.ActBwsPoint)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBwsPoint{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBwsPoint(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// actBwsAchievement 赛程信息
+func bwsPoint(c *bm.Context) {
+	arg := new(model.ActBwsPoint)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsPoint(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsList 比赛对象列表
+func bwsPoints(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBwsPoint
+	)
+	v := new(struct {
+		FID      int64 `form:"fid" default:"0"`
+		BID      int64 `form:"bid" default:"0"`
+		LockType int64 `form:"lock_type" default:"lock_type"`
+		Del      int8  `form:"del" default:"0"`
+		Page     int   `form:"pn" default:"1"`
+		Size     int   `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if v.BID != 0 {
+		db = db.Where("bid = ?", v.BID)
+	}
+	if v.FID != 0 {
+		db = db.Where("fid = ?", v.FID)
+	}
+	if v.LockType != 0 {
+		db = db.Where("lock_type = ?", v.LockType)
+	}
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsPoints(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBwsPoint{}).Count(&count).Error; err != nil {
+		log.Error("bwsPoints count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addBwsUserAchievement 保存用户
+func addBwsUserAchievement(c *bm.Context) {
+	arg := new(model.ActBwsUserAchievement)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBwsUserAchievement(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBwsUserAchievement 保存用户成就
+func saveBwsUserAchievement(c *bm.Context) {
+	arg := new(model.ActBwsUserAchievement)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBwsUserAchievement{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBwsUserAchievement(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// bwsUserAchievement 用户成就信息
+func bwsUserAchievement(c *bm.Context) {
+	arg := new(model.ActBwsUserAchievement)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsUserAchievement(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsUserAchievements 用户成就列表
+func bwsUserAchievements(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBwsUserAchievement
+	)
+	v := new(struct {
+		MID  int64 `form:"mid" default:"0"`
+		AID  int64 `form:"aid" default:"0"`
+		BID  int64 `form:"bid" default:"0"`
+		Del  int8  `form:"del" default:"0"`
+		Page int   `form:"pn" default:"1"`
+		Size int   `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if v.BID != 0 {
+		db = db.Where("bid = ?", v.BID)
+	}
+	if v.AID != 0 {
+		db = db.Where("aid = ?", v.AID)
+	}
+	if v.MID != 0 {
+		db = db.Where("mid = ?", v.MID)
+	}
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsUserAchievements(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBwsUserAchievement{}).Count(&count).Error; err != nil {
+		log.Error("bwsUserAchievements count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addBwsUserPoint 保存用户
+func addBwsUserPoint(c *bm.Context) {
+	arg := new(model.ActBwsUserPoint)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBwsUserPoint(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBwsUserAchievement 保存用户成就
+func saveBwsUserPoint(c *bm.Context) {
+	arg := new(model.ActBwsUserPoint)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBwsUserPoint{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBwsUserPoint(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// bwsUserPoint 用户点数信息
+func bwsUserPoint(c *bm.Context) {
+	arg := new(model.ActBwsUserPoint)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsUserPoint(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsUserPoints 用户点数列表
+func bwsUserPoints(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBwsUserPoint
+	)
+	v := new(struct {
+		MID      int64  `form:"mid" default:"0"`
+		KEY      string `form:"key" default:""`
+		LockType int64  `form:"lock_type" default:"lock_type"`
+		BID      int64  `form:"bid" default:"0"`
+		Del      int8   `form:"del" default:"0"`
+		Page     int    `form:"pn" default:"1"`
+		Size     int    `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if v.BID != 0 {
+		db = db.Where("bid = ?", v.BID)
+	}
+	if v.KEY != "" {
+		db = db.Where("key = ?", v.KEY)
+	}
+	if v.MID != 0 {
+		db = db.Where("mid = ?", v.MID)
+	}
+	if v.LockType != 0 {
+		db = db.Where("lock_type = ?", v.LockType)
+	}
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsUserPoints(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBwsUserPoint{}).Count(&count).Error; err != nil {
+		log.Error("bwsUserPoints count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addBwsUser 添加用户
+func addBwsUser(c *bm.Context) {
+	arg := new(model.ActBwsUser)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addBwsUserPoint(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveBwsUserAchievement 保存用户成就
+func saveBwsUser(c *bm.Context) {
+	arg := new(model.ActBwsUser)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActBwsUser{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveBwsUserPoint(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// bwsUserPoint 用户点数信息
+func bwsUser(c *bm.Context) {
+	arg := new(model.ActBwsUser)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("bwsUserPoint(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// bwsUserPoints 用户点数列表
+func bwsUsers(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActBwsUser
+	)
+	v := new(struct {
+		MID  int64  `form:"mid" default:"0"`
+		KEY  string `form:"key" default:""`
+		BID  int64  `form:"bid" default:"0"`
+		Del  int8   `form:"del" default:"0"`
+		Page int    `form:"pn" default:"1"`
+		Size int    `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	db = db.Where("del = ?", v.Del)
+	if v.BID != 0 {
+		db = db.Where("bid = ?", v.BID)
+	}
+	if v.KEY != "" {
+		db = db.Where("key = ?", v.KEY)
+	}
+	if v.MID != 0 {
+		db = db.Where("mid = ?", v.MID)
+	}
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("bwsUsers(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActBwsUser{}).Count(&count).Error; err != nil {
+		log.Error("bwsUsers count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}

app/admin/main/activity/http/http.go

@@ -0,0 +1,133 @@
+package http
+
+import (
+	"go-common/app/admin/main/activity/conf"
+	"go-common/app/admin/main/activity/service"
+	"go-common/app/admin/main/activity/service/kfc"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+var (
+	actSrv  *service.Service
+	authSrv *permit.Permit
+	kfcSrv  *kfc.Service
+)
+
+// Init init http sever instance.
+func Init(c *conf.Config, s *service.Service) {
+	actSrv = s
+	kfcSrv = kfc.New(c)
+	authSrv = permit.New(c.Auth)
+	engine := bm.DefaultServer(c.HTTPServer)
+	route(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("httpx.Serve error(%v)", err)
+		panic(err)
+	}
+}
+
+func route(e *bm.Engine) {
+	e.Ping(ping)
+	g := e.Group("/x/admin/activity")
+	{
+		g.GET("/arcs", archives)
+		gapp := g.Group("/matchs", authSrv.Permit("ACT_MATCHS_MGT_TEST"))
+		{
+			gapp.POST("/add", addMatch)
+			gapp.POST("/save", saveMatch)
+			gapp.GET("/info", matchInfo)
+			gapp.GET("/list", matchList)
+		}
+		gappO := g.Group("/matchs/object", authSrv.Permit("ACT_MATCHS_MGT_TEST"))
+		{
+			gappO.POST("/add", addMatchObject)
+			gappO.POST("/save", saveMatchObject)
+			gappO.GET("/info", matchObjectInfo)
+			gappO.GET("/list", matchObjectList)
+		}
+		gappSuject := g.Group("/subject")
+		{
+			gappSuject.GET("/list", listInfosAll)
+			gappSuject.GET("/videos", videoList)
+			gappSuject.POST("/add", addActSubject)
+			gappSuject.POST("/up", updateInfoAll)
+			gappSuject.GET("/protocol", subPro)
+			gappSuject.GET("/conf", timeConf)
+			gappSuject.GET("/articles", article)
+		}
+		gappLikes := g.Group("/likes")
+		{
+			gappLikes.GET("/list", likesList)
+			gappLikes.GET("/lids", likes)
+			gappLikes.POST("/add", addLike)
+			gappLikes.POST("/up", upLike)
+			gappLikes.POST("/up/reply", upListContent)
+			gappLikes.POST("/up/wid", upWid)
+			gappLikes.POST("/add/pic", addPic)
+			gappLikes.POST("/batch/wid", batchLikes)
+		}
+		gappKfc := g.Group("kfc")
+		{
+			gappKfc.GET("/list", kfcList)
+		}
+		gappBws := g.Group("/bws")
+		{
+			gappBws.POST("/add", addBws)
+			gappBws.POST("/save", saveBws)
+			gappBws.GET("/info", bwsInfo)
+			gappBws.GET("/list", bwsList)
+			gappAchievement := gappBws.Group("/achievement")
+			{
+				gappAchievement.POST("/add", addBwsAchievement)
+				gappAchievement.POST("/save", saveBwsAchievement)
+				gappAchievement.GET("/info", bwsAchievement)
+				gappAchievement.GET("/list", bwsAchievements)
+			}
+			gappField := gappBws.Group("/field")
+			{
+				gappField.POST("/add", addBwsField)
+				gappField.POST("/save", saveBwsField)
+				gappField.GET("/info", bwsField)
+				gappField.GET("/list", bwsFields)
+			}
+			gappPoint := gappBws.Group("/point")
+			{
+				gappPoint.POST("/add", addBwsPoint)
+				gappPoint.POST("/save", saveBwsPoint)
+				gappPoint.GET("/info", bwsPoint)
+				gappPoint.GET("/list", bwsPoints)
+			}
+			gappUser := gappBws.Group("/user")
+			{
+				gappUser.POST("/add", addBwsUser)
+				gappUser.POST("/save", saveBwsUser)
+				gappUser.GET("/info", bwsUser)
+				gappUser.GET("/list", bwsUsers)
+				gappUserAchievement := gappUser.Group("/achievement")
+				{
+					gappUserAchievement.POST("/add", addBwsUserAchievement)
+					gappUserAchievement.POST("/save", saveBwsUserAchievement)
+					gappUserAchievement.GET("/info", bwsUserAchievement)
+					gappUserAchievement.GET("/list", bwsUserAchievements)
+				}
+				gappUserPoint := gappUser.Group("/point")
+				{
+					gappUserPoint.POST("/add", addBwsUserPoint)
+					gappUserPoint.POST("/save", saveBwsUserPoint)
+					gappUserPoint.GET("/info", bwsUserPoint)
+					gappUserPoint.GET("/list", bwsUserPoints)
+				}
+			}
+		}
+
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := actSrv.Ping(c); err != nil {
+		c.Error = err
+		c.AbortWithStatus(503)
+	}
+}

app/admin/main/activity/http/kfc.go

@@ -0,0 +1,14 @@
+package http
+
+import (
+	kfcmdl "go-common/app/admin/main/activity/model/kfc"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func kfcList(c *bm.Context) {
+	arg := new(kfcmdl.ListParams)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(kfcSrv.List(c, arg))
+}

app/admin/main/activity/http/likes.go

@@ -0,0 +1,75 @@
+package http
+
+import (
+	"go-common/app/admin/main/activity/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func likesList(c *bm.Context) {
+	arg := new(model.LikesParam)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.LikesList(c, arg))
+}
+
+func likes(c *bm.Context) {
+	var args struct {
+		Sid  int64   `form:"sid" validate:"min=1,required"`
+		Lids []int64 `form:"lids,split" validate:"min=1,max=50,dive,min=1"`
+	}
+	if err := c.Bind(&args); err != nil {
+		return
+	}
+	c.JSON(actSrv.Likes(c, args.Sid, args.Lids))
+}
+
+func addLike(c *bm.Context) {
+	args := new(model.AddLikes)
+	if err := c.Bind(args); err != nil {
+		return
+	}
+	c.JSON(actSrv.AddLike(c, args))
+}
+
+func upLike(c *bm.Context) {
+	args := new(model.UpLike)
+	if err := c.Bind(args); err != nil {
+		return
+	}
+	username, _ := c.Get("username")
+	c.JSON(actSrv.UpLike(c, args, username.(string)))
+}
+
+func upListContent(c *bm.Context) {
+	args := new(model.UpReply)
+	if err := c.Bind(args); err != nil {
+		return
+	}
+	username, _ := c.Get("username")
+	c.JSON(nil, actSrv.UpLikesState(c, args.IDs, args.State, args.Reply, username.(string)))
+}
+
+func upWid(c *bm.Context) {
+	args := new(model.UpWid)
+	if err := c.Bind(args); err != nil {
+		return
+	}
+	c.JSON(nil, actSrv.UpWid(c, args))
+}
+
+func addPic(c *bm.Context) {
+	args := new(model.AddPic)
+	if err := c.Bind(args); err != nil {
+		return
+	}
+	c.JSON(actSrv.AddPicContent(c, args))
+}
+
+func batchLikes(c *bm.Context) {
+	args := new(model.BatchLike)
+	if err := c.Bind(args); err != nil {
+		return
+	}
+	c.JSON(nil, actSrv.BatchLikes(c, args))
+}

app/admin/main/activity/http/match.go

@@ -0,0 +1,213 @@
+package http
+
+import (
+	"fmt"
+	"go-common/app/admin/main/activity/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// addMatch 增加赛程
+func addMatch(c *bm.Context) {
+	arg := new(model.ActMatchs)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addMatch(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveMatch 存储赛程
+func saveMatch(c *bm.Context) {
+	arg := new(model.ActMatchs)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Model(&model.ActMatchs{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveMatch(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// matchInfo 赛程信息
+func matchInfo(c *bm.Context) {
+	arg := new(model.ActMatchs)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("matcInfo(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// matchList 比赛对象列表
+func matchList(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActMatchs
+	)
+	v := new(struct {
+		SID    int64 `form:"sid" default:"-1"`
+		Status int8  `form:"status" default:"-1"`
+		Page   int   `form:"pn" default:"1"`
+		Size   int   `form:"ps" default:"20"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	if v.Status != -1 {
+		db = db.Where("status = ?", v.Status)
+	}
+	if v.SID != -1 {
+		db = db.Where("sid = ?", v.SID)
+	}
+	db = db.Where("status = ?", 0)
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("businessList(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActMatchs{}).Count(&count).Error; err != nil {
+		log.Error("businessList count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}
+
+// addMatchObject 比赛对象
+func addMatchObject(c *bm.Context) {
+	arg := new(model.ActMatchsObject)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if err := actSrv.DB.Create(arg).Error; err != nil {
+		log.Error("addMatch(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// saveMatchObject 更新比赛对象
+func saveMatchObject(c *bm.Context) {
+	arg := new(model.ActMatchsObject)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	fmt.Println(arg.AwayName)
+	fmt.Println(arg.HomeLogo)
+	if err := actSrv.DB.Model(&model.ActMatchsObject{ID: arg.ID}).Update(arg).Error; err != nil {
+		log.Error("saveMatch(%v) error(%v)", arg, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+// matchObjectInfo 比赛对象信息
+func matchObjectInfo(c *bm.Context) {
+	arg := new(model.ActMatchsObject)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if err := actSrv.DB.First(arg, arg.ID).Error; err != nil {
+		log.Error("matcInfo(%d) error(%v)", arg.ID, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(arg, nil)
+}
+
+// matchObjectList 比赛对象列表
+func matchObjectList(c *bm.Context) {
+	var (
+		err   error
+		count int
+		list  []*model.ActMatchsObject
+	)
+	v := new(struct {
+		SID     int64 `form:"sid" default:"-1"`
+		Status  int8  `form:"status" default:"-1"`
+		Page    int   `form:"pn" default:"1"`
+		Size    int   `form:"ps" default:"20"`
+		MatchID int   `form:"match_id"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	db := actSrv.DB
+	if v.Page == 0 {
+		v.Page = 1
+	}
+	if v.Size == 0 {
+		v.Size = 20
+	}
+	if v.Status != -1 {
+		db = db.Where("status = ?", v.Status)
+	}
+	if v.SID != -1 {
+		db = db.Where("sid = ?", v.SID)
+	}
+	if v.MatchID != 0 {
+		db = db.Where("match_id = ?", v.MatchID)
+	}
+	db = db.Where("status = ?", 0)
+	if err = db.
+		Offset((v.Page - 1) * v.Size).Limit(v.Size).
+		Find(&list).Error; err != nil {
+		log.Error("businessList(%d,%d) error(%v)", v.Page, v.Size, err)
+		c.JSON(nil, err)
+		return
+	}
+	if err = db.Model(&model.ActMatchsObject{}).Count(&count).Error; err != nil {
+		log.Error("businessList count error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	data := map[string]interface{}{
+		"data":  list,
+		"pn":    v.Page,
+		"ps":    v.Size,
+		"total": count,
+	}
+	c.JSONMap(data, nil)
+}

app/admin/main/activity/http/subject.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"go-common/app/admin/main/activity/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func listInfosAll(c *bm.Context) {
+	arg := new(model.ListSub)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.SubjectList(c, arg))
+}
+
+func videoList(c *bm.Context) {
+	c.JSON(actSrv.VideoList(c))
+}
+
+func addActSubject(c *bm.Context) {
+	arg := new(model.AddList)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.AddActSubject(c, arg))
+}
+
+func updateInfoAll(c *bm.Context) {
+	type upStr struct {
+		model.AddList
+		Sid int64 `form:"sid" validate:"min=1"`
+	}
+	arg := new(upStr)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.UpActSubject(c, &arg.AddList, arg.Sid))
+}
+
+func subPro(c *bm.Context) {
+	type subStr struct {
+		Sid int64 `form:"sid" validate:"min=1"`
+	}
+	arg := new(subStr)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.SubProtocol(c, arg.Sid))
+}
+
+func timeConf(c *bm.Context) {
+	type subStr struct {
+		Sid int64 `form:"sid" validate:"required"`
+	}
+	arg := new(subStr)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.TimeConf(c, arg.Sid))
+}
+
+func article(c *bm.Context) {
+	type subStr struct {
+		Aids []int64 `form:"aids,split" validate:"min=1,required"`
+	}
+	arg := new(subStr)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	c.JSON(actSrv.GetArticleMetas(c, arg.Aids))
+}

app/admin/main/activity/model/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["model_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive.go",
+        "bws.go",
+        "likes.go",
+        "match.go",
+        "subject.go",
+    ],
+    importpath = "go-common/app/admin/main/activity/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//library/time:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/activity/model/kfc:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/model/archive.go

@@ -0,0 +1,6 @@
+package model
+
+// ArchiveParam .
+type ArchiveParam struct {
+	Aids []int64 `json:"aids" form:"aids,split" validate:"min=1,max=30,dive,gt=0"`
+}

app/admin/main/activity/model/bws.go

@@ -0,0 +1,108 @@
+package model
+
+import (
+	"time"
+)
+
+// ActBws def.
+type ActBws struct {
+	ID    int64     `json:"id" form:"id"`
+	Name  string    `json:"name" form:"name"`
+	Image string    `json:"image" form:"image"`
+	Dic   string    `json:"dic" form:"dic"`
+	Del   int8      `json:"del" form:"del"`
+	Ctime time.Time `json:"ctime"`
+	Mtime time.Time `json:"mtime"`
+}
+
+// ActBwsAchievement def.
+type ActBwsAchievement struct {
+	ID            int64     `json:"id" form:"id"`
+	Name          string    `json:"name" form:"name"`
+	Icon          string    `json:"icon" form:"icon"`
+	Dic           string    `json:"dic" form:"dic"`
+	Image         string    `json:"image" form:"image"`
+	LinkType      int64     `json:"link_type" form:"link_type"`
+	Unlock        int64     `json:"unlock" form:"unlock"`
+	BID           int64     `json:"bid" gorm:"column:bid"  form:"bid"`
+	IconBig       string    `json:"icon_big" form:"icon_big"`
+	IconActive    string    `json:"icon_active" form:"icon_active"`
+	IconActiveBig string    `json:"icon_active_big" form:"icon_active_big"`
+	Award         int8      `json:"award" form:"award"`
+	Ctime         time.Time `json:"ctime"`
+	Mtime         time.Time `json:"mtime"`
+	Del           int8      `json:"del"  form:"del"`
+	SuitID        int64     `json:"suit_id" gorm:"column:suit_id"  form:"suit_id"`
+}
+
+// ActBwsField def.
+type ActBwsField struct {
+	ID    int64     `json:"id" form:"id"`
+	Name  string    `json:"name" form:"name"`
+	Area  string    `json:"area" form:"area"`
+	BID   int64     `json:"bid" gorm:"column:bid"  form:"bid"`
+	Del   int8      `json:"del" form:"del"`
+	Ctime time.Time `json:"ctime"`
+	Mtime time.Time `json:"mtime"`
+}
+
+// ActBwsPoint def.
+type ActBwsPoint struct {
+	ID           int64     `json:"id" form:"id"`
+	Name         string    `json:"name" form:"name"`
+	Icon         string    `json:"icon" form:"icon"`
+	FID          int64     `json:"fid" gorm:"column:fid"  form:"fid"`
+	Ower         int64     `json:"ower" gorm:"column:ower"  form:"ower"`
+	Image        string    `json:"image" form:"image"`
+	Unlocked     int64     `json:"unlocked" form:"unlocked"`
+	LoseUnlocked int64     `json:"lose_unlocked" form:"lose_unlocked"`
+	LockType     int64     `json:"lock_type" form:"lock_type"`
+	Dic          string    `json:"dic" form:"dic"`
+	Rule         string    `json:"rule" form:"rule"`
+	BID          int64     `json:"bid" gorm:"column:bid"  form:"bid"`
+	OtherIP      string    `json:"other_ip" gorm:"column:other_ip" form:"other_ip"`
+	Del          int8      `json:"del" form:"del"`
+	Ctime        time.Time `json:"ctime"`
+	Mtime        time.Time `json:"mtime"`
+}
+
+// ActBwsUserAchievement def.
+type ActBwsUserAchievement struct {
+	ID    int64     `json:"id" form:"id"`
+	MID   int64     `json:"mid" gorm:"column:mid"  form:"mid"`
+	AID   int64     `json:"aid" gorm:"column:aid"  form:"aid"`
+	BID   int64     `json:"bid" gorm:"column:bid"  form:"bid"`
+	Key   string    `json:"key" form:"key"`
+	Del   int8      `json:"del" form:"del"`
+	Ctime time.Time `json:"ctime"`
+	Mtime time.Time `json:"mtime"`
+}
+
+// ActBwsUserPoint def.
+type ActBwsUserPoint struct {
+	ID     int64     `json:"id" form:"id"`
+	MID    int64     `json:"mid" gorm:"column:mid"  form:"mid"`
+	PID    int64     `json:"pid" gorm:"column:pid"  form:"pid"`
+	BID    int64     `json:"bid" gorm:"column:bid"  form:"bid"`
+	Key    string    `json:"key" form:"key"`
+	Points int64     `json:"points" form:"points"`
+	Del    int8      `json:"del" form:"del"`
+	Ctime  time.Time `json:"ctime"`
+	Mtime  time.Time `json:"mtime"`
+}
+
+// ActBwsUser def.
+type ActBwsUser struct {
+	ID    int64     `json:"id" form:"id"`
+	MID   int64     `json:"mid" gorm:"column:mid"  form:"mid"`
+	BID   int64     `json:"bid" gorm:"column:bid"  form:"bid"`
+	Key   string    `json:"key" form:"key"`
+	Del   int8      `json:"del" form:"del"`
+	Ctime time.Time `json:"ctime"`
+	Mtime time.Time `json:"mtime"`
+}
+
+// TableName ActBws def.
+func (ActBws) TableName() string {
+	return "act_bws"
+}

app/admin/main/activity/model/kfc/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["kfc.go"],
+    importpath = "go-common/app/admin/main/activity/model/kfc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//library/time:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/model/kfc/kfc.go

@@ -0,0 +1,28 @@
+package kfc
+
+import "go-common/library/time"
+
+// ListParams .
+type ListParams struct {
+	CouponCode string `form:"coupon_code"`
+	Mid        int64  `form:"mid"`
+	Pn         int    `form:"pn" default:"0" validate:"min=0"`
+	Ps         int    `form:"ps" default:"15" validate:"min=1"`
+}
+
+//BnjKfcCoupon def
+type BnjKfcCoupon struct {
+	ID         int64     `json:"id"  gorm:"column:id"`
+	Mid        int64     `json:"mid"  gorm:"column:mid"`
+	CouponCode string    `json:"coupon_code"  gorm:"column:coupon_code"`
+	Desc       string    `json:"desc"  gorm:"column:desc"`
+	State      int       `json:"state"  gorm:"column:state"`
+	DeleteTime time.Time `json:"delete_time"  gorm:"column:delete_time" time_format:"2006-01-02 15:04:05"`
+	Ctime      time.Time `json:"ctime"  gorm:"column:ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime      time.Time `json:"mtime"  gorm:"column:mtime" time_format:"2006-01-02 15:04:05"`
+}
+
+// TableName BnjKfcCoupon def
+func (BnjKfcCoupon) TableName() string {
+	return "bnj_kfc_coupon"
+}

app/admin/main/activity/model/likes.go

@@ -0,0 +1,143 @@
+package model
+
+import (
+	xtime "go-common/library/time"
+)
+
+// LikesParam def.
+type LikesParam struct {
+	Sid      int64 `form:"sid" validate:"min=1"`
+	Mid      int64 `form:"mid"`
+	Wid      int64 `form:"wid"`
+	Page     int   `form:"page" default:"1" validate:"min=1"`
+	PageSize int   `form:"pagesize" default:"15" validate:"min=1"`
+	States   []int `form:"state,split"`
+}
+
+// AddLikes .
+type AddLikes struct {
+	DealType string `form:"deal_type" validate:"required"`
+	Wid      int64  `form:"wid"`
+	Sid      int64  `form:"sid" validate:"min=1"`
+	Type     int    `form:"type"`
+	Mid      int64  `form:"mid"`
+	State    int    `form:"state"`
+	Plat     int    `form:"plat"`
+	Device   int    `form:"device"`
+}
+
+// UpReply .
+type UpReply struct {
+	State int     `form:"state"`
+	Reply string  `form:"reply"`
+	IDs   []int64 `form:"ids,split" validate:"min=1,max=50"`
+}
+
+// UpWid .
+type UpWid struct {
+	Sid   int64 `form:"sid" validate:"min=1"`
+	Wid   int64 `form:"wid" validate:"min=1"`
+	State int   `form:"state"`
+}
+
+// BatchLike .
+type BatchLike struct {
+	Sid  int64   `form:"sid" validate:"min=1"`
+	Wid  []int64 `form:"wid,split" validate:"min=1,max=200,dive,gt=0"`
+	Mid  int64   `form:"mid"`
+	Type int     `form:"type"`
+}
+
+// AddPic .
+type AddPic struct {
+	Sid     int64  `form:"sid" validate:"min=1"`
+	Type    int    `form:"type"`
+	Mid     int64  `form:"mid"`
+	Wid     int64  `form:"wid"`
+	Plat    int    `form:"plat"`
+	Device  int    `form:"device"`
+	Image   string `form:"image"`
+	Message string `form:"message" validate:"required,max=450,min=1"`
+	Link    string `form:"link"`
+}
+
+// UpLike .
+type UpLike struct {
+	Type     int    `form:"type"`
+	Mid      int64  `form:"mid"`
+	Wid      int64  `form:"wid"`
+	State    int    `form:"state"`
+	StickTop int    `form:"stick_top"`
+	Lid      int64  `form:"lid" validate:"min=1"`
+	Message  string `form:"message"`
+	Reply    string `form:"reply"`
+	Link     string `form:"link"`
+	Image    string `form:"image"`
+}
+
+// ActivityAVInfo active_id -> avid
+type ActivityAVInfo struct {
+	ActivityID int64 `json:"mission_id"`
+	AVID       int64 `json:"id"`
+	MID        int64 `json:"mid"`
+	Category   int   `json:"typeid"`
+	TagID      int64 `json:"-"`
+	Ratio      int   `json:"-"`
+}
+
+// LikeContent def
+type LikeContent struct {
+	ID      int64      `json:"id" form:"id" gorm:"column:id"`
+	Message string     `json:"message" form:"message"`
+	IP      int64      `json:"ip" form:"ip" gorm:"column:ip"`
+	Plat    int        `json:"plat" form:"plat"`
+	Device  int        `json:"device" form:"device"`
+	Ctime   xtime.Time `json:"ctime" form:"ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime   xtime.Time `json:"mtime" form:"mtime" time_format:"2006-01-02 15:04:05"`
+	Image   string     `json:"image" form:"image"`
+	Reply   string     `json:"reply" form:"reply"`
+	Link    string     `json:"link" form:"link"`
+	ExName  string     `json:"ex_name" form:"ex_name"`
+	IPv6    []byte     `json:"ipv6" gorm:"column:ipv6"`
+}
+
+//ActLikeLog def
+type ActLikeLog struct {
+	ID    int64      `json:"id" form:"id" gorm:"column:id"`
+	Lid   int64      `json:"lid" form:"lid" gorm:"column:lid"`
+	User  string     `json:"user" form:"user" gorm:"column:user"`
+	State int64      `json:"state" form:"state" gorm:"column:state"`
+	Ctime xtime.Time `json:"ctime" form:"ctime" gorm:"column:ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime xtime.Time `json:"mtime" form:"mtime" gorm:"column:mtime" time_format:"2006-01-02 15:04:05"`
+}
+
+// LikesRes .
+type LikesRes struct {
+	Likes map[int64]*Like `json:"likes"`
+	PageRes
+}
+
+// MusicRes .
+type MusicRes struct {
+	Code int `json:"code"`
+	Data map[int64]struct {
+		CoverURL  string   `json:"coverUrl"`
+		Duration  string   `json:"duration"`
+		Categorie string   `json:"categorie"`
+		Intro     string   `json:"intro"`
+		Mid       int64    `json:"mid"`
+		Title     string   `json:"title"`
+		SongID    int64    `json:"songId"`
+		PlayURL   []string `json:"playUrl"`
+	}
+}
+
+// TableName ActLikeLog def
+func (ActLikeLog) TableName() string {
+	return "act_like_log"
+}
+
+// TableName LikeContent def
+func (LikeContent) TableName() string {
+	return "like_content"
+}

app/admin/main/activity/model/match.go

@@ -0,0 +1,44 @@
+package model
+
+import (
+	"time"
+)
+
+// ActMatchs def.
+type ActMatchs struct {
+	ID       int64     `json:"id" form:"id"`
+	Name     string    `json:"name" form:"name"`
+	URL      string    `json:"url" form:"url"`
+	Cover    string    `json:"cover" form:"cover"`
+	SID      int64     `json:"sid" form:"sid" gorm:"column:sid"`
+	MaxStake int64     `json:"max_stake" form:"max_stake"`
+	Stake    int8      `json:"stake" form:"stake"`
+	Status   int8      `json:"status" form:"status"`
+	Ctime    time.Time `json:"ctime"`
+	Mtime    time.Time `json:"mtime"`
+}
+
+// ActMatchsObject def.
+type ActMatchsObject struct {
+	ID        int64     `json:"id" form:"id"`
+	HomeName  string    `json:"home_name" form:"home_name"`
+	HomeLogo  string    `json:"home_logo" form:"home_logo"`
+	HomeScore int64     `json:"home_score" form:"home_score"`
+	AwayName  string    `json:"away_name" form:"away_name"`
+	AwayLogo  string    `json:"away_logo" form:"away_logo"`
+	AwayScore int64     `json:"away_score" form:"away_score"`
+	SID       int64     `json:"sid" gorm:"column:sid"  form:"sid"`
+	MatchID   int64     `json:"match_id" form:"match_id"`
+	GameStime time.Time `json:"game_stime" form:"game_stime" time_format:"2006-01-02 15:04:05"`
+	Stime     time.Time `json:"stime" form:"stime" time_format:"2006-01-02 15:04:05"`
+	Etime     time.Time `json:"etime" form:"etime" time_format:"2006-01-02 15:04:05"`
+	Ctime     time.Time `json:"ctime"`
+	Mtime     time.Time `json:"mtime"`
+	Result    int8      `json:"result"  form:"result"`
+	Status    int8      `json:"status"  form:"status"`
+}
+
+// TableName ActMatchsObject def.
+func (ActMatchsObject) TableName() string {
+	return "act_matchs_object"
+}

app/admin/main/activity/model/model_test.go

@@ -0,0 +1,9 @@
+package model
+
+import "testing"
+
+func Test_Funcs(t *testing.T) {
+	act := new(ActMatchsObject)
+	s := act.TableName()
+	t.Logf("tablename  %s", s)
+}

app/admin/main/activity/model/subject.go

@@ -0,0 +1,192 @@
+package model
+
+import (
+	xtime "go-common/library/time"
+)
+
+// VIDEO actiivty types .
+const (
+	VIDEO        = 1
+	PICTURE      = 2
+	DRAWYOO      = 3
+	VIDEOLIKE    = 4
+	PICTURELIKE  = 5
+	DRAWYOOLIKE  = 6
+	TEXT         = 7
+	TEXTLIKE     = 8
+	ONLINEVOTE   = 9
+	QUESTION     = 10
+	LOTTERY      = 11
+	ARTICLE      = 12
+	VIDEO2       = 13
+	MUSIC        = 15
+	PHONEVIDEO   = 16
+	SMALLVIDEO   = 17
+	RESERVATION  = 18
+	MISSIONGROUP = 19
+)
+
+// SidSub def
+type SidSub struct {
+	Type int     `form:"type" validate:"required"`
+	Lids []int64 `form:"lids,split" validate:"max=50,min=1,dive,min=1"`
+}
+
+// ListSub def
+type ListSub struct {
+	Page     int    `form:"page" default:"1" validate:"min=1"`
+	PageSize int    `form:"pagesize" default:"15" validate:"min=1"`
+	Keyword  string `form:"keyword"`
+	States   []int  `form:"state,split" default:"0"`
+	Types    []int  `form:"type,split" default:"0"`
+	Sctime   int64  `form:"sctime"`
+	Ectime   int64  `form:"ectime"`
+}
+
+// SubListRes .
+type SubListRes struct {
+	List []*ActSubject `json:"list"`
+	Page *PageRes      `json:"page"`
+}
+
+// PageRes .
+type PageRes struct {
+	Num   int   `json:"num"`
+	Size  int   `json:"size"`
+	Total int64 `json:"total"`
+}
+
+// AddList def
+type AddList struct {
+	ActSubject
+	Protocol  string     `form:"protocol"`
+	Types     string     `form:"types"`
+	Pubtime   xtime.Time `form:"pubtime" time_format:"2006-01-02 15:04:05"`
+	Deltime   xtime.Time `form:"deltime" time_format:"2006-01-02 15:04:05"`
+	Editime   xtime.Time `form:"editime" time_format:"2006-01-02 15:04:05"`
+	Tags      string     `form:"tags"`
+	Interval  int        `form:"interval"`
+	Tlimit    int        `form:"tlimit"`
+	Ltime     int        `form:"ltime"`
+	Hot       int        `form:"hot"`
+	BgmID     int64      `form:"bgm_id"`
+	PasterID  int64      `form:"paster_id"`
+	Oids      string     `from:"oids"`
+	ScreenSet int        `form:"screen_set" default:"1"`
+}
+
+//ActSubjectProtocol def
+type ActSubjectProtocol struct {
+	ID        int64      `json:"id" form:"id" gorm:"column:id"`
+	Sid       int64      `json:"sid" form:"sid"`
+	Protocol  string     `json:"protocol" form:"protocol"`
+	Mtime     xtime.Time `json:"mtime" form:"mtime" time_format:"2006-01-02 15:04:05"`
+	Ctime     xtime.Time `json:"ctime" form:"ctime" time_format:"2006-01-02 15:04:05"`
+	Types     string     `json:"types" form:"types"`
+	Tags      string     `json:"tags" form:"tags"`
+	Hot       int        `json:"hot" form:"hot"`
+	Pubtime   xtime.Time `json:"pubtime" form:"pubtime" time_format:"2006-01-02 15:04:05"`
+	Deltime   xtime.Time `json:"deltime" form:"deltime" time_format:"2006-01-02 15:04:05"`
+	Editime   xtime.Time `json:"editime" form:"editime" time_format:"2006-01-02 15:04:05"`
+	BgmID     int64      `json:"bgm_id" form:"bgm_id" gorm:"column:bgm_id"`
+	PasterID  int64      `json:"paster_id" form:"paster_id" gorm:"column:paster_id"`
+	Oids      string     `json:"oids" form:"oids" gorm:"column:oids"`
+	ScreenSet int        `json:"screen_set" form:"screen_set" gorm:"column:screen_set"`
+}
+
+//ActTimeConfig def
+type ActTimeConfig struct {
+	ID       int64      `json:"id" form:"id" gorm:"column:id"`
+	Sid      int64      `json:"sid" form:"sid"`
+	Interval int        `json:"interval" form:"interval"`
+	Ctime    xtime.Time `json:"ctime" form:"ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime    xtime.Time `json:"mtime" form:"mtime" time_format:"2006-01-02 15:04:05"`
+	Tlimit   int        `json:"tlimit" form:"tlimit"`
+	Ltime    int        `json:"ltime" form:"ltime"`
+}
+
+// ActSubject def.
+type ActSubject struct {
+	ID         int64      `json:"id,omitempty" form:"id" gorm:"column:id"`
+	Oid        int64      `json:"oid,omitempty" form:"oid"`
+	Type       int        `json:"type,omitempty" form:"type"`
+	State      int        `json:"state,omitempty" form:"state"`
+	Level      int        `json:"level,omitempty" form:"level"`
+	Flag       int64      `json:"flag,omitempty" form:"flag"`
+	Rank       int64      `json:"rank,omitempty" form:"rank"`
+	Stime      xtime.Time `json:"stime,omitempty" form:"stime" time_format:"2006-01-02 15:04:05"`
+	Etime      xtime.Time `json:"etime,omitempty" form:"etime" time_format:"2006-01-02 15:04:05"`
+	Ctime      xtime.Time `json:"ctime,omitempty" form:"ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime      xtime.Time `json:"mtime,omitempty" form:"mtime" time_format:"2006-01-02 15:04:05"`
+	Lstime     xtime.Time `json:"lstime,omitempty" form:"lstime" time_format:"2006-01-02 15:04:05"`
+	Letime     xtime.Time `json:"letime,omitempty" form:"letime" time_format:"2006-01-02 15:04:05"`
+	Uetime     xtime.Time `json:"uetime,omitempty" form:"uetime" time_format:"2006-01-02 15:04:05"`
+	Ustime     xtime.Time `json:"ustime,omitempty" form:"ustime" time_format:"2006-01-02 15:04:05"`
+	Name       string     `json:"name,omitempty" form:"name"`
+	Author     string     `json:"author,omitempty" form:"author"`
+	ActURL     string     `json:"act_url,omitempty" form:"act_url"`
+	Cover      string     `json:"cover,omitempty" form:"cover"`
+	Dic        string     `json:"dic,omitempty" form:"dic"`
+	H5Cover    string     `json:"h5_cover,omitempty" form:"h5_cover"`
+	LikeLimit  int        `json:"like_limit" form:"like_limit"`
+	AndroidURL string     `json:"android_url"`
+	IosURL     string     `json:"ios_url"`
+}
+
+// ActSubjectResult .
+type ActSubjectResult struct {
+	*ActSubject
+	Aids []int64 `json:"aids,omitempty"`
+}
+
+// Like def.
+type Like struct {
+	ID       int64       `json:"id" form:"id" gorm:"column:id"`
+	Sid      int64       `json:"sid" form:"sid"`
+	Type     int         `json:"type" form:"type"`
+	Mid      int64       `json:"mid" form:"mid"`
+	Wid      int64       `json:"wid" form:"wid"`
+	State    int         `json:"state" form:"state"`
+	StickTop int         `json:"stick_top" form:"stick_top"`
+	Ctime    xtime.Time  `json:"ctime" form:"ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime    xtime.Time  `json:"mtime" form:"mtime" time_format:"2006-01-02 15:04:05"`
+	Object   interface{} `json:"object,omiempty" gorm:"-"`
+	Like     int64       `json:"like,omiempty" gorm:"-"`
+}
+
+//LikeAction def
+type LikeAction struct {
+	ID     int64      `form:"id" gorm:"column:id"`
+	Lid    int64      `form:"lid"`
+	Mid    int64      `form:"mid"`
+	Action int64      `form:"action"`
+	Ctime  xtime.Time `form:"ctime" time_format:"2006-01-02 15:04:05"`
+	Mtime  xtime.Time `form:"mtime" time_format:"2006-01-02 15:04:05"`
+	Sid    int64      `form:"sid"`
+	IP     int64      `form:"ip" gorm:"column:ip"`
+}
+
+// TableName LikeAction def
+func (LikeAction) TableName() string {
+	return "like_action"
+}
+
+// TableName ActMatchs def.
+func (ActSubject) TableName() string {
+	return "act_subject"
+}
+
+// TableName Likes def
+func (Like) TableName() string {
+	return "likes"
+}
+
+// TableName ActSubjectProtocol def
+func (ActSubjectProtocol) TableName() string {
+	return "act_subject_protocol"
+}
+
+// TableName ActTimeConfig def
+func (ActTimeConfig) TableName() string {
+	return "act_time_config"
+}

app/admin/main/activity/service/BUILD

@@ -0,0 +1,74 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive.go",
+        "likes.go",
+        "service.go",
+        "subject.go",
+    ],
+    importpath = "go-common/app/admin/main/activity/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/dao:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/interface/main/tag/rpc/client:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/rpc/client:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/activity/service/kfc:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "archive_test.go",
+        "likes_test.go",
+        "service_test.go",
+        "subject_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/activity/service/archive.go

@@ -0,0 +1,27 @@
+package service
+
+import (
+	"context"
+
+	lmdl "go-common/app/admin/main/activity/model"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/log"
+)
+
+// Archives get achives info .
+func (s *Service) Archives(c context.Context, p *lmdl.ArchiveParam) (res map[int64]*arcmdl.Arc, err error) {
+	var (
+		arcs *arcmdl.ArcsReply
+	)
+	if arcs, err = s.arcClient.Arcs(c, &arcmdl.ArcsRequest{Aids: p.Aids}); err != nil {
+		log.Error("s.arcClient.Archives3(%v) error(%v)", p.Aids, err)
+		return
+	}
+	res = make(map[int64]*arcmdl.Arc, len(p.Aids))
+	for _, aid := range p.Aids {
+		if arc, ok := arcs.Arcs[aid]; ok && arc.IsNormal() {
+			res[aid] = arc
+		}
+	}
+	return
+}

app/admin/main/activity/service/archive_test.go

@@ -0,0 +1,21 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	lmdl "go-common/app/admin/main/activity/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Archives(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		res, err := s.Archives(context.Background(), &lmdl.ArchiveParam{Aids: []int64{10110582, 10110581}})
+		So(err, ShouldBeNil)
+		for _, v := range res {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}

app/admin/main/activity/service/kfc/BUILD

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["service.go"],
+    importpath = "go-common/app/admin/main/activity/service/kfc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/dao/kfc:go_default_library",
+        "//app/admin/main/activity/model/kfc:go_default_library",
+        "//library/log:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/activity/service/kfc/service.go

@@ -0,0 +1,40 @@
+package kfc
+
+import (
+	"context"
+
+	"go-common/app/admin/main/activity/conf"
+	kfcDao "go-common/app/admin/main/activity/dao/kfc"
+	kfcmdl "go-common/app/admin/main/activity/model/kfc"
+	"go-common/library/log"
+)
+
+// Service struct
+type Service struct {
+	c   *conf.Config
+	dao *kfcDao.Dao
+}
+
+// Close service
+func (s *Service) Close() {
+	if s.dao != nil {
+		s.dao.Close()
+	}
+}
+
+// New Service
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: kfcDao.New(c),
+	}
+	return
+}
+
+// List .
+func (s *Service) List(c context.Context, arg *kfcmdl.ListParams) (list []*kfcmdl.BnjKfcCoupon, err error) {
+	if list, err = s.dao.SearchList(c, arg.CouponCode, arg.Mid, arg.Pn, arg.Ps); err != nil {
+		log.Error("s.dao.SearchList(%v) error(%+v)", arg, err)
+	}
+	return
+}

app/admin/main/activity/service/likes.go

@@ -0,0 +1,606 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	"go-common/app/admin/main/activity/model"
+	tagmdl "go-common/app/interface/main/tag/model"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	acccli "go-common/app/service/main/account/api"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+	xtime "go-common/library/time"
+	"go-common/library/xstr"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_approved   = 1
+	_pending    = 0
+	_tagArcType = 3
+)
+
+// LikesList .
+func (s *Service) LikesList(c context.Context, arg *model.LikesParam) (outRes *model.LikesRes, err error) {
+	var (
+		likeSubject     *model.ActSubject
+		list            []*model.Like
+		likeList        map[int64]*model.Like
+		ids, wids, mids []int64
+		count           int64
+		offset          int
+	)
+	if likeSubject, err = s.dao.ActSubject(c, arg.Sid); err != nil {
+		return
+	}
+	db := s.DB
+	db = db.Where("sid = ?", likeSubject.ID)
+	if len(arg.States) > 0 {
+		db = db.Where("state in (?)", arg.States)
+	}
+	if arg.Mid > 0 {
+		db = db.Where("mid = ?", arg.Mid)
+	}
+	if arg.Wid > 0 {
+		db = db.Where("wid = ?", arg.Wid)
+	}
+	if err = db.Model(model.Like{}).Count(&count).Error; err != nil {
+		log.Error("db.Model(model.Like{}).Count() arg(%v) error(%v) ", arg, err)
+		return
+	}
+	offset = (arg.Page - 1) * arg.PageSize
+	if err = db.Offset(offset).Limit(arg.PageSize).Order("id asc").Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("db.Model(model.Like{}).Find() arg(%v) error(%v)", arg, err)
+		return
+	}
+	likeList = make(map[int64]*model.Like, len(list))
+	ids = make([]int64, 0, len(list))
+	wids = make([]int64, 0, len(list))
+	mids = make([]int64, 0, len(list))
+	for _, val := range list {
+		ids = append(ids, val.ID)
+		wids = append(wids, val.Wid)
+		mids = append(mids, val.Mid)
+		likeList[val.ID] = val
+		//like 根据最新的逻辑获取，现在无法获取 todo
+		likeList[val.ID].Like = 0
+	}
+	if len(list) > 0 {
+		if err = s.GetContent(c, likeSubject.Type, likeList, ids, wids, mids); err != nil {
+			log.Error("s.GetContent(%d,%v,%v,%v,%v) error(%v)", likeSubject.Type, likeList, ids, mids, wids, err)
+			return
+		}
+	}
+	outRes = &model.LikesRes{
+		Likes: likeList,
+	}
+	outRes.Size = arg.PageSize
+	outRes.Num = arg.Page
+	outRes.Total = count
+	return
+}
+
+// Likes .
+func (s *Service) Likes(c context.Context, Sid int64, lids []int64) (likeList map[int64]*model.Like, err error) {
+	var (
+		likeSubject     *model.ActSubject
+		like            []*model.Like
+		ids, wids, mids []int64
+	)
+	if likeSubject, err = s.dao.ActSubject(c, Sid); err != nil {
+		return
+	}
+	if err = s.DB.Where("id in (?)", lids).Find(&like).Error; err != nil {
+		log.Error("s.DB.Where(id in (%v)).Find() error(%v)", lids, err)
+		return
+	}
+	likeList = make(map[int64]*model.Like, len(like))
+	ids = make([]int64, 0, len(like))
+	wids = make([]int64, 0, len(like))
+	mids = make([]int64, 0, len(like))
+	for _, val := range like {
+		ids = append(ids, val.ID)
+		wids = append(wids, val.Wid)
+		mids = append(mids, val.Mid)
+		likeList[val.ID] = val
+		//like 根据最新的逻辑获取，现在无法获取 todo
+		likeList[val.ID].Like = 0
+	}
+	if len(like) > 0 {
+		if err = s.GetContent(c, likeSubject.Type, likeList, ids, wids, mids); err != nil {
+			log.Error("s.GetContent( %d, %v, %v, %v, %v) error(%v)", likeSubject.Type, likeList, ids, mids, wids, err)
+		}
+	}
+	return
+}
+
+// archiveWithTag get archives and tags.
+func (s *Service) archiveWithTag(c context.Context, aids []int64, likes map[int64]*model.Like) (err error) {
+	var (
+		archives       *arcmdl.ArcsReply
+		arcErr, tagErr error
+		tags           map[int64][]*tagmdl.Tag
+		ip             = metadata.String(c, metadata.RemoteIP)
+	)
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		if archives, arcErr = s.arcClient.Arcs(errCtx, &arcmdl.ArcsRequest{Aids: aids}); err != nil {
+			log.Error("s.arcClient.Arcs(%v, %s) error(%v)", aids, ip, err)
+			return arcErr
+		}
+		return nil
+	})
+	group.Go(func() error {
+		arg := &tagmdl.ArgResTags{Oids: aids, Type: _tagArcType, RealIP: ip}
+		if tags, tagErr = s.tagRPC.ResTags(errCtx, arg); tagErr != nil {
+			log.Error("ResTags接口错误 s.tag.ResTag(%+v) error(%v)", arg, tagErr)
+			return tagErr
+		}
+		return nil
+	})
+	if err = group.Wait(); err != nil {
+		return
+	}
+	for _, val := range likes {
+		if val.Wid != 0 {
+			tem := make(map[string]interface{}, 2)
+			if arch, ok := archives.Arcs[val.Wid]; ok && arch.IsNormal() {
+				tem["archives"] = arch
+			}
+			if tag, ok := tags[val.Wid]; ok {
+				temps := make([]string, 0, len(tag))
+				for _, val := range tag {
+					temps = append(temps, val.Name)
+				}
+				tem["tags"] = temps
+			}
+			val.Object = tem
+		}
+	}
+	return
+}
+
+// accountAndContent get likecontent and accountinfo .
+func (s *Service) accountAndContent(c context.Context, ids []int64, mids []int64, likes map[int64]*model.Like) (err error) {
+	var (
+		contents map[int64]*model.LikeContent
+		accRly   *acccli.CardsReply
+	)
+	if contents, err = s.dao.GetLikeContent(c, ids); err != nil {
+		log.Error(" s.dao.GetLikeContent(%v) error(%v)", ids, err)
+		return
+	}
+	if accRly, err = s.accClient.Cards3(c, &acccli.MidsReq{Mids: mids}); err != nil {
+		log.Error("s.AccountsInfo(%v) error(%v)", mids, err)
+		return
+	}
+	for _, val := range likes {
+		temp := make(map[string]interface{}, 2)
+		if cont, ok := contents[val.ID]; ok {
+			temp["content"] = cont
+		}
+		if val.Mid != 0 && accRly != nil {
+			if acct, ok := accRly.Cards[val.Mid]; ok {
+				temp["owner"] = map[string]interface{}{
+					"mid":   acct.Mid,
+					"name":  acct.Name,
+					"face":  acct.Face,
+					"sex":   acct.Sex,
+					"level": acct.Level,
+				}
+			}
+		}
+		val.Object = temp
+	}
+	return
+}
+
+// articles .
+func (s *Service) articles(c context.Context, wids []int64, likes map[int64]*model.Like) (err error) {
+	var artiRes map[int64]*artmdl.Meta
+	if artiRes, err = s.artRPC.ArticleMetas(c, &artmdl.ArgAids{Aids: wids}); err != nil {
+		log.Error("s.ArticleMetas(%v) error(%v)", wids, err)
+		return
+	}
+	for _, val := range likes {
+		if val.Wid != 0 {
+			if v, ok := artiRes[val.Wid]; ok {
+				val.Object = map[string]interface{}{
+					"article": v,
+				}
+			}
+		}
+	}
+	return
+}
+
+// musicsAndAct .
+func (s *Service) musicsAndAct(c context.Context, wids, mids []int64, likes map[int64]*model.Like) (err error) {
+	var (
+		musics *model.MusicRes
+		accRly *acccli.CardsReply
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	if musics, err = s.dao.Musics(c, wids, ip); err != nil {
+		log.Error("s.dao.Musics(%v) error(%+v)", wids, err)
+		return
+	}
+	if accRly, err = s.accClient.Cards3(c, &acccli.MidsReq{Mids: mids}); err != nil {
+		log.Error("s.AccountsInfo(%v) error(%v)", mids, err)
+		return
+	}
+	for _, val := range likes {
+		temp := make(map[string]interface{}, 2)
+		if v, ok := musics.Data[val.Wid]; ok {
+			temp["music"] = v
+		}
+		if val.Mid != 0 && accRly != nil {
+			if acct, ok := accRly.Cards[val.Mid]; ok {
+				temp["owner"] = map[string]interface{}{
+					"mid":   acct.Mid,
+					"name":  acct.Name,
+					"face":  acct.Face,
+					"sex":   acct.Sex,
+					"level": acct.Level,
+				}
+			}
+		}
+		val.Object = temp
+	}
+	return
+}
+
+// GetContent get act_subjet extensions .
+func (s *Service) GetContent(c context.Context, likeSubType int, likes map[int64]*model.Like, ids []int64, wids []int64, mids []int64) (err error) {
+	switch likeSubType {
+	case model.PICTURE, model.PICTURELIKE, model.DRAWYOO, model.DRAWYOOLIKE, model.TEXT, model.TEXTLIKE, model.QUESTION:
+		err = s.accountAndContent(c, ids, mids, likes)
+	case model.VIDEO, model.VIDEOLIKE, model.ONLINEVOTE, model.VIDEO2, model.PHONEVIDEO, model.SMALLVIDEO:
+		err = s.archiveWithTag(c, wids, likes)
+	case model.ARTICLE:
+		err = s.articles(c, wids, likes)
+	case model.MUSIC:
+		err = s.musicsAndAct(c, wids, mids, likes)
+	default:
+		err = ecode.RequestErr
+	}
+	return
+}
+
+// ItemUp .
+func (s *Service) ItemUp(c context.Context, sid, wid int64, state int) (likeList *model.Like, err error) {
+	var likeSubject *model.ActSubject
+	if likeSubject, err = s.dao.ActSubject(c, sid); err != nil {
+		log.Error("s.GetLikesSubjectByID(%d) error(%v)", sid, err)
+		return
+	}
+	likeList = new(model.Like)
+	if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Model(model.Like{}).Where(sid =? %d).Where(wid = ?, %d).Last(),error(%v)", likeSubject.ID, wid, err)
+		return
+	}
+	if likeList.ID == 0 {
+		err = nil
+		return
+	}
+	likeList.State = state
+	likeList.Mtime = xtime.Time(time.Now().Unix())
+	if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": state, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
+		log.Error("s.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
+	}
+	return
+}
+
+// ItemAdd .
+func (s *Service) ItemAdd(c context.Context, args *model.AddLikes) (likeList *model.Like, err error) {
+	var (
+		likeSubject *model.ActSubject
+		ip          = metadata.String(c, metadata.RemoteIP)
+	)
+	if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		log.Error(" s.GetLikesSubjectByID(%d) error(%v) ", args.Sid, err)
+		return
+	}
+	//怀疑原代码这里是个bug？？ todo
+	if args.Type != likeSubject.Type {
+		err = errors.New("ItemAdd params liketype error")
+		return
+	}
+	likeList = new(model.Like)
+	if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", args.Wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Model(model.Like{}).Where(sid =?, %d).Where(wid = ?, %d).Last() error(%v)", likeSubject.ID, args.Wid, err)
+		return
+	}
+	if err == gorm.ErrRecordNotFound {
+		addLike := &model.Like{
+			Type:  args.Type,
+			Wid:   args.Wid,
+			Sid:   likeSubject.ID,
+			Mid:   args.Mid,
+			State: args.State,
+		}
+		ipv6 := net.ParseIP(ip)
+		if ipv6 == nil {
+			ipv6 = []byte{}
+		}
+		addLikeContent := &model.LikeContent{
+			Plat:    args.Plat,
+			Device:  args.Device,
+			Message: "no",
+			Image:   "no",
+			IPv6:    ipv6,
+		}
+		tx := s.DB.Begin()
+		if err = tx.Create(addLike).Error; err != nil {
+			log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", addLike, err)
+			tx.Rollback()
+			return
+		}
+		addLikeContent.ID = addLike.ID
+		if err = tx.Create(addLikeContent).Error; err != nil {
+			log.Error("db.Model(&model.LikeContent{}).Create(%v) error(%v)\n", addLikeContent, err)
+			tx.Rollback()
+			return
+		}
+		tx.Commit()
+		likeList = addLike
+	} else {
+		likeList.State = args.State
+		likeList.Mtime = xtime.Time(time.Now().Unix())
+		if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": args.State, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
+			log.Error("s.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
+		}
+	}
+	return
+
+}
+
+// AddPicContent .
+func (s *Service) AddPicContent(c context.Context, args *model.AddPic) (likeID int64, err error) {
+	var (
+		likeSubject *model.ActSubject
+		ip          = metadata.String(c, metadata.RemoteIP)
+	)
+	if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		log.Error(" s.GetLikesSubjectByID(%d) error(%v) ", args.Sid, err)
+		return
+	}
+	likes := &model.Like{
+		Sid:   likeSubject.ID,
+		Wid:   args.Wid,
+		Type:  args.Type,
+		Mid:   args.Mid,
+		State: _pending,
+	}
+	ipv6 := net.ParseIP(ip)
+	if ipv6 == nil {
+		ipv6 = []byte{}
+	}
+	likeContent := &model.LikeContent{
+		IPv6:    ipv6,
+		Plat:    args.Plat,
+		Device:  args.Device,
+		Message: args.Message,
+		Link:    args.Link,
+		Image:   args.Image, //只支持传image串（需要支持传文件）todo
+	}
+	tx := s.DB.Begin()
+	if err = tx.Create(likes).Error; err != nil {
+		log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", likes, err)
+		tx.Rollback()
+		return
+	}
+	likeContent.ID = likes.ID
+	if err = tx.Create(likeContent).Error; err != nil {
+		log.Error("db.Model(&model.LikeContent{}).Create(%v) error(%v)\n", likeContent, err)
+		tx.Rollback()
+		return
+	}
+	tx.Commit()
+	likeID = likes.ID // need to update todo
+	return
+}
+
+// BatchLikes .
+func (s *Service) BatchLikes(c context.Context, args *model.BatchLike) (err error) {
+	var (
+		likes   []*model.Like
+		likeMap map[int64]*model.Like
+		addWid  []int64
+		ipv6    = net.ParseIP(metadata.String(c, metadata.RemoteIP))
+	)
+	if ipv6 == nil {
+		ipv6 = []byte{}
+	}
+	if err = s.DB.Where(fmt.Sprintf("sid = ? and wid in (%s)", xstr.JoinInts(args.Wid)), args.Sid).Find(&likes).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(%d,%v) error(%v)", args.Sid, args.Wid, err)
+		return
+	}
+	if err == gorm.ErrRecordNotFound {
+		addWid = args.Wid
+	} else {
+		likeMap = make(map[int64]*model.Like, len(likes))
+		for _, v := range likes {
+			likeMap[v.Wid] = v
+		}
+		addWid = make([]int64, 0, len(args.Wid))
+		for _, v := range args.Wid {
+			if _, ok := likeMap[v]; !ok {
+				addWid = append(addWid, v)
+			}
+		}
+	}
+	if len(addWid) == 0 {
+		return
+	}
+	item := &model.Like{
+		Sid:   args.Sid,
+		Mid:   args.Mid,
+		Type:  args.Type,
+		State: _pending,
+	}
+	if err = s.dao.BatchLike(c, item, addWid, ipv6); err != nil {
+		log.Error("s.dao.BatchLike(%v) error(%+v)", addWid, err)
+	}
+	return
+}
+
+// VideoAdd .
+func (s *Service) VideoAdd(c context.Context, args *model.AddLikes) (likeList *model.Like, err error) {
+	var (
+		likeSubject *model.ActSubject
+		ip          = metadata.String(c, metadata.RemoteIP)
+	)
+	if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		log.Error("s.dao.ActSubject(%d) error(%v) ", args.Sid, err)
+		return
+	}
+	if likeSubject.Type != model.VIDEO && likeSubject.Type != model.VIDEOLIKE && likeSubject.Type != model.VIDEO2 {
+		err = errors.New("VideoAdd params liketype error")
+		return
+	}
+	likeList = new(model.Like)
+	if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", args.Wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Model(&model.Like{}).Where(sid =?, %d).Where(wid = ?, %d).Last() error(%v)", likeSubject.ID, args.Wid, err)
+		return
+	}
+	if err == gorm.ErrRecordNotFound {
+		addLike := &model.Like{
+			Type:  args.Type,
+			Wid:   args.Wid,
+			Sid:   likeSubject.ID,
+			Mid:   args.Mid,
+			State: _approved,
+		}
+		ipv6 := net.ParseIP(ip)
+		if ipv6 == nil {
+			ipv6 = []byte{}
+		}
+		addLikeContent := &model.LikeContent{
+			IPv6:    ipv6,
+			Plat:    args.Plat,
+			Device:  args.Device,
+			Message: "no",
+			Image:   "no",
+		}
+		tx := s.DB.Begin()
+		if err = tx.Create(addLike).Error; err != nil {
+			log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", addLike, err)
+			tx.Rollback()
+			return
+		}
+		addLikeContent.ID = addLike.ID
+		if err = tx.Create(addLikeContent).Error; err != nil {
+			log.Error("tx.Model(&model.LikeContent{}).Create(%v) error(%v)", addLikeContent, err)
+			tx.Rollback()
+			return
+		}
+		tx.Commit()
+		likeList = addLike
+	} else {
+		likeList.State = _approved
+		likeList.Mtime = xtime.Time(time.Now().Unix())
+		if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": _approved, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
+			log.Error("ls.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
+		}
+	}
+	return
+}
+
+// UpLikesState .
+func (s *Service) UpLikesState(c context.Context, IDs []int64, state int, reply string, username string) (err error) {
+	if err = s.DB.Model(&model.Like{}).Where("id in (?)", xstr.JoinInts(IDs)).Update(map[string]interface{}{"state": state}).Error; err != nil {
+		log.Info("s.DB.Model(&model.Like{}).Where(id = ?,%d).Update() error(%v)", IDs, err)
+		return
+	}
+	if reply != "" {
+		s.DB.Model(&model.LikeContent{}).Where("id in (?)", xstr.JoinInts(IDs)).Update(map[string]interface{}{"reply": reply})
+	}
+	if state != 0 {
+		for _, v := range IDs {
+			likeLog := &model.ActLikeLog{
+				Lid:   v,
+				User:  username,
+				State: int64(state),
+			}
+			s.DB.Create(likeLog)
+		}
+	}
+	return
+}
+
+// UpLike .
+func (s *Service) UpLike(c context.Context, args *model.UpLike, username string) (res int64, err error) {
+	likes := map[string]interface{}{
+		"Type":     args.Type,
+		"Mid":      args.Mid,
+		"Wid":      args.Wid,
+		"State":    args.State,
+		"StickTop": args.StickTop,
+	}
+	if err = s.DB.Model(model.Like{}).Where("id = ?", args.Lid).Update(likes).Error; err != nil {
+		log.Error("s.DB.Model(model.Like{}).Where(id = ?, %d).Update() error(%v)", args.Lid, err)
+		return
+	}
+	likeContent := map[string]interface{}{
+		"Message": args.Message,
+		"Reply":   args.Reply,
+		"Link":    args.Link,
+		"Image":   args.Image,
+	}
+	if err = s.DB.Model(model.LikeContent{}).Where("id = ?", args.Lid).Update(likeContent).Error; err != nil {
+		log.Error("s.DB.Model(model.LikeContent{}).Where(id = ?,%d).Update() error(%v)", args.Lid, err)
+		return
+	}
+	if args.State != 0 {
+		likeLog := &model.ActLikeLog{
+			Lid:   args.Lid,
+			User:  username,
+			State: int64(args.State),
+		}
+		s.DB.Create(likeLog)
+	}
+	res = args.Lid
+	return
+}
+
+// AddLike .
+func (s *Service) AddLike(c context.Context, args *model.AddLikes) (likesRes *model.Like, err error) {
+	switch args.DealType {
+	case "itemUp":
+		likesRes, err = s.ItemUp(c, args.Sid, args.Wid, args.State)
+	case "itemAdd":
+		likesRes, err = s.ItemAdd(c, args)
+	case "videoAdd":
+		likesRes, err = s.VideoAdd(c, args)
+	default:
+		err = errors.New("type error")
+	}
+	return
+}
+
+// UpWid .
+func (s *Service) UpWid(c context.Context, args *model.UpWid) (err error) {
+	var (
+		subject *model.ActSubject
+	)
+	if subject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		return
+	}
+	like := map[string]interface{}{
+		"state": args.State,
+		"mtime": xtime.Time(time.Now().Unix()),
+	}
+	if err := s.DB.Model(&model.Like{}).Where("sid = ? and wid = ?", subject.ID, args.Wid).Update(like).Limit(1).Error; err != nil {
+		log.Error("actSrv.DB.Where(sid = %d and wid = %d).Update().Limit(1) error(%v)", subject.ID, args.Wid, err)
+	}
+	return
+}

app/admin/main/activity/service/likes_test.go

@@ -0,0 +1,53 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/admin/main/activity/model"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_LikesByLid(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.LikesList(context.Background(), &model.LikesParam{Sid: 10256, PageSize: 10, Page: 1, Mid: 155551800, States: []int{0, 1}})
+		So(err, ShouldBeEmpty)
+		for _, v := range res.Likes {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}
+
+func TestService_Likes(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.Likes(context.Background(), 10256, []int64{1185, 1256})
+		So(err, ShouldBeEmpty)
+		for _, v := range res {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}
+
+func TestService_UpLike(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.AddLike(context.Background(), &model.AddLikes{DealType: "videoAdd", Sid: 10206, Wid: 10210488, Mid: 88895364, Device: 11, Plat: 12, State: 1, Type: 12})
+		So(err, ShouldBeEmpty)
+		fmt.Printf("%+v", res)
+	}))
+}
+
+func TestService_UpLikeContents(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.UpLike(context.Background(), &model.UpLike{Lid: 13557, Type: 13, State: 1, Message: "ii", Reply: "nono", Image: "jj", Link: "like", Mid: 12345, Wid: 12367, StickTop: 1}, "ly")
+		So(err, ShouldBeEmpty)
+		fmt.Printf("%+v", res)
+	}))
+}
+
+func TestService_BatchLikes(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		err := s.BatchLikes(context.Background(), &model.BatchLike{Sid: 10299, Type: 13, Mid: 12345, Wid: []int64{1, 4, 5, 6, 7}})
+		So(err, ShouldBeEmpty)
+	}))
+}

app/admin/main/activity/service/service.go

@@ -0,0 +1,56 @@
+package service
+
+import (
+	"context"
+	"go-common/app/admin/main/activity/conf"
+	"go-common/app/admin/main/activity/dao"
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+	artrpc "go-common/app/interface/openplatform/article/rpc/client"
+	acccli "go-common/app/service/main/account/api"
+	arcclient "go-common/app/service/main/archive/api"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Service biz service def.
+type Service struct {
+	c         *conf.Config
+	dao       *dao.Dao
+	DB        *gorm.DB
+	accClient acccli.AccountClient
+	tagRPC    *tagrpc.Service
+	artRPC    *artrpc.Service
+	arcClient arcclient.ArchiveClient
+}
+
+// New new a Service and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:      c,
+		dao:    dao.New(c),
+		tagRPC: tagrpc.New2(c.TagRPC),
+		artRPC: artrpc.New(c.ArticlrRPC),
+	}
+	s.DB = s.dao.DB
+	var err error
+	if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil {
+		panic(err)
+	}
+	if s.accClient, err = acccli.NewClient(c.AccClient); err != nil {
+		panic(err)
+	}
+	return s
+}
+
+// Ping check dao health.
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Wait wait all closed.
+func (s *Service) Wait() {}
+
+// Close close all dao.
+func (s *Service) Close() {
+	s.dao.Close()
+}

app/admin/main/activity/service/service_test.go

@@ -0,0 +1,36 @@
+package service
+
+import (
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/activity/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var svr *Service
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/activity-admin-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	svr = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		Reset(func() {})
+		f(svr)
+	}
+}
+
+func Test_Service(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		s.Wait()
+		s.Close()
+	}))
+}

app/admin/main/activity/service/subject.go

@@ -0,0 +1,307 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/activity/model"
+	articlemodel "go-common/app/interface/openplatform/article/model"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/jinzhu/gorm"
+)
+
+// GetArticleMetas from rpc .
+func (s *Service) GetArticleMetas(c context.Context, aids []int64) (res map[int64]*articlemodel.Meta, err error) {
+	if res, err = s.artRPC.ArticleMetas(c, &articlemodel.ArgAids{Aids: aids}); err != nil {
+		log.Error("s.ArticleMetas(%v) error(%v)", aids, err)
+	}
+	return
+}
+
+// SubjectList get subject list .
+func (s *Service) SubjectList(c context.Context, listParams *model.ListSub) (listRes *model.SubListRes, err error) {
+	var (
+		count int64
+		list  []*model.ActSubject
+	)
+	db := s.DB
+	if listParams.Keyword != "" {
+		names := listParams.Keyword + "%"
+		db = db.Where("`id` = ? or `name` like ? or `author` like ?", listParams.Keyword, names, names)
+	}
+	if listParams.Sctime != 0 {
+		parseScime := time.Unix(listParams.Sctime, 0)
+		db = db.Where("ctime >= ?", parseScime.Format("2006-01-02 15:04:05"))
+	}
+	if listParams.Ectime != 0 {
+		parseEcime := time.Unix(listParams.Ectime, 0)
+		db = db.Where("etime <= ?", parseEcime.Format("2006-01-02 15:04:05"))
+	}
+	if len(listParams.States) > 0 {
+		db = db.Where("state in (?)", listParams.States)
+	}
+	if len(listParams.Types) > 0 {
+		db = db.Where("type in (?)", listParams.Types)
+	}
+	if err = db.Offset((listParams.Page - 1) * listParams.PageSize).Limit(listParams.PageSize).Order("id desc").Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error(" db.Model(&model.ActSubject{}).Find() args(%v) error(%v)", listParams, err)
+		return
+	}
+	if err = db.Model(&model.ActSubject{}).Count(&count).Error; err != nil {
+		log.Error("db.Model(&model.ActSubject{}).Count() args(%v) error(%v)", listParams, err)
+		return
+	}
+	listRes = &model.SubListRes{
+		List: list,
+		Page: &model.PageRes{
+			Num:   listParams.Page,
+			Size:  listParams.PageSize,
+			Total: count,
+		},
+	}
+	return
+}
+
+// VideoList .
+func (s *Service) VideoList(c context.Context) (res []*model.ActSubjectResult, err error) {
+	var (
+		types    = []int{1, 4}
+		list     []*model.ActSubject
+		likeList []*model.Like
+	)
+	db := s.DB
+	if err = db.Where("state = ?", 1).Where("type in (?)", types).Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("db.Model(&model.ActSubject{}).Where(state = ?, 1).Where(type in (?), %v).Find() error(%v)", types, err)
+		return
+	}
+	listCount := len(list)
+	if listCount == 0 {
+		return
+	}
+	sids := make([]int64, 0, listCount)
+	for _, value := range list {
+		sids = append(sids, value.ID)
+	}
+	if err = db.Where("sid in (?)", sids).Where("wid > ?", 0).Find(&likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("db.Model(&model.Like{}).Where(sid in (?), %v).Find() error(%v)", sids, err)
+		return
+	}
+	hashList := make(map[int64][]int64)
+	for _, value := range likeList {
+		hashList[value.Sid] = append(hashList[value.Sid], value.Wid)
+	}
+	res = make([]*model.ActSubjectResult, 0, len(list))
+	for _, value := range list {
+		rs := &model.ActSubjectResult{
+			ActSubject: value,
+		}
+		if v, ok := hashList[value.ID]; ok {
+			rs.Aids = v
+		}
+		res = append(res, rs)
+	}
+	return
+}
+
+// AddActSubject .
+func (s *Service) AddActSubject(c context.Context, params *model.AddList) (res int64, err error) {
+	if params.ScreenSet != 2 {
+		params.ScreenSet = 1
+	}
+	protect := &model.ActSubjectProtocol{
+		Protocol:  params.Protocol,
+		Types:     params.Types,
+		Pubtime:   params.Pubtime,
+		Deltime:   params.Deltime,
+		Editime:   params.Editime,
+		Tags:      params.Tags,
+		Hot:       params.Hot,
+		BgmID:     params.BgmID,
+		Oids:      params.Oids,
+		ScreenSet: params.ScreenSet,
+		PasterID:  params.PasterID,
+	}
+	actTime := &model.ActTimeConfig{
+		Interval: params.Interval,
+		Tlimit:   params.Tlimit,
+		Ltime:    params.Ltime,
+	}
+	if params.Tags != "" {
+		if err = s.dao.AddTags(c, params.Tags, metadata.String(c, metadata.RemoteIP)); err != nil {
+			log.Error("s.AddTags(%s,) error(%v)", params.Tags, err)
+			return
+		}
+	}
+	actSub := &model.ActSubject{
+		Oid:        params.ActSubject.Oid,
+		Type:       params.ActSubject.Type,
+		State:      params.ActSubject.State,
+		Level:      params.ActSubject.Level,
+		Flag:       params.ActSubject.Flag,
+		Rank:       params.ActSubject.Rank,
+		Stime:      params.ActSubject.Stime,
+		Etime:      params.ActSubject.Etime,
+		Lstime:     params.ActSubject.Lstime,
+		Letime:     params.ActSubject.Letime,
+		Uetime:     params.ActSubject.Uetime,
+		Ustime:     params.ActSubject.Ustime,
+		Name:       params.ActSubject.Name,
+		Author:     params.ActSubject.Author,
+		ActURL:     params.ActSubject.ActURL,
+		Cover:      params.ActSubject.Cover,
+		Dic:        params.ActSubject.Dic,
+		H5Cover:    params.ActSubject.H5Cover,
+		LikeLimit:  params.ActSubject.LikeLimit,
+		AndroidURL: params.ActSubject.AndroidURL,
+		IosURL:     params.ActSubject.IosURL,
+	}
+	if err = s.DB.Create(actSub).Error; err != nil {
+		log.Error("s.DB.Create(%v) error(%v)", actSub, err)
+		return
+	}
+	protect.Sid = actSub.ID
+	if err = s.DB.Create(protect).Error; err != nil {
+		log.Error("s.DB.Create(%v) error(%v)", protect, err)
+		return
+	}
+	if params.Type == model.ONLINEVOTE {
+		actTime.Sid = actSub.ID
+		if err = s.DB.Create(actTime).Error; err != nil {
+			log.Error("s.DB.Create(%v) error(%v)", actTime, err)
+			return
+		}
+	}
+	res = actSub.ID
+	return
+}
+
+// UpActSubject .
+func (s *Service) UpActSubject(c context.Context, params *model.AddList, sid int64) (res int64, err error) {
+	if params.ScreenSet != 2 {
+		params.ScreenSet = 1
+	}
+	onlineData := &model.ActTimeConfig{
+		Interval: params.Interval,
+		Tlimit:   params.Tlimit,
+		Ltime:    params.Ltime,
+	}
+	actSubject := new(model.ActSubject)
+	if err = s.DB.Where("id = ?", sid).Last(actSubject).Error; err != nil {
+		log.Error("s.DB.Where(id = ?, %d).Last(%v) error(%v)", sid, actSubject, err)
+		return
+	}
+	data := map[string]interface{}{
+		"Oid":        params.Oid,
+		"Type":       params.Type,
+		"State":      params.State,
+		"Level":      params.Level,
+		"Flag":       params.Flag,
+		"Rank":       params.Rank,
+		"Stime":      params.Stime,
+		"Etime":      params.Etime,
+		"Lstime":     params.Lstime,
+		"Uetime":     params.Uetime,
+		"Ustime":     params.Ustime,
+		"Name":       params.Name,
+		"Author":     params.Author,
+		"ActURL":     params.ActURL,
+		"Cover":      params.Cover,
+		"Dic":        params.Dic,
+		"H5Cover":    params.H5Cover,
+		"LikeLimit":  params.LikeLimit,
+		"AndroidURL": params.AndroidURL,
+		"IosURL":     params.IosURL,
+	}
+	if err = s.DB.Model(&model.ActSubject{}).Where("id = ?", sid).Update(data).Error; err != nil {
+		log.Error("s.DB.Model(&model.ActSubject{}).Where(id = ?, %d).Update(%v) error(%v)", sid, data, err)
+		return
+	}
+	item := new(model.ActSubjectProtocol)
+	if err = s.DB.Where("sid = ? ", sid).Last(item).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(sid = ? , %d).Last(%v) error(%v)", sid, item, err)
+		return
+	}
+	//item有值
+	if item.ID > 0 {
+		if params.Tags != "" {
+			if item.Tags != params.Tags {
+				if err = s.dao.AddTags(c, params.Tags, metadata.String(c, metadata.RemoteIP)); err != nil {
+					log.Error("s.AddTags(%s) error(%v)", params.Tags, err)
+					return
+				}
+			}
+		}
+		upProtectData := map[string]interface{}{
+			"Protocol":  params.Protocol,
+			"Types":     params.Types,
+			"Pubtime":   params.Pubtime,
+			"Deltime":   params.Deltime,
+			"Editime":   params.Editime,
+			"Hot":       params.Hot,
+			"BgmID":     params.BgmID,
+			"Oids":      params.Oids,
+			"ScreenSet": params.ScreenSet,
+			"PasterID":  params.PasterID,
+			"Tags":      params.Tags,
+		}
+		if err = s.DB.Model(&model.ActSubjectProtocol{}).Where("id = ?", item.ID).Update(upProtectData).Error; err != nil {
+			log.Error("s.DB.Model(&model.ActSubjectProtocol{}).Where(id = ?, %d).Update(%v) error(%v)", item.ID, upProtectData, err)
+			return
+		}
+	} else {
+		protectDtata := &model.ActSubjectProtocol{
+			Protocol:  params.Protocol,
+			Types:     params.Types,
+			Pubtime:   params.Pubtime,
+			Deltime:   params.Deltime,
+			Editime:   params.Editime,
+			Hot:       params.Hot,
+			BgmID:     params.BgmID,
+			Oids:      params.Oids,
+			ScreenSet: params.ScreenSet,
+			PasterID:  params.PasterID,
+			Sid:       sid,
+		}
+		if err = s.DB.Create(protectDtata).Error; err != nil {
+			log.Error("s.DB.Create(%v) error(%v)", protectDtata, err)
+			return
+		}
+	}
+	if actSubject.Type == model.ONLINEVOTE {
+		onlineData.Sid = sid
+		output := new(model.ActTimeConfig)
+		if err = s.DB.Where("sid = ?", sid).Last(output).Error; err != nil && err != gorm.ErrRecordNotFound {
+			log.Error("s.DB.Where(sid = ?, %d).Last(%v) error(%v)", sid, output, err)
+			return
+		}
+		if output.ID > 0 {
+			if err = s.DB.Model(&model.ActTimeConfig{}).Where("id = ?", output.ID).Update(onlineData).Error; err != nil {
+				log.Error("s.DB.Model(&model.ActTimeConfig{}).Where(id = ?, %d).Update(%v) error(%v)", output.ID, onlineData, err)
+				return
+			}
+		}
+
+	}
+	res = sid
+	return
+}
+
+// SubProtocol .
+func (s *Service) SubProtocol(c context.Context, sid int64) (res *model.ActSubjectProtocol, err error) {
+	res = &model.ActSubjectProtocol{}
+	if err = s.DB.Where("sid = ?", sid).First(res).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(sid = %d ) error(%v)", sid, err)
+	}
+	return
+}
+
+// TimeConf .
+func (s *Service) TimeConf(c context.Context, sid int64) (res *model.ActTimeConfig, err error) {
+	res = new(model.ActTimeConfig)
+	if err = s.DB.Where("sid = ?", sid).First(res).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("actSrv.DB.Where(sid = ?, %d) error(%v)", sid, err)
+	}
+	return
+}

app/admin/main/activity/service/subject_test.go

@@ -0,0 +1,166 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go-common/app/admin/main/activity/model"
+
+	xtime "go-common/library/time"
+
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_SubjectList(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		p := &model.ListSub{
+			Page:     1,
+			PageSize: 15,
+			Keyword:  "layang123",
+			States:   []int{1},
+			Types:    []int{18},
+			Sctime:   1534835169,
+			Ectime:   1546272001,
+		}
+		list, err := s.SubjectList(context.Background(), p)
+		So(err, ShouldBeNil)
+		for _, v := range list.List {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}
+
+func TestService_VideoList(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		list, err := s.VideoList(context.Background())
+		So(err, ShouldBeNil)
+		for _, v := range list {
+			fmt.Printf("%+v  %+v", v.ActSubject, v.Aids)
+		}
+	}))
+}
+
+func TestService_AddActSubject(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		p := &model.AddList{
+			ActSubject: model.ActSubject{
+				Oid:        11,
+				Type:       9,
+				State:      1,
+				Level:      5,
+				Rank:       100,
+				Stime:      xtime.Time(time.Now().Unix()),
+				Etime:      xtime.Time(time.Now().Unix()),
+				Ctime:      xtime.Time(time.Now().Unix()),
+				Mtime:      xtime.Time(time.Now().Unix()),
+				Lstime:     xtime.Time(time.Now().Unix()),
+				Letime:     xtime.Time(time.Now().Unix()),
+				Uetime:     xtime.Time(time.Now().Unix()),
+				Ustime:     xtime.Time(time.Now().Unix()),
+				Name:       "test one",
+				Author:     "layang",
+				ActURL:     "http://www.baidu.com/",
+				Cover:      "cover",
+				Flag:       128,
+				Dic:        "dif",
+				H5Cover:    "H5Cover",
+				LikeLimit:  5,
+				AndroidURL: "AndroidURL",
+				IosURL:     "IosURL",
+			},
+			Protocol:  "Protocol",
+			Types:     "1,2,3",
+			Pubtime:   xtime.Time(time.Now().Unix()),
+			Deltime:   xtime.Time(time.Now().Unix()),
+			Editime:   xtime.Time(time.Now().Unix()),
+			Tags:      "由三",
+			Interval:  1,
+			Tlimit:    123,
+			Ltime:     124,
+			Hot:       1,
+			BgmID:     3,
+			PasterID:  4,
+			Oids:      "5,7,8",
+			ScreenSet: 1,
+		}
+		res, err := s.AddActSubject(context.Background(), p)
+		So(err, ShouldBeNil)
+		fmt.Printf("%d", res)
+	}))
+}
+
+func TestService_UpActSubject(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		p := &model.AddList{
+			ActSubject: model.ActSubject{
+				Oid:        12,
+				Type:       9,
+				State:      0,
+				Level:      6,
+				Rank:       101,
+				Stime:      xtime.Time(time.Now().Unix()),
+				Etime:      xtime.Time(time.Now().Unix()),
+				Ctime:      xtime.Time(time.Now().Unix()),
+				Mtime:      xtime.Time(time.Now().Unix()),
+				Lstime:     xtime.Time(time.Now().Unix()),
+				Letime:     xtime.Time(time.Now().Unix()),
+				Uetime:     xtime.Time(time.Now().Unix()),
+				Ustime:     xtime.Time(time.Now().Unix()),
+				Name:       "test two",
+				Author:     "layang2",
+				ActURL:     "http://www.baidu.com/2",
+				Cover:      "cover2",
+				Flag:       129,
+				Dic:        "dif2",
+				H5Cover:    "H5Cover2",
+				LikeLimit:  6,
+				AndroidURL: "AndroidURL2",
+				IosURL:     "IosURL2",
+			},
+			Protocol:  "Protocol2",
+			Types:     "1,2,3,4",
+			Pubtime:   xtime.Time(time.Now().Unix()),
+			Deltime:   xtime.Time(time.Now().Unix()),
+			Editime:   xtime.Time(time.Now().Unix()),
+			Tags:      "由三2",
+			Interval:  2,
+			Tlimit:    124,
+			Ltime:     125,
+			Hot:       0,
+			BgmID:     4,
+			PasterID:  8,
+			Oids:      "5,7,8.9",
+			ScreenSet: 2,
+		}
+		res, err := s.UpActSubject(context.Background(), p, 10298)
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", res)
+	}))
+}
+
+func TestService_SubProtocol(t *testing.T) {
+	Convey("sub protovol ", t, WithService(func(s *Service) {
+		list, err := s.SubProtocol(context.Background(), 10256)
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", list)
+	}))
+}
+
+func TestService_TimeConf(t *testing.T) {
+	Convey("sub TimeConf ", t, WithService(func(s *Service) {
+		list, err := s.TimeConf(context.Background(), 10298)
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", list)
+	}))
+}
+
+func TestService_GetArticleMetas(t *testing.T) {
+	Convey("sub TimeConf ", t, WithService(func(s *Service) {
+		list, err := s.GetArticleMetas(context.Background(), []int64{1412})
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", list)
+	}))
+}

app/admin/main/aegis/BUILD

@@ -0,0 +1,22 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/aegis/cmd:all-srcs",
+        "//app/admin/main/aegis/conf:all-srcs",
+        "//app/admin/main/aegis/dao:all-srcs",
+        "//app/admin/main/aegis/model:all-srcs",
+        "//app/admin/main/aegis/server/databus:all-srcs",
+        "//app/admin/main/aegis/server/http:all-srcs",
+        "//app/admin/main/aegis/service:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/aegis/CHANGELOG.md

@@ -0,0 +1,100 @@
+#v 1.2.1
+1. 任务操作数据统计
+
+#v 1.2.0
+1. 监控平台迁移，添加了监控数据接口
+
+#v 1.1.5
+1. 梳理错误日志
+- 92015错误不抛出，只在tips提示
+- 资源列表检索默认不展示刚下发的任务，避免重复审核
+- 业务回调接口，http错误不重试
+- next接口未登入时，自动登入
+2. 修复任务列表panic
+
+#v 1.1.4
+1. resource和task的databus分开
+2. 业务回调错误将详细信息返回前端
+
+#v 1.1.3
+1. up-service rpc更新
+
+#v 1.1.2
+1. 提供databus导入资源方式
+2. 修复指派任务导致领取不到
+3. 修复不必要参数为空报错
+4. 常规任务不包含停滞任务
+
+#v 1.1.1
+1. 搜索改v3 sdk
+
+#v 1.1.0
+1. v2版本，对接单话审核
+2. 流程网加缓存
+
+#v 1.0.12
+1. 进出审量报表
+2. 去掉多余的任务日志,报错信息
+3. 列表批量高亮，限制长度3000，并改为并发请求
+4. account使用grpc
+
+#v 1.0.11
+1. 避免91025错误，任务下发前根据flowid检查是否需要审核
+
+#v 1.0.10
+1. 新增role/flush接口，方便角色变化时进行刷新
+2. 提交时更新搜索，查列表时验证状态
+3. middelware
+
+#v 1.0.9
+1. 修复周期权重配置的去重逻辑
+2. 修复orm事务错误
+3. 已被处理的任务延迟时进行提示
+4. 资源提交错误先默认重试3次
+5. 任务统计不展示空进出审
+
+# v1.0.8
+1. fix资源日志多出3个数字索引的情况，改为字符串索引
+2. 新增操作日志查询接口
+3. 审核日志添加cancel
+
+# v1.0.7
+1. 对应上rider版本号
+
+# v1.0.6
+1. 任务抢占分布式锁，可重试3次
+2. 补充任务详情信息，使用errorgroup
+3. 审核日志增加资源添加日志
+4. hash tag改为 businessid-flowid
+5. 添加初始态配置，给任务创建时做判断
+6. 先默认一个资源只在一个flow下分发，解决目前存在flow状态与task状态不同步
+
+# v1.0.5
+1. 资源提交时实时按照rid,flow_id搜索未完成任务，不能用提交的task_id搜索
+
+# v1.0.4
+1. fix bug 已取消过后的资源重新add，需要更新state为正常状态
+2. 先事务提交，才创建任务流转信息
+3. 有权限的任务为空时，不返回403
+4. 使用graphviz dot和viz.js绘制流程图
+
+# v1.0.3
+1. 日志过滤null的打回理由和备注
+2. 批量操作报错友好一点
+
+# v1.0.2
+1. 支持灰度策略or，策略多字段and逻辑
+
+# v1.0.1
+1. 修复属性位错误
+2. 任务报表flow_id改为非必传
+3. 业务注册加权限点 AEGIS_REGISTER
+4. 修复提交错误时，任务缓存释放
+5. 批量打回添加理由和通知
+6. 非管理员可查看和操作资源审核列表
+7. public key使用hash tag
+8. 修复领任务死循环
+
+# v1.0.0
+1. 上线功能xxx
+

app/admin/main/aegis/CONTRIBUTORS.md

@@ -0,0 +1,14 @@
+# Owner
+shencen
+wangzhe01
+
+# Author
+shencen
+chenxuefeng
+chenxi01
+
+
+# Reviewer
+shencen
+chenxuefeng
+chenxi01

app/admin/main/aegis/OWNERS

@@ -0,0 +1,17 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- chenxi01
+- chenxuefeng
+- shencen
+- wangzhe01
+labels:
+- admin
+- admin/main/aegis
+- main
+options:
+  no_parent_owners: true
+reviewers:
+- chenxi01
+- chenxuefeng
+- shencen

app/admin/main/aegis/README.md

@@ -0,0 +1,12 @@
+# aegis-admin
+
+# 项目简介
+宙斯盾审核平台
+
+# 编译环境
+
+
+# 依赖包
+
+
+# 编译执行

app/admin/main/aegis/api/http/api.md

@@ -0,0 +1 @@
+# HTTP API文档

app/admin/main/aegis/cmd/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["aegis-admin.toml"],
+    importpath = "go-common/app/admin/main/aegis/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/aegis/conf:go_default_library",
+        "//app/admin/main/aegis/server/http:go_default_library",
+        "//app/admin/main/aegis/service:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/queue/databus/report:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/aegis/cmd/aegis-admin.toml

@@ -0,0 +1,201 @@
+debug = "local"
+bucket = "archive"
+admin = "481"
+[consumer]
+    onexp = 600
+    roleexp = 86400
+[gray]
+    [[gray.biz]]
+    businessID = 1
+    [[gray.biz.options]]
+        [[gray.biz.options.fields]]
+        name = "OID"
+        value = "oid1,oid3"
+    [[gray.biz.options]]
+        [[gray.biz.options.fields]]
+        name = "MID"
+        value = "1,2"
+    [[gray.biz.options]]
+        [[gray.biz.options.fields]]
+        name = "Extra2"
+        value = "3,4"
+        [[gray.biz.options.fields]]
+        name = "OID"
+        value = "oid6"
+
+[auditstate]
+    1 = "1,2"
+    2 = "3,4"
+
+[log]
+    dir="/data/log/aegis"
+
+[app]
+    key = "c1a1cb2d89c33794"
+    secret = "dda47eeca111e03e6845017505baea13"
+
+[orm]
+    dsn = "test:test@tcp(127.0.0.1:3306)/bilibili_aegis?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    active = 5
+    idle = 5
+    idleTimeout = "4h"
+
+[mysql]
+	addr = "aegis"
+	dsn = "test:test@tcp(127.0.0.1:3306)/bilibili_aegis?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    readDSN = ["test:test@tcp(127.0.0.1:3306)/bilibili_aegis?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"]
+	active = 20
+	idle = 10
+	idleTimeout ="4h"
+	queryTimeout = "100ms"
+	execTimeout = "100ms"
+	tranTimeout = "200ms"
+
+[redis]
+    netExpire = "30m"
+    [redis.cluster]
+	    name = "aegis-admin"
+	    proto = "tcp"
+	    addr = "127.0.0.1:6379"
+	    idle = 10
+	    active = 10
+	    dialTimeout = "100ms"
+	    readTimeout = "100s"
+	    writeTimeout = "100ms"
+	    idleTimeout = "10s"
+	    expire = "1m"
+
+[memcache]
+	name = "aegis-admin"
+	proto = "tcp"
+	addr = "127.0.0.1:11211"
+	active = 50
+	idle = 10
+	dialTimeout = "1s"
+	readTimeout = "1s"
+	writeTimeout = "1s"
+	idleTimeout = "10s"
+	expire = "24h"
+
+[bm]
+    addr = "0.0.0.0:8000"
+    maxListen = 10
+    timeout = "1s"
+
+[auth]
+    managerHost = "http://uat-manager.bilibili.co"
+    dashboardHost = "http://dashboard-mng.bilibili.co"
+    dashboardCaller = "manager-go"
+    [auth.DsHTTPClient]
+    key = "manager-go"
+    secret = "949bbb2dd3178252638c2407578bc7ad"
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    [auth.DsHTTPClient.breaker]
+    window  = "3s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+    [auth.MaHTTPClient]
+    key = "f6433799dbd88751"
+    secret = "36f8ddb1806207fe07013ab6a77a3935"
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    [auth.MaHTTPClient.breaker]
+    window  = "3s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+    [auth.session]
+    sessionIDLength = 32
+    cookieLifeTime = 1800
+    cookieName = "mng-go"
+    domain = ".bilibili.co"
+    [auth.session.Memcache]
+    name = "go-business/auth"
+    proto = "unix"
+    addr = "/tmp/uat-manager-auth-mc.sock"
+    active = 10
+    idle = 5
+    dialTimeout = "1s"
+    readTimeout = "1s"
+    writeTimeout = "1s"
+    idleTimeout = "80s"
+
+[rpc]
+    [rpc.acc]
+	[rpc.up]
+	[rpc.rel]
+
+[host]
+    api = "http://uat-api.bilibili.co"
+    manager = "http://uat-manager.bilibili.co"
+
+[httpClient]
+    [httpClient.read]
+    key = "b8f239ca38a53308"
+    secret = "5460ef72fe13c10dfb53442b9111427e"
+    dial = "80ms"
+    timeout = "800ms"
+    keepAlive = "60s"
+    [httpClient.read.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+    [httpClient.write]
+    key = "b8f239ca38a53308"
+    secret = "5460ef72fe13c10dfb53442b9111427e"
+    dial = "50ms"
+    timeout = "1s"
+    keepAlive = "60s"
+    [httpClient.write.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+    [httpClient.es]
+    key = "b8f239ca38a53308"
+    secret = "5460ef72fe13c10dfb53442b9111427e"
+    dial = "1s"
+    timeout = "2s"
+    keepAlive = "60s"
+    [httpClient.es.breaker]
+    window  = "10s"
+    sleep   = "1000ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[aegisPub]
+    key = "0PtMsLLxWyyvoTgAyLCD"
+    secret = "0PtMsLLxWyyvoTgAyLCE"
+    group = "Aegis-P"
+    topic = "Aegis"
+    action = "pub"
+    name = "aegis-admin/databus"
+    proto = "tcp"
+    addr = "172.16.33.158:6205"
+    active = 1
+    idle = 1
+    dialTimeout = "1s"
+    readTimeout = "1s"
+    writeTimeout = "1s"
+    idleTimeout = "10s"
+
+[bfs]
+    key    = "ef42d94858dd49b2"
+    secret = "351c300573a330a5271226835be496"
+    host   = "http://uat-bfs.bilibili.co"
+    timeout = 1000
+    maxFileSize = 5242880
+
+[grpc]
+    [accRPC]
+        timeout = "1s"

app/admin/main/aegis/cmd/main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"go-common/app/admin/main/aegis/conf"
+	"go-common/app/admin/main/aegis/server/http"
+	"go-common/app/admin/main/aegis/service"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	"go-common/library/net/trace"
+	"go-common/library/queue/databus/report"
+)
+
+func main() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	log.Init(conf.Conf.Log)
+	defer log.Close()
+	log.Info("aegis-admin start")
+
+	if conf.Conf.Debug != "local" {
+		trace.Init(nil)
+		defer trace.Close()
+		ecode.Init(nil)
+	}
+
+	// report init
+	report.InitManager(nil)
+	svc := service.New(conf.Conf)
+	http.Init(conf.Conf, svc)
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
+	for {
+		s := <-c
+		log.Info("get a signal %s", s.String())
+		switch s {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+			svc.Close()
+			log.Info("aegis-admin exit")
+			time.Sleep(time.Second)
+			return
+		case syscall.SIGHUP:
+		default:
+			return
+		}
+	}
+}

app/admin/main/aegis/conf/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["conf.go"],
+    importpath = "go-common/app/admin/main/aegis/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/conf:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/BurntSushi/toml:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/aegis/conf/conf.go

@@ -0,0 +1,185 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/conf"
+	"go-common/library/database/orm"
+	"go-common/library/database/sql"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+	"go-common/library/net/http/blademaster/middleware/verify"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/warden"
+	"go-common/library/net/trace"
+	"go-common/library/queue/databus"
+	xtime "go-common/library/time"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	confPath string
+	client   *conf.Client
+	// Conf config
+	Conf = &Config{}
+)
+
+// Config .
+type Config struct {
+	Log      *log.Config
+	BM       *bm.ServerConfig
+	Verify   *verify.Config
+	Auth     *permit.Config
+	Tracer   *trace.Config
+	Redis    *Redis
+	Memcache *memcache.Config
+
+	Ecode *ecode.Config
+	RPC   *RPC
+	Host  *Host
+	// http client test
+	HTTPClient HTTPClient
+	// ORM
+	ORM      *orm.Config
+	MySQL    *sql.Config
+	AegisPub *databus.Config
+	Bfs      *Bfs
+
+	Bucket   string
+	Debug    string
+	Admin    string // 所有业务的管理员
+	Consumer *Consumer
+	Gray     *Gray
+
+	Auditstate map[string]string
+
+	GRPC *GRPC
+}
+
+//GRPC .
+type GRPC struct {
+	AccRPC *warden.ClientConfig
+	UpRPC  *warden.ClientConfig
+}
+
+// Gray .
+type Gray struct {
+	Biz []graybiz
+}
+
+type graybiz struct {
+	BusinessID int64
+	Options    []grayoption
+}
+
+type grayoption struct {
+	Fields []struct {
+		Name  string
+		Value string
+	}
+}
+
+// Consumer 在线过期时间，角色过期时间
+type Consumer struct {
+	OnExp   int32
+	RoleExp int32
+}
+
+// Bfs reprensents the bfs config
+type Bfs struct {
+	Key         string
+	Secret      string
+	Host        string
+	Timeout     int
+	MaxFileSize int
+}
+
+// Host host config .
+type Host struct {
+	API        string
+	Manager    string
+	MainSearch string
+}
+
+// Redis .
+type Redis struct {
+	NetExpire xtime.Duration
+	Cluster   *redis.Config
+}
+
+// HTTPClient str
+type HTTPClient struct {
+	Read  *bm.ClientConfig
+	Write *bm.ClientConfig
+	Es    *bm.ClientConfig
+}
+
+//DB .
+type DB struct {
+	Aegis *sql.Config
+	MySQL *sql.Config
+}
+
+// RPC .
+type RPC struct {
+	Acc *rpc.ClientConfig
+	Rel *rpc.ClientConfig
+	Up  *rpc.ClientConfig
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default config path")
+}
+
+// Init init conf
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}
+
+func local() (err error) {
+	_, err = toml.DecodeFile(confPath, &Conf)
+	return
+}
+
+func remote() (err error) {
+	if client, err = conf.New(); err != nil {
+		return
+	}
+	if err = load(); err != nil {
+		return
+	}
+	go func() {
+		for range client.Event() {
+			log.Info("config reload")
+			if load() != nil {
+				log.Error("config reload error (%v)", err)
+			}
+		}
+	}()
+	return
+}
+
+func load() (err error) {
+	var (
+		s       string
+		ok      bool
+		tmpConf *Config
+	)
+	if s, ok = client.Toml2(); !ok {
+		return errors.New("load config center error")
+	}
+	if _, err = toml.Decode(s, &tmpConf); err != nil {
+		return errors.New("could not decode config")
+	}
+	*Conf = *tmpConf
+	return
+}

app/admin/main/aegis/dao/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/aegis/dao/gorm:all-srcs",
+        "//app/admin/main/aegis/dao/http:all-srcs",
+        "//app/admin/main/aegis/dao/mc:all-srcs",
+        "//app/admin/main/aegis/dao/mysql:all-srcs",
+        "//app/admin/main/aegis/dao/redis:all-srcs",
+        "//app/admin/main/aegis/dao/rpc:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/aegis/dao/gorm/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 = [
+        "business_config_test.go",
+        "business_test.go",
+        "common_test.go",
+        "dao_test.go",
+        "direction_test.go",
+        "flow_resource_test.go",
+        "flow_test.go",
+        "net_test.go",
+        "report_test.go",
+        "resource_test.go",
+        "task_config_test.go",
+        "task_test.go",
+        "token_test.go",
+        "transition_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/aegis/conf:go_default_library",
+        "//app/admin/main/aegis/model/business:go_default_library",
+        "//app/admin/main/aegis/model/common:go_default_library",
+        "//app/admin/main/aegis/model/net:go_default_library",
+        "//app/admin/main/aegis/model/resource:go_default_library",
+        "//app/admin/main/aegis/model/task:go_default_library",
+        "//library/ecode:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "business.go",
+        "business_config.go",
+        "common.go",
+        "dao.go",
+        "direction.go",
+        "flow.go",
+        "flow_resource.go",
+        "net.go",
+        "report.go",
+        "resource.go",
+        "task.go",
+        "task_config.go",
+        "token.go",
+        "transition.go",
+    ],
+    importpath = "go-common/app/admin/main/aegis/dao/gorm",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/aegis/conf:go_default_library",
+        "//app/admin/main/aegis/model:go_default_library",
+        "//app/admin/main/aegis/model/business:go_default_library",
+        "//app/admin/main/aegis/model/net:go_default_library",
+        "//app/admin/main/aegis/model/resource:go_default_library",
+        "//app/admin/main/aegis/model/task:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/aegis/dao/gorm/business.go

@@ -0,0 +1,66 @@
+package gorm
+
+import (
+	"context"
+
+	"go-common/app/admin/main/aegis/model/business"
+
+	"github.com/jinzhu/gorm"
+)
+
+// AddBusiness .
+func (d *Dao) AddBusiness(c context.Context, e *business.Business) (id int64, err error) {
+	err = d.orm.Table("business").Create(&e).Error
+	id = e.ID
+	return
+}
+
+// UpdateBusiness .
+func (d *Dao) UpdateBusiness(c context.Context, e *business.Business) (err error) {
+	return d.orm.Table("business").Where("id = ?", e.ID).Update(map[string]interface{}{
+		"name":      e.Name,
+		"desc":      e.Desc,
+		"developer": e.Developer,
+	}).Error
+}
+
+// EnableBusiness .
+func (d *Dao) EnableBusiness(c context.Context, id int64) (err error) {
+	return d.orm.Table("business").Where("id = ?", id).Update(map[string]interface{}{
+		"state": business.StateEnable,
+	}).Error
+}
+
+// DisableBusiness .
+func (d *Dao) DisableBusiness(c context.Context, id int64) (err error) {
+	return d.orm.Table("business").Where("id = ?", id).Update(map[string]interface{}{
+		"state": business.StateDisable,
+	}).Error
+}
+
+// Business .
+func (d *Dao) Business(c context.Context, id int64) (res *business.Business, err error) {
+	res = &business.Business{}
+	if err = d.orm.Where("id = ?", id).First(&res).Error; err == gorm.ErrRecordNotFound {
+		res = nil
+		err = nil
+	}
+	return
+}
+
+// BusinessList .
+func (d *Dao) BusinessList(c context.Context, tp int8, ids []int64, onlyEnable bool) (res []*business.Business, err error) {
+	res = []*business.Business{}
+	db := d.orm
+	if len(ids) > 0 {
+		db = db.Where("id in (?)", ids)
+	}
+	if onlyEnable {
+		db = db.Where("state=?", business.StateEnable)
+	}
+	if tp > 0 {
+		db = db.Where("type = ?", tp)
+	}
+	err = db.Find(&res).Error
+	return
+}

app/admin/main/aegis/dao/gorm/business_config.go

@@ -0,0 +1,68 @@
+package gorm
+
+import (
+	"context"
+	"database/sql"
+
+	"go-common/app/admin/main/aegis/model/business"
+	"go-common/library/log"
+)
+
+// GetConfigs .
+func (d *Dao) GetConfigs(c context.Context, bizid int64) (cfgs []*business.BizCFG, err error) {
+	if err = d.orm.Table("business_config").Where("business_id=? AND state=0", bizid).Scan(&cfgs).Error; err != nil {
+		log.Error("GetURL error(%v)", err)
+	}
+	return
+}
+
+// GetConfig .
+func (d *Dao) GetConfig(c context.Context, bizid int64, tp int8) (config string, err error) {
+	if err = d.orm.Table("business_config").Select("`config`").
+		Where("business_id=? AND type=? AND state=0", bizid, tp).
+		Order("mtime DESC").Limit(1).
+		Row().Scan(&config); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			return
+		}
+		log.Error("GetConfig error(%v)", err)
+		return
+	}
+	return
+}
+
+// ActiveConfigs 所有任务配置
+func (d *Dao) ActiveConfigs(c context.Context) (configs []*business.BizCFG, err error) {
+	configs = []*business.BizCFG{}
+	if err = d.orm.Where("state=0").Find(&configs).Error; err != nil {
+		log.Error("ActiveConfigs find error(%v)", err)
+	}
+	return
+}
+
+// AddBizConfig 每个业务每种配置只有一条
+func (d *Dao) AddBizConfig(c context.Context, cfg *business.BizCFG) (lastid int64, err error) {
+	if err = d.orm.Table("business_config").Where("business_id=? AND `type`=?", cfg.BusinessID, cfg.TP).
+		Assign(map[string]interface{}{
+			"config": cfg.Config,
+			"state":  cfg.State,
+		}).FirstOrCreate(cfg).Error; err != nil {
+		log.Error("AddBizConfig error(%v)", err)
+	}
+
+	lastid = cfg.ID
+	return
+}
+
+// EditBizConfig .
+func (d *Dao) EditBizConfig(c context.Context, cfg *business.BizCFG) (err error) {
+	if err = d.orm.Table("business_config").Where("id=?", cfg.ID).
+		Update(map[string]interface{}{
+			"config": cfg.Config,
+			"state":  cfg.State,
+		}).Error; err != nil {
+		log.Error("EditBizConfig error(%v)", err)
+	}
+	return
+}

app/admin/main/aegis/dao/gorm/business_config_test.go

@@ -0,0 +1,94 @@
+package gorm
+
+import (
+	"context"
+	"go-common/app/admin/main/aegis/model/business"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestGormGetConfigs(t *testing.T) {
+	convey.Convey("GetConfigs", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			bizid = int64(1)
+		)
+		ctx.Convey("success", func(ctx convey.C) {
+			cfgs, err := d.GetConfigs(c, bizid)
+			ctx.Convey("Then err should be nil.cfgs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(cfgs, convey.ShouldNotBeNil)
+			})
+		})
+		ctx.Convey("empty", func(ctx convey.C) {
+			_, err := d.GetConfigs(c, -1)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormGetConfig(t *testing.T) {
+	convey.Convey("GetConfig", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			bizid = int64(0)
+			tp    = int8(-1)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			config, err := d.GetConfig(c, bizid, tp)
+			ctx.Convey("Then err should be nil.config should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(config, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestGormActiveConfigs(t *testing.T) {
+	convey.Convey("ActiveConfigs", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			configs, err := d.ActiveConfigs(c)
+			ctx.Convey("Then err should be nil.configs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(configs, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestGormAddBizConfig(t *testing.T) {
+	convey.Convey("AddBizConfig", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			cfg = &business.BizCFG{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			lastid, err := d.AddBizConfig(c, cfg)
+			ctx.Convey("Then err should be nil.lastid should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(lastid, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestGormEditBizConfig(t *testing.T) {
+	convey.Convey("EditBizConfig", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			cfg = &business.BizCFG{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.EditBizConfig(c, cfg)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/business_test.go

@@ -0,0 +1,80 @@
+package gorm
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/aegis/model/business"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestEnableBusiness(t *testing.T) {
+	convey.Convey("EnableBusiness", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.EnableBusiness(c, 0)
+			ctx.Convey("Then err should be nil.cfgs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDisableBusiness(t *testing.T) {
+	convey.Convey("DisableBusiness", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.DisableBusiness(c, 0)
+			ctx.Convey("Then err should be nil.cfgs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestBusiness(t *testing.T) {
+	convey.Convey("Business", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.Business(c, 0)
+			ctx.Convey("Then err should be nil.cfgs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestBusinessList(t *testing.T) {
+	convey.Convey("BusinessList", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.BusinessList(c, 1, []int64{0}, true)
+			ctx.Convey("Then err should be nil.cfgs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestUpdateBusiness(t *testing.T) {
+	convey.Convey("UpdateBusiness", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.UpdateBusiness(c, &business.Business{})
+			ctx.Convey("Then err should be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/common.go

@@ -0,0 +1,106 @@
+package gorm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/log"
+)
+
+// Available .
+func Available(db *gorm.DB) *gorm.DB {
+	return db.Where("disable_time = '0000-00-00 00:00:00'")
+}
+
+// Disable .
+func Disable(db *gorm.DB) *gorm.DB {
+	return db.Not("disable_time = '0000-00-00 00:00:00'")
+}
+
+func state(state string) func(db *gorm.DB) *gorm.DB {
+	state = strings.TrimSpace(state)
+	if state == net.StateAvailable {
+		return func(db *gorm.DB) *gorm.DB {
+			return Available(db)
+		}
+	} else if state == net.StateDisable {
+		return func(db *gorm.DB) *gorm.DB {
+			return Disable(db)
+		}
+	} else {
+		return func(db *gorm.DB) *gorm.DB {
+			return db
+		}
+	}
+}
+
+func pager(ps int64, pn int64, sort string) func(db *gorm.DB) *gorm.DB {
+	offset := ps * (pn - 1)
+	order := fmt.Sprintf("id %s", sort)
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Limit(ps).Offset(offset).Order(order)
+	}
+}
+
+// UpdateFields .
+func (d *Dao) UpdateFields(c context.Context, db *gorm.DB, table string, id int64, fields map[string]interface{}) (err error) {
+	if db == nil {
+		db = d.orm
+	}
+	if err = db.Table(table).Where("id=?", id).Updates(fields).Error; err != nil {
+		log.Error("UpdateFlow(%s,%d) error(%v) changed(%+v)", table, id, err, fields)
+	}
+	return
+}
+
+// AddItem .
+func (d *Dao) AddItem(c context.Context, db *gorm.DB, n interface{}) (err error) {
+	if db == nil {
+		db = d.orm
+	}
+	if err = db.Create(n).Error; err != nil {
+		log.Error("AddItem error(%v) (%+v)", err, n)
+	}
+	return
+}
+
+// ColumnMapString .
+func (d *Dao) ColumnMapString(c context.Context, table string, column string, ids []int64, where string) (result map[int64]string, err error) {
+	var (
+		rows  *sql.Rows
+		id    int64
+		value string
+		slt   = fmt.Sprintf("`id`,`%s`", column)
+	)
+
+	result = map[int64]string{}
+	db := d.orm.Table(table).Select(slt).Where("id in (?)", ids)
+	where = strings.TrimSpace(where)
+	if where != "" {
+		db = db.Where(where)
+	}
+	rows, err = db.Rows()
+	if err == sql.ErrNoRows {
+		err = nil
+		return
+	}
+	if err != nil {
+		log.Error("ColumnMapString(%s, %s) rows error(%v) ids(%v)", table, column, err, ids)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		if err = rows.Scan(&id, &value); err != nil {
+			log.Error("ColumnMapString(%s, %s) rows.scan error(%v) ids(%v)", table, column, err, ids)
+			return
+		}
+		result[id] = value
+	}
+
+	return
+}

app/admin/main/aegis/dao/gorm/common_test.go

@@ -0,0 +1,61 @@
+package gorm
+
+import (
+	"testing"
+
+	"github.com/jinzhu/gorm"
+	"github.com/smartystreets/goconvey/convey"
+	"go-common/app/admin/main/aegis/model/net"
+)
+
+func TestDaoAvailable(t *testing.T) {
+	var (
+		db = &gorm.DB{}
+	)
+	convey.Convey("Available", t, func(ctx convey.C) {
+		p1 := Available(db)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoDisable(t *testing.T) {
+	var (
+		db = &gorm.DB{}
+	)
+	convey.Convey("Disable", t, func(ctx convey.C) {
+		p1 := Disable(db)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaostatePager(t *testing.T) {
+	var (
+		s1 = ""
+	)
+	convey.Convey("state", t, func(ctx convey.C) {
+		p1 := state(s1)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDao_ColumnMapString(t *testing.T) {
+	var (
+		table  = net.TableFlow
+		column = "ch_name"
+		ids    = []int64{1, 2, 3}
+	)
+
+	convey.Convey("ColumnMapString", t, func(ctx convey.C) {
+		result, err := d.ColumnMapString(cntx, table, column, ids, "")
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+		t.Logf("result(%+v)", result)
+	})
+}

app/admin/main/aegis/dao/gorm/dao.go

@@ -0,0 +1,47 @@
+package gorm
+
+import (
+	"context"
+
+	"go-common/app/admin/main/aegis/conf"
+	"go-common/library/database/orm"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Dao dao
+type Dao struct {
+	c   *conf.Config
+	orm *gorm.DB
+}
+
+// New init mysql orm
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:   c,
+		orm: orm.NewMySQL(c.ORM),
+	}
+	dao.orm.LogMode(true)
+
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.orm.Close()
+}
+
+// BeginTx .
+func (d *Dao) BeginTx(c context.Context) (tx *gorm.DB, err error) {
+	tx = d.orm.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("orm begin tx error(%v)", err)
+	}
+	return
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	return d.orm.DB().PingContext(c)
+}

app/admin/main/aegis/dao/gorm/dao_test.go

@@ -0,0 +1,50 @@
+package gorm
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/aegis/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d    *Dao
+	cntx context.Context
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.aegis-admin")
+		flag.Set("conf_token", "cad913269be022e1eb8c45a8d5408d78")
+		flag.Set("tree_id", "60977")
+		flag.Set("conf_version", "1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/aegis-admin.toml")
+	}
+
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	cntx = context.Background()
+	os.Exit(m.Run())
+}
+
+func TestDaoPing(t *testing.T) {
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.Ping(context.TODO())
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/direction.go

@@ -0,0 +1,122 @@
+package gorm
+
+import (
+	"context"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// DirectionByFlowID .
+func (d *Dao) DirectionByFlowID(c context.Context, flowID []int64, direction int8) (dirs []*net.Direction, err error) {
+	dirs = []*net.Direction{}
+	db := d.orm.Where("flow_id in (?)", flowID)
+	if direction == net.DirInput || direction == net.DirOutput {
+		db = db.Where("direction=?", direction)
+	}
+	err = db.Scopes(Available).Find(&dirs).Error
+	if err != nil {
+		log.Error("DirectionByFlowID find error(%v) flowid(%v) direction(%d)", err, flowID, direction)
+	}
+	return
+}
+
+// DirectionByTransitionID .
+func (d *Dao) DirectionByTransitionID(c context.Context, transitionID []int64, direction int8, onlyAvailable bool) (dirs []*net.Direction, err error) {
+	dirs = []*net.Direction{}
+	db := d.orm.Where("transition_id in (?)", transitionID)
+	if direction == net.DirInput || direction == net.DirOutput {
+		db = db.Where("direction=?", direction)
+	}
+	if onlyAvailable {
+		db = db.Scopes(Available)
+	}
+	err = db.Find(&dirs).Error
+	if err != nil {
+		log.Error("DirectionByTransitionID find error(%v) transitionid(%v) direction(%d)", err, transitionID, direction)
+	}
+	return
+}
+
+// DirectionByID .
+func (d *Dao) DirectionByID(c context.Context, id int64) (n *net.Direction, err error) {
+	n = &net.Direction{}
+	err = d.orm.Where("id=?", id).First(n).Error
+	if err == gorm.ErrRecordNotFound {
+		err = ecode.NothingFound
+		return
+	}
+	if err != nil {
+		log.Error("DirectionByID(%+v) error(%v)", id, err)
+	}
+
+	return
+}
+
+func (d *Dao) Directions(c context.Context, ids []int64) (n []*net.Direction, err error) {
+	n = []*net.Direction{}
+	if err = d.orm.Where("id in (?)", ids).Find(&n).Error; err != nil {
+		log.Error("Directions error(%v) ids(%v)", err, ids)
+	}
+
+	return
+}
+
+// DirectionList .
+func (d *Dao) DirectionList(c context.Context, pm *net.ListDirectionParam) (result *net.ListDirectionRes, err error) {
+	result = &net.ListDirectionRes{
+		Pager: net.Pager{
+			Num:  pm.Pn,
+			Size: pm.Ps,
+		},
+	}
+	db := d.orm.Table(net.TableDirection).Where("net_id=?", pm.NetID)
+	if len(pm.ID) > 0 {
+		db = db.Where("id in (?)", pm.ID)
+	}
+	if pm.FlowID > 0 {
+		db = db.Where("flow_id=?", pm.FlowID)
+	}
+	if pm.TransitionID > 0 {
+		db = db.Where("transition_id=?", pm.TransitionID)
+	}
+	if pm.Direction == net.DirInput || pm.Direction == net.DirOutput {
+		db = db.Where("direction=?", pm.Direction)
+	}
+
+	err = db.Scopes(state(pm.State)).Count(&result.Pager.Total).Scopes(pager(pm.Ps, pm.Pn, pm.Sort)).Find(&result.Result).Error
+	if err != nil {
+		log.Error("DirectionList find error(%v) params(%+v)", err, pm)
+	}
+	return
+}
+
+// DirectionByUnique .
+func (d *Dao) DirectionByUnique(c context.Context, netID int64, flowID int64, transitionID int64, direction int8) (t *net.Direction, err error) {
+	t = &net.Direction{}
+	err = d.orm.Where("net_id=? AND flow_id=? AND transition_id=? AND direction=?", netID, flowID, transitionID, direction).
+		First(t).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+		t = nil
+		return
+	}
+	if err != nil {
+		log.Error("DirectionByUnique(%d,%d,%d,%d) error(%v)", netID, flowID, transitionID, direction, err)
+	}
+
+	return
+}
+
+// DirectionByNet .
+func (d *Dao) DirectionByNet(c context.Context, netID int64) (n []*net.Direction, err error) {
+	n = []*net.Direction{}
+	err = d.orm.Where("net_id=?", netID).Scopes(Available).Find(&n).Error
+	if err != nil {
+		log.Error("DirectionByNet(%d) error(%v)", netID, err)
+	}
+
+	return
+}

app/admin/main/aegis/dao/gorm/direction_test.go

@@ -0,0 +1,89 @@
+package gorm
+
+import (
+	"testing"
+
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/ecode"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoDirectionByTransitionID(t *testing.T) {
+	convey.Convey("DirectionByTransitionID", t, func(ctx convey.C) {
+		_, err := d.DirectionByTransitionID(cntx, []int64{}, 1, true)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDirectionByID(t *testing.T) {
+	convey.Convey("DirectionByID", t, func(ctx convey.C) {
+		_, err := d.DirectionByID(cntx, -1)
+		ctx.Convey("Then err should be 404", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.NothingFound)
+		})
+	})
+}
+
+func TestDaoDirectionList(t *testing.T) {
+	var (
+		pm = &net.ListDirectionParam{
+			NetID:        1,
+			Ps:           20,
+			ID:           []int64{1},
+			FlowID:       1,
+			TransitionID: 1,
+			Direction:    1,
+		}
+	)
+	convey.Convey("DirectionList", t, func(ctx convey.C) {
+		result, err := d.DirectionList(cntx, pm)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+
+			t.Logf("list result(%+v)", result)
+			for _, dir := range result.Result {
+				t.Logf("bylist dir(%+v)", dir)
+			}
+		})
+	})
+}
+
+func TestDaoDirectionByUnique(t *testing.T) {
+	convey.Convey("DirectionByUnique", t, func(ctx convey.C) {
+		_, err := d.DirectionByUnique(cntx, 0, 0, 0, 0)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDirectionByFlowID(t *testing.T) {
+	convey.Convey("DirectionByFlowID", t, func(ctx convey.C) {
+		_, err := d.DirectionByFlowID(cntx, []int64{}, 1)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDirectionByNet(t *testing.T) {
+	convey.Convey("DirectionByNet", t, func(ctx convey.C) {
+		_, err := d.DirectionByNet(cntx, 0)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDirections(t *testing.T) {
+	convey.Convey("Directions", t, func(ctx convey.C) {
+		_, err := d.Directions(cntx, []int64{0})
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/flow.go

@@ -0,0 +1,105 @@
+package gorm
+
+import (
+	"context"
+	"strings"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// FlowByID .
+func (d *Dao) FlowByID(c context.Context, id int64) (f *net.Flow, err error) {
+	f = &net.Flow{}
+	err = d.orm.Where("id=?", id).First(f).Error
+	if err == gorm.ErrRecordNotFound {
+		err = ecode.AegisFlowNotFound
+		return
+	}
+	if err != nil {
+		log.Error("FlowByID(%+v) error(%v)", id, err)
+	}
+	return
+}
+
+// FlowList .
+func (d *Dao) FlowList(c context.Context, pm *net.ListNetElementParam) (result *net.ListFlowRes, err error) {
+	result = &net.ListFlowRes{
+		Pager: net.Pager{
+			Num:  pm.Pn,
+			Size: pm.Ps,
+		},
+	}
+
+	db := d.orm.Table(net.TableFlow).Where("net_id=?", pm.NetID)
+	if len(pm.ID) > 0 {
+		db = db.Where("id in (?)", pm.ID)
+	}
+	pm.Name = strings.TrimSpace(pm.Name)
+	if pm.Name != "" {
+		db = db.Where("name=?", pm.Name)
+	}
+
+	err = db.Scopes(state(pm.State)).Count(&result.Pager.Total).Scopes(pager(pm.Ps, pm.Pn, pm.Sort)).Find(&result.Result).Error
+	if err != nil {
+		log.Error("FlowList find error(%v) params(%+v)", err, pm)
+	}
+	return
+}
+
+// FlowByUnique .
+func (d *Dao) FlowByUnique(c context.Context, netID int64, name string) (f *net.Flow, err error) {
+	f = &net.Flow{}
+	err = d.orm.Where("net_id=? AND name=?", netID, name).First(f).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+		f = nil
+		return
+	}
+	if err != nil {
+		log.Error("FlowByUnique(%d,%s) error(%v)", netID, name, err)
+	}
+	return
+}
+
+// Flows .
+func (d *Dao) Flows(c context.Context, ids []int64) (fs []*net.Flow, err error) {
+	fs = []*net.Flow{}
+	err = d.orm.Where("id in (?)", ids).Find(&fs).Error
+	if err != nil {
+		log.Error("Flows(%v) error(%v)", ids, err)
+	}
+
+	return
+}
+
+// FlowsByNet .
+func (d *Dao) FlowsByNet(c context.Context, netID []int64) (fs []*net.Flow, err error) {
+	fs = []*net.Flow{}
+	err = d.orm.Scopes(Available).Where("net_id in (?)", netID).Order("id ASC").Find(&fs).Error
+	if err != nil {
+		log.Error("Flows(%d) error(%v)", netID, err)
+	}
+	return
+}
+
+func (d *Dao) FlowIDByNet(c context.Context, nid []int64) (res map[int64][]int64, err error) {
+	res = map[int64][]int64{}
+	listi := []struct {
+		ID    int64 `gorm:"column:id"`
+		NetID int64 `gorm:"column:net_id"`
+	}{}
+
+	if err = d.orm.Table(net.TableFlow).Select("id,net_id").
+		Where("net_id in (?)", nid).Scopes(Available).Scan(&listi).Error; err != nil {
+		log.Error("FlowIDByNet error(%v) nid(%v)", err, nid)
+		return
+	}
+
+	for _, item := range listi {
+		res[item.NetID] = append(res[item.NetID], item.ID)
+	}
+	return
+}

app/admin/main/aegis/dao/gorm/flow_resource.go

@@ -0,0 +1,70 @@
+package gorm
+
+import (
+	"context"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/log"
+)
+
+// FRByFlow .
+func (d *Dao) FRByFlow(c context.Context, flowID []int64) (fr *net.FlowResource, err error) {
+	fr = &net.FlowResource{}
+	if err = d.orm.Where("flow_id in (?)", flowID).First(fr).Error; err == gorm.ErrRecordNotFound {
+		fr = nil
+		err = nil
+		return
+	}
+
+	if err != nil {
+		log.Error("FRByFlow error(%v) flowid(%v)", err, flowID)
+	}
+	return
+}
+
+// FRByNetRID .
+func (d *Dao) FRByNetRID(c context.Context, netID []int64, rids []int64, onlyRunning bool) (frs []*net.FlowResource, err error) {
+	frs = []*net.FlowResource{}
+	db := d.orm.Where("rid in (?) AND net_id in (?)", rids, netID)
+	if onlyRunning {
+		db = db.Scopes(running)
+	}
+	if err = db.Find(&frs).Error; err != nil {
+		log.Error("FRByNetRID error(%v) netid(%v) rids(%v)", err, netID, rids)
+	}
+	return
+}
+
+// FRByUniques .
+func (d *Dao) FRByUniques(c context.Context, rids []int64, flowID []int64, onlyRunning bool) (frs []*net.FlowResource, err error) {
+	frs = []*net.FlowResource{}
+	db := d.orm
+	if len(rids) > 0 {
+		db = db.Where("rid in (?)", rids)
+	}
+	if len(flowID) > 0 {
+		db = db.Where("flow_id in (?)", flowID)
+	}
+	if onlyRunning {
+		db = db.Scopes(running)
+	}
+	if err = db.Find(&frs).Error; err != nil {
+		log.Error("FRByUniques error(%v) rids(%+v) flowid(%d)", err, rids, flowID)
+	}
+
+	return
+}
+
+// CancelFlowResource .
+func (d *Dao) CancelFlowResource(c context.Context, tx *gorm.DB, rids []int64) (err error) {
+	fields := map[string]interface{}{"state": net.FRStateDeleted}
+	if err = tx.Table(net.TableFlowResource).Where("rid in (?)", rids).Updates(fields).Error; err != nil {
+		log.Error("CancelFlowResource error(%v) rids(%+v)", err, rids)
+	}
+	return
+}
+
+func running(db *gorm.DB) *gorm.DB {
+	return db.Where("state!=?", net.FRStateDeleted)
+}

app/admin/main/aegis/dao/gorm/flow_resource_test.go

@@ -0,0 +1,45 @@
+package gorm
+
+import (
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoFRByFlow(t *testing.T) {
+	convey.Convey("FRByFlow", t, func(ctx convey.C) {
+		_, err := d.FRByFlow(cntx, []int64{})
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoFRByNetRID(t *testing.T) {
+	convey.Convey("FRByNetRID", t, func(ctx convey.C) {
+		_, err := d.FRByNetRID(cntx, []int64{}, []int64{}, false)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoFRByUniques(t *testing.T) {
+	convey.Convey("FRByUniques", t, func(ctx convey.C) {
+		_, err := d.FRByUniques(cntx, []int64{1}, []int64{1}, true)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoCancelFlowResource(t *testing.T) {
+	tx, _ := d.BeginTx(cntx)
+	defer tx.Commit()
+	convey.Convey("CancelFlowResource", t, func(ctx convey.C) {
+		err := d.CancelFlowResource(cntx, tx, []int64{})
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/flow_test.go

@@ -0,0 +1,73 @@
+package gorm
+
+import (
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	"go-common/app/admin/main/aegis/model/net"
+)
+
+func TestDaoFlowByID(t *testing.T) {
+	convey.Convey("FlowByID", t, func(ctx convey.C) {
+		_, err := d.FlowByID(cntx, 1)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoFlowList(t *testing.T) {
+	var (
+		pm = &net.ListNetElementParam{
+			NetID: 1,
+			State: net.StateAvailable,
+			Ps:    5,
+			Pn:    2,
+			ID:    []int64{1},
+			Name:  "name",
+		}
+	)
+	convey.Convey("FlowList", t, func(ctx convey.C) {
+		result, err := d.FlowList(cntx, pm)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoFlowByUnique(t *testing.T) {
+	convey.Convey("FlowByUnique", t, func(ctx convey.C) {
+		_, err := d.FlowByUnique(cntx, 0, "")
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoFlowsByNet(t *testing.T) {
+	convey.Convey("FlowsByNet", t, func(ctx convey.C) {
+		_, err := d.FlowsByNet(cntx, []int64{})
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoFlows(t *testing.T) {
+	convey.Convey("Flows", t, func(ctx convey.C) {
+		_, err := d.Flows(cntx, []int64{})
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoFlowIDByNet(t *testing.T) {
+	convey.Convey("FlowIDByNet", t, func(ctx convey.C) {
+		_, err := d.FlowIDByNet(cntx, []int64{})
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/net.go

@@ -0,0 +1,120 @@
+package gorm
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+// NetByID .
+func (d *Dao) NetByID(c context.Context, id int64) (n *net.Net, err error) {
+	n = &net.Net{}
+	err = d.orm.Where("id=?", id).First(n).Error
+	if err == gorm.ErrRecordNotFound {
+		err = ecode.NothingFound
+		return
+	}
+	if err != nil {
+		log.Error("NetByID(%+v) error(%v)", id, err)
+	}
+	return
+}
+
+func (d *Dao) Nets(c context.Context, ids []int64) (n []*net.Net, err error) {
+	n = []*net.Net{}
+	if err = d.orm.Where("id in (?)", ids).Find(&n).Error; err != nil {
+		log.Error("Nets error(%v) ids(%v)", err, ids)
+	}
+	return
+}
+
+// NetByUnique .
+func (d *Dao) NetByUnique(c context.Context, name string) (n *net.Net, err error) {
+	n = &net.Net{}
+	err = d.orm.Where("ch_name=?", name).First(n).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+		n = nil
+		return
+	}
+	if err != nil {
+		log.Error("NetByUnique(%+v) error(%v)", name, err)
+	}
+	return
+}
+
+// NetList .
+func (d *Dao) NetList(c context.Context, pm *net.ListNetParam) (result *net.ListNetRes, err error) {
+	result = &net.ListNetRes{
+		Pager: net.Pager{
+			Num:  pm.Pn,
+			Size: pm.Ps,
+		},
+	}
+	db := d.orm.Table(net.TableNet)
+	if len(pm.ID) > 0 {
+		db = db.Where("id in (?)", pm.ID)
+	}
+	if pm.BusinessID > 0 {
+		db = db.Where("business_id=?", pm.BusinessID)
+	}
+	err = db.Scopes(state(pm.State)).Count(&result.Pager.Total).Scopes(pager(pm.Ps, pm.Pn, pm.Sort)).Find(&result.Result).Error
+	if err != nil {
+		log.Error("NetList find error(%v) params(%+v)", err, pm)
+	}
+	return
+}
+
+// NetBindStartFlow .
+func (d *Dao) NetBindStartFlow(c context.Context, tx *gorm.DB, id int64, flowID int64) (err error) {
+	if err = d.UpdateFields(c, tx, net.TableNet, id, map[string]interface{}{"start_flow_id": flowID}); err != nil {
+		log.Error("NetBindStartFlow d.UpdateFields error(%v) id(%d) flowid(%d)", err, id, flowID)
+	}
+	return
+}
+
+// NetIDByBusiness .
+func (d *Dao) NetIDByBusiness(c context.Context, businessID []int64) (bizmap map[int64][]int64, err error) {
+	res := []struct {
+		ID         int64 `gorm:"column:id"`
+		BusinessID int64 `gorm:"column:business_id"`
+	}{}
+	list := []*net.Net{}
+	bizmap = map[int64][]int64{}
+	if err = d.orm.Select("id, business_id").Where("business_id in (?)", businessID).
+		Scopes(Available).Find(&list).Scan(&res).Error; err != nil {
+		return
+	}
+
+	for _, item := range res {
+		bizmap[item.BusinessID] = append(bizmap[item.BusinessID], item.ID)
+	}
+	return
+}
+
+// NetsByBusiness .
+func (d *Dao) NetsByBusiness(c context.Context, businessID []int64, onlyAvailable bool) (list []*net.Net, err error) {
+	list = []*net.Net{}
+	db := d.orm
+	if len(businessID) > 0 {
+		db = db.Where("business_id in (?)", businessID)
+	}
+	if onlyAvailable {
+		db = db.Scopes(Available)
+	}
+	if err = db.Find(&list).Error; err != nil {
+		log.Error("NetsByBusiness(%v) error(%v) onlyavailable(%v)", businessID, err, onlyAvailable)
+	}
+	return
+}
+
+// DisableNet .
+func (d *Dao) DisableNet(c context.Context, tx *gorm.DB, id int64) (err error) {
+	err = d.UpdateFields(c, tx, net.TableNet, id, map[string]interface{}{"disable_time": time.Now()})
+	return
+}

app/admin/main/aegis/dao/gorm/net_test.go

@@ -0,0 +1,93 @@
+package gorm
+
+import (
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	"go-common/app/admin/main/aegis/model/net"
+)
+
+func TestDaoNetByID(t *testing.T) {
+	convey.Convey("NetByID", t, func(ctx convey.C) {
+		d.NetByID(cntx, 1)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+		})
+	})
+}
+
+func TestDao_NetList(t *testing.T) {
+	convey.Convey("NetList", t, func(ctx convey.C) {
+		pm := &net.ListNetParam{
+			BusinessID: 1,
+			//State:      net.StateAvailable,
+			Ps: 20,
+			Pn: 1,
+			ID: []int64{1},
+		}
+		_, err := d.NetList(cntx, pm)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoNetIDByBusiness(t *testing.T) {
+	convey.Convey("NetIDByBusiness", t, func(ctx convey.C) {
+		res, err := d.NetIDByBusiness(cntx, []int64{1, 2, 3})
+		t.Logf("res(%+v)", res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoNetsByBusiness(t *testing.T) {
+	convey.Convey("NetsByBusiness", t, func(ctx convey.C) {
+		_, err := d.NetsByBusiness(cntx, []int64{1}, true)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoNets(t *testing.T) {
+	convey.Convey("Nets", t, func(ctx convey.C) {
+		_, err := d.Nets(cntx, []int64{})
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoNetByUnique(t *testing.T) {
+	convey.Convey("NetByUnique", t, func(ctx convey.C) {
+		_, err := d.NetByUnique(cntx, "")
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoNetBindStartFlow(t *testing.T) {
+	var (
+		tx, _ = d.BeginTx(cntx)
+	)
+	defer tx.Commit()
+	convey.Convey("NetBindStartFlow", t, func(ctx convey.C) {
+		err := d.NetBindStartFlow(cntx, tx, 0, 0)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoDisableNet(t *testing.T) {
+	var (
+		tx, _ = d.BeginTx(cntx)
+	)
+	defer tx.Commit()
+	convey.Convey("DisableNet", t, func(ctx convey.C) {
+		err := d.DisableNet(cntx, tx, 0)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/report.go

@@ -0,0 +1,67 @@
+package gorm
+
+import (
+	"context"
+	"database/sql"
+
+	"go-common/app/admin/main/aegis/model"
+	"go-common/library/log"
+)
+
+//ReportTaskMetas 任务数据统计
+func (d *Dao) ReportTaskMetas(c context.Context, bt string, et string, bizid, flowid int64, uids []int64, mnames map[int64]string, tp int8) (metas []*model.ReportMeta, missuid []int64, err error) {
+	db := d.orm.Table("task_report").Select("mtime,uid,type,content").Where("business_id=? AND type=?", bizid, tp)
+	if flowid != 0 {
+		db.Where("flow_id=?", flowid)
+	}
+	db = db.Where("mtime>=? AND mtime<?", bt, et)
+
+	if len(uids) > 0 {
+		db = db.Where("uid IN (?)", uids)
+	}
+
+	var rows *sql.Rows
+	if rows, err = db.Order("mtime asc").Rows(); err != nil {
+		log.Error("ReportTaskFlow error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		meta := &model.ReportMeta{}
+		if err = rows.Scan(&meta.Mtime, &meta.UID, &meta.Type, &meta.Content); err != nil {
+			return
+		}
+		if uname, ok := mnames[meta.UID]; ok {
+			meta.Uname = uname
+		} else {
+			missuid = append(missuid, meta.UID)
+		}
+		metas = append(metas, meta)
+	}
+	return
+}
+
+//TaskReports 任务报表记录
+func (d *Dao) TaskReports(c context.Context, biz int64, flowID int64, tp []int8, statdateFrom string, statdateTo string) (res []*model.TaskReport, err error) {
+	res = []*model.TaskReport{}
+	db := d.orm
+	if statdateFrom != "" {
+		db = db.Where("stat_date>=?", statdateFrom)
+	}
+	if statdateTo != "" {
+		db = db.Where("stat_date <=?", statdateTo)
+	}
+	db = db.Where("business_id=?", biz)
+	if flowID > 0 {
+		db = db.Where("flow_id=?", flowID)
+	}
+	if len(tp) >= 0 {
+		db = db.Where("type in (?)", tp)
+	}
+	db = db.Order("stat_date desc, business_id desc, flow_id desc")
+	if err = db.Find(&res).Error; err != nil {
+		log.Error("TaskReports error(%v)", err)
+	}
+	return
+}

app/admin/main/aegis/dao/gorm/report_test.go

@@ -0,0 +1,40 @@
+package gorm
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	"time"
+)
+
+func TestGormReportTaskFlow(t *testing.T) {
+	convey.Convey("ReportTaskFlow", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			metas, _, err := d.ReportTaskMetas(c, "", "", 1, 1, []int64{}, map[int64]string{}, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				for _, meta := range metas {
+					fmt.Println("meta:", meta)
+				}
+			})
+		})
+	})
+}
+
+func TestDao_TaskReports(t *testing.T) {
+	time.Time{}.Unix()
+	t.Logf("%s", time.Duration(time.Duration(3661)*time.Second).String())
+	return
+	convey.Convey("TaskReports", t, func(ctx convey.C) {
+		res, err := d.TaskReports(cntx, 1, 1, []int8{2, 3, 4}, "2019-01-14", "2019-01-15")
+		ctx.So(err, convey.ShouldBeNil)
+		for _, item := range res {
+			t.Logf("item(%+v)", item)
+		}
+	})
+}

app/admin/main/aegis/dao/gorm/resource.go

@@ -0,0 +1,304 @@
+package gorm
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+
+	"go-common/app/admin/main/aegis/model/resource"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model"
+)
+
+const (
+	_resourceResSQL = "SELECT r.id, r.business_id, r.oid, r.mid,r.content,r.extra1,r.extra2,r.extra3,r.extra4,r.extra1s,r.extra2s,r.metadata, rr.attribute, rr.note, rr.reject_reason, rr.reason_id, rr.state, rr.pubtime, rr.deltime " +
+		"FROM resource r LEFT JOIN resource_result rr ON r.id = rr.rid WHERE r.id = ?"
+	_resByOIDSQL = "SELECT r.id, r.business_id, r.oid, r.mid,r.content,r.extra1,r.extra2,r.extra3,r.extra4,r.extra1s,r.extra2s,r.metadata, rr.attribute, rr.note, rr.reject_reason, rr.reason_id, rr.state, rr.pubtime, rr.deltime " +
+		"FROM resource r LEFT JOIN resource_result rr ON r.id = rr.rid WHERE r.business_id = ? AND r.oid = ?"
+)
+
+var _changeableFields = map[string]struct{}{
+	"extra1":     {},
+	"extra2":     {},
+	"extra3":     {},
+	"extra4":     {},
+	"extra5":     {},
+	"extra6":     {},
+	"extra1s":    {},
+	"extra2s":    {},
+	"extra3s":    {},
+	"extra4s":    {},
+	"extratime1": {},
+}
+
+// ListHelperForTask 补充任务列表里面的oid和content
+func (d *Dao) ListHelperForTask(c context.Context, rids []int64) (res map[int64][]interface{}, err error) {
+	var (
+		rows                   *sql.Rows
+		id                     int64
+		oid, content, metadata string
+	)
+	if rows, err = d.orm.Table("resource").Select("id,oid,content,metadata").Where("id IN (?)", rids).Rows(); err != nil {
+		log.Error("listHelperForTask err(%v)", err)
+		return
+	}
+
+	res = make(map[int64][]interface{})
+	defer rows.Close()
+	for rows.Next() {
+		if err = rows.Scan(&id, &oid, &content, &metadata); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		metas := make(map[string]interface{})
+		if len(metadata) > 0 {
+			if err = json.Unmarshal([]byte(metadata), &metas); err != nil {
+				log.Error("ListHelperForTask err(%+v)\n", err)
+			}
+			err = nil
+		}
+		res[id] = []interface{}{oid, content, metas}
+	}
+	return
+}
+
+// TxAddResource .
+func (d *Dao) TxAddResource(tx *gorm.DB, r *resource.Resource, rr *resource.Result) (rid int64, err error) {
+	err = tx.Table("resource").Where("business_id=? AND oid=?", r.BusinessID, r.OID).
+		Assign(map[string]interface{}{
+			"oid":        r.OID,
+			"content":    r.Content,
+			"extra1":     r.Extra1,
+			"extra2":     r.Extra2,
+			"extra3":     r.Extra3,
+			"extra4":     r.Extra4,
+			"extra1s":    r.Extra1s,
+			"extra2s":    r.Extra2s,
+			"metadata":   r.MetaData,
+			"extra5":     r.Extra5,
+			"extra6":     r.Extra6,
+			"extra3s":    r.Extra3s,
+			"extra4s":    r.Extra4s,
+			"extratime1": r.ExtraTime1,
+			"octime":     r.OCtime,
+			"ptime":      r.Ptime,
+		}).FirstOrCreate(&r).Error
+	if err != nil {
+		return
+	}
+	rid = r.ID
+	rr.RID = r.ID
+	err = tx.Table("resource_result").Where("rid=?", rr.RID).Assign(map[string]interface{}{
+		"attribute":     rr.Attribute,
+		"note":          rr.Note,
+		"reject_reason": rr.RejectReason,
+		"reason_id":     rr.ReasonID,
+		"state":         rr.State,
+		"pubtime":       rr.PubTime,
+		"deltime":       rr.DelTime,
+	}).FirstOrCreate(&rr).Error
+	return
+}
+
+// ResourceByOID .
+func (d *Dao) ResourceByOID(c context.Context, OID string, bizID int64) (res *resource.Resource, err error) {
+	res = &resource.Resource{}
+	if err = d.orm.Where("oid = ? AND business_id = ?", OID, bizID).First(res).Error; err == gorm.ErrRecordNotFound {
+		res = nil
+		err = nil
+	}
+	return
+}
+
+// RidsByOids .
+func (d *Dao) RidsByOids(c context.Context, bizID int64, oids []string) (rids string, err error) {
+	err = d.orm.Table("resource").Select("GROUP_CONCAT(id)").Where("business_id=? AND oid IN (?)", bizID, oids).Row().Scan(&rids)
+	return
+}
+
+// OidByRID 通过rid查到oid
+func (d *Dao) OidByRID(c context.Context, rid int64) (oid string, err error) {
+	if err = d.orm.Table("resource").Select("oid").Where("id=?", rid).Row().Scan(&oid); err == sql.ErrNoRows {
+		err = nil
+	}
+	return
+}
+
+// TxUpdateResult .
+func (d *Dao) TxUpdateResult(ormTx *gorm.DB, rid int64, res map[string]interface{}, rscRes *resource.Result) (err error) {
+	params := make(map[string]interface{})
+	for k, v := range res {
+		if k != "state" && k != "attribute" {
+			continue
+		}
+		params[k] = v
+	}
+
+	db := ormTx.Table("resource_result").
+		Where("rid = ?", rid)
+		//Update(params)
+	if rscRes != nil {
+		if rscRes.Attribute != -1 {
+			params["attribute"] = rscRes.Attribute
+		}
+		if rscRes.Note != "" {
+			params["note"] = rscRes.Note
+		}
+		if rscRes.RejectReason != "" {
+			params["reject_reason"] = rscRes.RejectReason
+		}
+		if rscRes.ReasonID != 0 {
+			params["reason_id"] = rscRes.ReasonID
+		}
+	}
+	return db.Update(params).Error
+}
+
+// TxUpdateResource . TODO Resource表的字段要不要直接审核提交变更 还是等待业务方同步更新？(例如单话的上线下线)
+func (d *Dao) TxUpdateResource(ormTx *gorm.DB, rid int64, res map[string]interface{}) (err error) {
+	params := make(map[string]interface{})
+	for k, v := range res {
+		if _, ok := _changeableFields[k]; !ok {
+			continue
+		}
+		params[k] = v
+	}
+
+	return ormTx.Table("resource").Where("id = ?", rid).Update(params).Error
+}
+
+// TxUpdateState 更新状态
+func (d *Dao) TxUpdateState(tx *gorm.DB, rids []int64, state int) (err error) {
+	return tx.Table("resource_result").Where("rid IN (?)", rids).Update("state", state).Error
+}
+
+// UpdateResource 更新资源
+func (d *Dao) UpdateResource(c context.Context, bizid int64, oid string, update map[string]interface{}) (rows int64, err error) {
+	db := d.orm.Table("resource").Where("business_id=? AND oid=?", bizid, oid).Update(update)
+	return db.RowsAffected, db.Error
+}
+
+// ResourceRes .
+func (d *Dao) ResourceRes(c context.Context, rid int64) (res *resource.Res, err error) {
+	res = &resource.Res{}
+	if err = d.orm.Raw(_resourceResSQL, rid).Scan(res).Error; err == gorm.ErrRecordNotFound {
+		res = nil
+		err = nil
+	}
+	return
+}
+
+// ResByOID .
+func (d *Dao) ResByOID(c context.Context, bizID int64, OID string) (res *resource.Res, err error) {
+	res = &resource.Res{}
+	if err = d.orm.Raw(_resByOIDSQL, bizID, OID).Scan(res).Error; err == gorm.ErrRecordNotFound {
+		res = nil
+		err = nil
+	}
+	return
+}
+
+//ResOIDByID 根据id获取资源oid
+func (d *Dao) ResOIDByID(c context.Context, rids []int64) (res map[int64]string, err error) {
+	list := []struct {
+		ID  int64  `gorm:"column:id"`
+		OID string `gorm:"column:oid"`
+	}{}
+	res = map[int64]string{}
+	if err = d.orm.Table("resource").Select("id,oid").Where("id in (?)", rids).Find(&list).Error; err != nil {
+		log.Error("ResOIDByID error(%v) rids(%v)", err, rids)
+		return
+	}
+
+	for _, item := range list {
+		res[item.ID] = item.OID
+	}
+	return
+}
+
+//ResIDByOID 根据oid获取rid
+func (d *Dao) ResIDByOID(C context.Context, bizID int64, oids []string) (res map[string]int64, err error) {
+	list := []struct {
+		ID  int64  `gorm:"column:id"`
+		OID string `gorm:"column:oid"`
+	}{}
+	res = map[string]int64{}
+	if err = d.orm.Table("resource").Select("id,oid").Where("business_id=? and oid in (?)", bizID, oids).Find(&list).Error; err != nil {
+		log.Error("ResIDByOID error(%v) oids(%v)", err, oids)
+		return
+	}
+
+	for _, item := range list {
+		res[item.OID] = item.ID
+	}
+	return
+}
+
+//ResourceHit 根据状态筛选资源
+func (d *Dao) ResourceHit(c context.Context, rids []int64) (hitids map[int64]int64, err error) {
+	hitids = make(map[int64]int64)
+	rows, err := d.orm.Table("resource_result").Select("rid,state").Where("rid IN (?)", rids).Rows()
+	if err != nil {
+		log.Error("ResourceHitState error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var rid, state int64
+		if err = rows.Scan(&rid, &state); err != nil {
+			log.Error("ResourceHitState error(%v)", err)
+		}
+		hitids[rid] = state
+	}
+	return
+}
+
+//ResultByRID result by rid
+func (d *Dao) ResultByRID(c context.Context, rid int64) (res *resource.Result, err error) {
+	res = &resource.Result{}
+	if err = d.orm.Where("rid=?", rid).First(&res).Error; err == gorm.ErrRecordNotFound {
+		log.Error("ResultByRID rid(%d) error(%v)", rid, err)
+	}
+	return
+}
+
+//MetaByRID .
+func (d *Dao) MetaByRID(c context.Context, rids []int64) (metas map[int64]string, err error) {
+	var rows *sql.Rows
+	metas = make(map[int64]string)
+	rows, err = d.orm.Table("resource").Select("id,metadata").Where("id IN (?)", rids).Rows()
+	if err != nil {
+		log.Error("MetaByRID Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var (
+			id   int64
+			meta string
+		)
+		if err = rows.Scan(&id, &meta); err != nil {
+			log.Error("MetaByRID rows.Scan error(%v)", err)
+			return
+		}
+		metas[id] = meta
+	}
+	return
+}
+
+//UpsertByOIDs 获取需要更新到搜索部分
+func (d *Dao) UpsertByOIDs(c context.Context, businessID int64, oids []string) (res []*model.UpsertItem, err error) {
+	res = []*model.UpsertItem{}
+	sqlstr := `SELECT r.id,r.extra1,r.extra2,r.extra3,r.extra4,rr.state
+FROM resource r
+LEFT JOIN resource_result rr ON r.id=rr.rid
+WHERE r.business_id=? AND r.oid IN (?)`
+	if err = d.orm.Raw(sqlstr, businessID, oids).Find(&res).Error; err != nil {
+		log.Error("UpsertByOIDs error(%+v) businessid(%d) oids(%+v)", err, businessID, oids)
+	}
+
+	return
+}

app/admin/main/aegis/dao/gorm/resource_test.go

@@ -0,0 +1,220 @@
+package gorm
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/aegis/model/resource"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestGormListHelperForTask(t *testing.T) {
+	convey.Convey("ListHelperForTask", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			rids = []int64{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := d.ListHelperForTask(c, rids)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestGormResourceByOID(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("ResourceByOID", t, func(ctx convey.C) {
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.ResourceByOID(c, "", 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormOidByRID(t *testing.T) {
+	var (
+		c = context.Background()
+	)
+	convey.Convey("OidByRID", t, func(ctx convey.C) {
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.OidByRID(c, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormTxUpdateResult(t *testing.T) {
+	convey.Convey("TxUpdateResult", t, func(ctx convey.C) {
+		var (
+			tx, _  = d.BeginTx(context.TODO())
+			rid    = int64(0)
+			res    = map[string]interface{}{"extra1": 1}
+			rscRes = &resource.Result{}
+		)
+		defer tx.Commit()
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.TxUpdateResult(tx, rid, res, rscRes)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormResourceRes(t *testing.T) {
+	convey.Convey("ResourceRes", t, func(ctx convey.C) {
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.ResourceRes(context.TODO(), 0)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormResByOID(t *testing.T) {
+	convey.Convey("ResByOID", t, func(ctx convey.C) {
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.ResByOID(context.TODO(), 0, "")
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormUpdateResource(t *testing.T) {
+	convey.Convey("UpdateResource", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			d.UpdateResource(context.TODO(), 1, "xyz", map[string]interface{}{"mid": 123})
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			})
+		})
+	})
+}
+
+func TestGormResOIDByID(t *testing.T) {
+	convey.Convey("ResOIDByID", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.ResOIDByID(context.TODO(), []int64{1, 2})
+			t.Logf("res(%+v)", res)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				convey.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormResIDByOID(t *testing.T) {
+	convey.Convey("ResIDByOID", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.ResIDByOID(context.TODO(), 1, []string{"1", "2"})
+			t.Logf("res(%+v)", res)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				convey.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormResourceHit(t *testing.T) {
+	convey.Convey("ResourceHit", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.ResourceHit(context.TODO(), []int64{})
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				convey.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormResultByRID(t *testing.T) {
+	convey.Convey("ResultByRID", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			d.ResultByRID(context.TODO(), 50)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			})
+		})
+	})
+}
+
+func TestGormRidsByOids(t *testing.T) {
+	convey.Convey("RidsByOids", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			d.RidsByOids(cntx, 0, []string{})
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			})
+		})
+	})
+}
+
+func TestGormTxUpdateResource(t *testing.T) {
+	convey.Convey("TxUpdateResource", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginTx(context.TODO())
+			rid   = int64(0)
+			res   = map[string]interface{}{"extra1": 1}
+		)
+		defer tx.Commit()
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.TxUpdateResource(tx, rid, res)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormTxUpdateState(t *testing.T) {
+	convey.Convey("TxUpdateState", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginTx(context.TODO())
+			rids  = []int64{0}
+		)
+		defer tx.Commit()
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.TxUpdateState(tx, rids, 0)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormMetaByRID(t *testing.T) {
+	convey.Convey("MetaByRID", t, func(ctx convey.C) {
+		var (
+			rids = []int64{0}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.MetaByRID(cntx, rids)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestGormUpsertByOIDs(t *testing.T) {
+	convey.Convey("UpsertByOIDs", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.UpsertByOIDs(context.TODO(), 1, []string{"oid000001", "oid000002"})
+			for _, item := range res {
+				t.Logf("res(%+v)", item)
+			}
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/task.go

@@ -0,0 +1,146 @@
+package gorm
+
+import (
+	"context"
+	"database/sql"
+
+	"go-common/app/admin/main/aegis/model/task"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_submitSQL = "UPDATE task SET state=?,uid=?,utime=? WHERE id=? AND state=? AND uid=?"
+)
+
+// TxSubmit 提交任务
+func (d *Dao) TxSubmit(tx *gorm.DB, opt *task.SubmitOptions, state int8) (rows int64, err error) {
+	rows = tx.Exec(_submitSQL, state, opt.UID, opt.Utime, opt.TaskID, opt.OldState, opt.OldUID).RowsAffected
+	return
+}
+
+// TxCloseTasks close
+func (d *Dao) TxCloseTasks(tx *gorm.DB, rids []int64, uid int64) (err error) {
+	err = tx.Table("task").Where("rid IN (?) AND state<?", rids, task.TaskStateSubmit).Update("state", task.TaskStateClosed).Update("uid", uid).Error
+	return
+}
+
+// CloseTask .
+func (d *Dao) CloseTask(c context.Context, id int64) (err error) {
+	return d.orm.Table("task").Where("id=?", id).Update("state", task.TaskStateClosed).Update("uid", 399).Error
+}
+
+// TaskByRID task by rid
+func (d *Dao) TaskByRID(c context.Context, rid, flowid int64) (t *task.Task, err error) {
+	db := d.orm.Model(&task.Task{}).Where("rid = ? AND state<?", rid, task.TaskStateSubmit)
+	if flowid > 0 {
+		db = db.Where("flow_id=?", flowid)
+	}
+	t = &task.Task{}
+	if err = db.Find(t).Error; err == gorm.ErrRecordNotFound {
+		err = nil
+		t = nil
+	}
+
+	return
+}
+
+// MaxWeight max weight
+func (d *Dao) MaxWeight(c context.Context, bizID, flowID int64) (max int64, err error) {
+	if err = d.orm.Table("task").Select("max(weight)").Where("business_id = ? AND flow_id = ?", bizID, flowID).
+		Where("state = ? OR state = ?", task.TaskStateInit, task.TaskStateDispatch).Row().Scan(&max); err != nil {
+		max = 0
+		err = nil
+	}
+	return
+}
+
+// UndoStat 未完成
+func (d *Dao) UndoStat(c context.Context, bizID, flowID, UID int64) (stat *task.UnDOStat, err error) {
+	stat = &task.UnDOStat{}
+
+	err = d.orm.Raw(`SELECT COUNT(CASE WHEN admin_id>0 AND state = 0 THEN 1 ELSE NULL END) assign, 
+	COUNT(CASE WHEN admin_id = 0 AND state = 2 THEN 1 ELSE NULL END) delay, 
+	COUNT(CASE WHEN admin_id = 0 AND state = 1 THEN 1 ELSE NULL END) normal
+	FROM task WHERE business_id=? AND flow_id=? AND uid=?`, bizID, flowID, UID).Scan(stat).Error
+	return
+}
+
+// TaskStat 任务详情统计
+func (d *Dao) TaskStat(c context.Context, bizID, flowID, UID int64) (stat *task.Stat, err error) {
+	stat = &task.Stat{}
+
+	err = d.orm.Raw(`SELECT COUNT(CASE WHEN admin_id=0 AND state = 0 THEN 1 ELSE NULL END) normal,
+		COUNT(CASE WHEN admin_id>0 AND state = 0 THEN 1 ELSE NULL END) assign,
+		COUNT(CASE WHEN state=2 THEN 1 ELSE NULL END) delayTotal,
+		COUNT(CASE WHEN uid=? AND state=2 THEN 1 ELSE NULL END) delayPersonal
+		FROM task WHERE business_id=? AND flow_id=?`, UID, bizID, flowID).Scan(stat).Error
+	return
+}
+
+// TaskListSeized 停滞任务
+func (d *Dao) TaskListSeized(c context.Context, opt *task.ListOptions) (ids []int64, count int64, err error) {
+	return d.tasklist(c, "seized", opt.BusinessID, opt.FlowID, opt.UID, opt.Pn, opt.Ps)
+}
+
+// TaskListDelayd 延迟任务
+func (d *Dao) TaskListDelayd(c context.Context, opt *task.ListOptions) (ids []int64, count int64, err error) {
+	return d.tasklist(c, "delayd", opt.BusinessID, opt.FlowID, opt.UID, opt.Pn, opt.Ps)
+}
+
+// TaskListAssignd 指派停滞任务
+func (d *Dao) TaskListAssignd(c context.Context, opt *task.ListOptions) (ids []int64, count int64, err error) {
+	return d.tasklist(c, "assignd", opt.BusinessID, opt.FlowID, opt.UID, opt.Pn, opt.Ps)
+}
+
+func (d *Dao) tasklist(c context.Context, ltp string, bizID, flowID, UID int64, pn, ps int) (ids []int64, count int64, err error) {
+	db := d.orm.Table("task").Where("business_id=? AND flow_id=?", bizID, flowID)
+	switch ltp {
+	case "seized":
+		db = db.Where("state=?", task.TaskStateDispatch)
+	case "delayd":
+		db = db.Where("state=?", task.TaskStateDelay)
+	case "assignd":
+		db = db.Where("state=? AND admin_id>0", task.TaskStateDispatch)
+	}
+	if UID > 0 {
+		db = db.Where("uid=?", UID)
+	}
+
+	var rows *sql.Rows
+	rows, err = db.Count(&count).Select("id").Order("weight DESC").Offset((pn - 1) * ps).Limit(ps).Rows()
+	if err != nil {
+		log.Error("tasklist error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id int64
+		if err = rows.Scan(&id); err != nil {
+			log.Error("tasklist error(%v)", err)
+			return
+		}
+		ids = append(ids, id)
+	}
+	return
+}
+
+//TaskHitAuditing 检查资源是否正在审核
+func (d *Dao) TaskHitAuditing(c context.Context, rids []int64) (map[int64]struct{}, error) {
+	hitids := make(map[int64]struct{})
+	rows, err := d.orm.Table("task").Select("rid").Where("rid IN (?)", rids).
+		Where("state = ? AND gtime!=0", task.TaskStateDispatch).Rows()
+	if err != nil {
+		return hitids, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id int64
+		if err = rows.Scan(&id); err != nil {
+			return hitids, err
+		}
+		hitids[id] = struct{}{}
+	}
+	return hitids, err
+}

app/admin/main/aegis/dao/gorm/task_config.go

@@ -0,0 +1,64 @@
+package gorm
+
+import (
+	"context"
+
+	taskmod "go-common/app/admin/main/aegis/model/task"
+	"go-common/library/log"
+)
+
+// AddConfig add config
+func (d *Dao) AddConfig(c context.Context, config *taskmod.Config, confJSON interface{}) (err error) {
+	if config.ConfType == taskmod.TaskConfigRangeWeight { //粉丝数，等待时长，分组权重配置去重
+		name := "%" + confJSON.(*taskmod.RangeWeightConfig).Name + "%"
+		err = d.orm.Table("task_config").Where("business_id=? AND flow_id=? AND conf_type=? AND conf_json LIKE ?", config.BusinessID, config.FlowID, taskmod.TaskConfigRangeWeight, name).
+			Assign(map[string]interface{}{
+				"conf_json":   config.ConfJSON,
+				"btime":       config.Btime,
+				"etime":       config.Etime,
+				"uid":         config.UID,
+				"uname":       config.Uname,
+				"description": config.Description,
+			}).FirstOrCreate(config).Error
+		return err
+	}
+	return d.orm.Create(config).Error
+}
+
+// UpdateConfig update config
+func (d *Dao) UpdateConfig(c context.Context, config *taskmod.Config) (err error) {
+	return d.orm.Model(&taskmod.Config{}).Where("id=?", config.ID).Update(config).Error
+}
+
+// SetStateConfig update config
+func (d *Dao) SetStateConfig(c context.Context, id int64, state int8) (err error) {
+	return d.orm.Model(&taskmod.Config{}).Where("id=?", id).Update("state", state).Error
+}
+
+// QueryConfigs list config
+func (d *Dao) QueryConfigs(c context.Context, queryParams *taskmod.QueryParams) (configs []*taskmod.Config, count int64, err error) {
+	db := d.orm.Model(&taskmod.Config{}).Where("conf_type=?", queryParams.ConfType).Where("state=?", queryParams.State)
+	if queryParams.BusinessID > 0 {
+		db = db.Where("business_id=?", queryParams.BusinessID)
+	}
+	if queryParams.FlowID > 0 {
+		db = db.Where("flow_id=?", queryParams.FlowID)
+	}
+	if len(queryParams.Btime) > 0 && len(queryParams.Etime) > 0 {
+		db = db.Where("mtime>=? AND mtime<=?", queryParams.Btime, queryParams.Etime)
+	}
+	if len(queryParams.ConfName) > 0 {
+		db = db.Where("conf_json LIKE '%" + queryParams.ConfName + "%'")
+	}
+
+	if err = db.Count(&count).Offset((queryParams.Pn - 1) * queryParams.Ps).Order("mtime DESC").Limit(queryParams.Ps).Find(&configs).Error; err != nil {
+		log.Error("query error(%v)", err)
+		return
+	}
+	return
+}
+
+// DeleteConfig delete config
+func (d *Dao) DeleteConfig(c context.Context, id int64) (err error) {
+	return d.orm.Where("id=?", id).Delete(&taskmod.Config{}).Error
+}

app/admin/main/aegis/dao/gorm/task_config_test.go

@@ -0,0 +1,73 @@
+package gorm
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/aegis/model/task"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoQueryConfigs(t *testing.T) {
+	convey.Convey("QueryConfigs", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			params = &task.QueryParams{
+				BusinessID: 1,
+				FlowID:     1,
+				Btime:      "0000-00-00 00:00:00",
+				Etime:      "2018-12-12 12:12:12",
+				ConfName:   "mid",
+			}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, _, err := d.QueryConfigs(c, params)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDeleteConfig(t *testing.T) {
+	convey.Convey("DeleteConfig", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.DeleteConfig(c, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetStateConfig(t *testing.T) {
+	convey.Convey("SetStateConfig", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.SetStateConfig(c, 0, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateConfig(t *testing.T) {
+	convey.Convey("UpdateConfig", t, func(ctx convey.C) {
+		var (
+			config = &task.Config{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.UpdateConfig(cntx, config)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/task_test.go

@@ -0,0 +1,155 @@
+package gorm
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/aegis/model/common"
+	taskmod "go-common/app/admin/main/aegis/model/task"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestUndoStat(t *testing.T) {
+	convey.Convey("UndoStat", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := d.UndoStat(c, 0, 0, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestTaskStat(t *testing.T) {
+	convey.Convey("TaskStat", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := d.TaskStat(c, 0, 0, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestTaskMaxWeight(t *testing.T) {
+	convey.Convey("MaxWeight", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.MaxWeight(c, 0, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestTaskListSeized(t *testing.T) {
+	convey.Convey("TaskListSeized", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, _, err := d.TaskListSeized(c, &taskmod.ListOptions{})
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestTxCloseTasks(t *testing.T) {
+	convey.Convey("TxCloseTasks", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tx, _ = d.BeginTx(c)
+		)
+		defer tx.Commit()
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.TxCloseTasks(tx, []int64{}, 0)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestTxSubmit(t *testing.T) {
+	convey.Convey("TxSubmit", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginTx(cntx)
+			opt   = &taskmod.SubmitOptions{}
+		)
+		defer tx.Commit()
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.TxSubmit(tx, opt, 0)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestCloseTask(t *testing.T) {
+	convey.Convey("CloseTask", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.CloseTask(cntx, 0)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestTaskByRID(t *testing.T) {
+	convey.Convey("TaskByRID", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.TaskByRID(cntx, 0, 1)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestTaskListAssignd(t *testing.T) {
+	convey.Convey("TaskListAssignd", t, func(ctx convey.C) {
+		var (
+			opt = &taskmod.ListOptions{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, _, err := d.TaskListAssignd(cntx, opt)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestTaskListDelayd(t *testing.T) {
+	convey.Convey("TaskListDelayd", t, func(ctx convey.C) {
+		var (
+			opt = &taskmod.ListOptions{
+				BaseOptions: common.BaseOptions{
+					UID: 1,
+				},
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, _, err := d.TaskListDelayd(cntx, opt)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/token.go

@@ -0,0 +1,126 @@
+package gorm
+
+import (
+	"context"
+	"strings"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// TokenByID .
+func (d *Dao) TokenByID(c context.Context, id int64) (t *net.Token, err error) {
+	t = &net.Token{}
+	err = d.orm.Where("id=?", id).First(t).Error
+	if err == gorm.ErrRecordNotFound {
+		err = ecode.AegisTokenNotFound
+		return
+	}
+	if err != nil {
+		log.Error("TokenByID(%+v) error(%v)", id, err)
+	}
+	return
+}
+
+// Tokens .
+func (d *Dao) Tokens(c context.Context, ids []int64) (list []*net.Token, err error) {
+	list = []*net.Token{}
+	err = d.orm.Where("id in (?)", ids).Find(&list).Error
+	if err != nil {
+		log.Error("Tokens(%v) error(%v)", ids, err)
+	}
+
+	return
+}
+
+func (d *Dao) tokenListDB(netID []int64, id []int64, name string, onlyAssign bool) (db *gorm.DB) {
+	db = d.orm.Table(net.TableToken).Where("net_id in (?)", netID)
+	if len(id) > 0 {
+		db = db.Where("id in (?)", id)
+	}
+	name = strings.TrimSpace(name)
+	if name != "" {
+		db = db.Where("name=?", name)
+	}
+	if onlyAssign {
+		db = db.Where("compare=?", net.TokenCompareAssign)
+	}
+	return
+}
+
+// TokenListWithPager .
+func (d *Dao) TokenListWithPager(c context.Context, pm *net.ListTokenParam) (result *net.ListTokenRes, err error) {
+	result = &net.ListTokenRes{
+		Pager: net.Pager{
+			Num:  pm.Pn,
+			Size: pm.Ps,
+		},
+	}
+	db := d.tokenListDB([]int64{pm.NetID}, pm.ID, pm.Name, pm.Assign)
+	err = db.Count(&result.Pager.Total).Scopes(pager(pm.Ps, pm.Pn, pm.Sort)).Find(&result.Result).Error
+	if err != nil {
+		log.Error("TokenListWithPager find error(%v) params(%+v)", err, pm)
+	}
+	return
+}
+
+// TokenList .
+func (d *Dao) TokenList(c context.Context, netID []int64, id []int64, name string, onlyAssign bool) (list []*net.Token, err error) {
+	err = d.tokenListDB(netID, id, name, onlyAssign).Find(&list).Error
+	if err != nil {
+		log.Error("TokenList find error(%v)", err)
+	}
+	return
+}
+
+// TokenByUnique .
+func (d *Dao) TokenByUnique(c context.Context, netID int64, name string, compare int8, value string) (t *net.Token, err error) {
+	t = &net.Token{}
+	err = d.orm.Where("net_id=? AND name=? AND compare=? AND value=?", netID, name, compare, value).First(t).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+		t = nil
+		return
+	}
+	if err != nil {
+		log.Error("TokenByUnique(%d,%s,%d,%s) error(%v)", netID, name, compare, value, err)
+	}
+	return
+}
+
+// TokenBinds .
+func (d *Dao) TokenBinds(c context.Context, id []int64) (t []*net.TokenBind, err error) {
+	t = []*net.TokenBind{}
+	err = d.orm.Where("id in (?)", id).Find(&t).Error
+	if err != nil {
+		log.Error("TokenBinds(%+v) error(%v)", id, err)
+	}
+	return
+}
+
+// TokenBindByElement .
+func (d *Dao) TokenBindByElement(c context.Context, elementID []int64, tp []int8, onlyAvailable bool) (binds map[int64][]*net.TokenBind, err error) {
+	binds = map[int64][]*net.TokenBind{}
+	list := []*net.TokenBind{}
+	db := d.orm.Where("element_id in (?) AND type in (?)", elementID, tp)
+	if onlyAvailable {
+		db = db.Scopes(Available)
+	}
+
+	if err = db.Find(&list).Error; err != nil {
+		log.Error("TokenBindByElement error(%v) elementid(%d) type(%v) onlyavailable(%v)", err, elementID, tp, onlyAvailable)
+		return
+	}
+
+	for _, item := range list {
+		if _, exist := binds[item.ElementID]; !exist {
+			binds[item.ElementID] = []*net.TokenBind{item}
+			continue
+		}
+
+		binds[item.ElementID] = append(binds[item.ElementID], item)
+	}
+	return
+}

app/admin/main/aegis/dao/gorm/token_test.go

@@ -0,0 +1,81 @@
+package gorm
+
+import (
+	"go-common/app/admin/main/aegis/model/net"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoTokens(t *testing.T) {
+	var (
+		ids = []int64{}
+	)
+	convey.Convey("Tokens", t, func(ctx convey.C) {
+		no, err := d.Tokens(cntx, ids)
+		ctx.Convey("Then err should be nil.no should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(no, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTokenList(t *testing.T) {
+	convey.Convey("TokenList", t, func(ctx convey.C) {
+		result, err := d.TokenList(cntx, []int64{1}, []int64{}, "1", true)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTokenByID(t *testing.T) {
+	convey.Convey("TokenByID", t, func(ctx convey.C) {
+		d.TokenByID(cntx, 1)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+		})
+	})
+}
+
+func TestDaoTokenListWithPager(t *testing.T) {
+	var (
+		pm = &net.ListTokenParam{}
+	)
+	convey.Convey("TokenListWithPager", t, func(ctx convey.C) {
+		result, err := d.TokenListWithPager(cntx, pm)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTokenByUnique(t *testing.T) {
+	convey.Convey("TokenByUnique", t, func(ctx convey.C) {
+		_, err := d.TokenByUnique(cntx, 0, "", 0, "")
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoTokenBinds(t *testing.T) {
+	convey.Convey("TokenBinds", t, func(ctx convey.C) {
+		result, err := d.TokenBinds(cntx, []int64{})
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTokenBindByElement(t *testing.T) {
+	convey.Convey("TokenBindByElement", t, func(ctx convey.C) {
+		result, err := d.TokenBindByElement(cntx, []int64{}, []int8{}, true)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/gorm/transition.go

@@ -0,0 +1,118 @@
+package gorm
+
+import (
+	"context"
+	"strings"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/aegis/model/net"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// TransitionByID .
+func (d *Dao) TransitionByID(c context.Context, id int64) (n *net.Transition, err error) {
+	n = &net.Transition{}
+	err = d.orm.Where("id=?", id).First(n).Error
+	if err == gorm.ErrRecordNotFound {
+		err = ecode.AegisTranNotFound
+		return
+	}
+	if err != nil {
+		log.Error("TransitionByID(%d) error(%v)", id, err)
+	}
+	return
+}
+
+// Transitions .
+func (d *Dao) Transitions(c context.Context, id []int64) (n []*net.Transition, err error) {
+	n = []*net.Transition{}
+	err = d.orm.Where("id in (?)", id).Find(&n).Error
+	if err != nil {
+		log.Error("Transitions(%v) error(%v)", id, err)
+	}
+	return
+}
+
+// TransitionList .
+func (d *Dao) TransitionList(c context.Context, pm *net.ListNetElementParam) (result *net.ListTransitionRes, err error) {
+	result = &net.ListTransitionRes{
+		Pager: net.Pager{
+			Num:  pm.Pn,
+			Size: pm.Ps,
+		},
+	}
+	db := d.orm.Table(net.TableTransition).Where("net_id=?", pm.NetID)
+	if len(pm.ID) > 0 {
+		db = db.Where("id in (?)", pm.ID)
+	}
+	pm.Name = strings.TrimSpace(pm.Name)
+	if pm.Name != "" {
+		db = db.Where("name=?", pm.Name)
+	}
+	err = db.Scopes(state(pm.State)).Count(&result.Pager.Total).Scopes(pager(pm.Ps, pm.Pn, pm.Sort)).Find(&result.Result).Error
+	if err != nil {
+		log.Error("TransitionList find error(%v) params(%+v)", err, pm)
+	}
+	return
+}
+
+// TransitionByUnique .
+func (d *Dao) TransitionByUnique(c context.Context, netID int64, name string) (t *net.Transition, err error) {
+	t = &net.Transition{}
+	err = d.orm.Where("net_id=? AND name=?", netID, name).First(t).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+		t = nil
+		return
+	}
+	if err != nil {
+		log.Error("TransitionByUnique(%d,%s) error(%v)", netID, name, err)
+	}
+	return
+}
+
+// TransitionIDByNet .
+func (d *Dao) TransitionIDByNet(c context.Context, netID []int64, onlyDispatch bool, onlyAvailable bool) (ids map[int64][]int64, err error) {
+	ids = map[int64][]int64{}
+	listi := []struct {
+		ID    int64 `gorm:"column:id"`
+		NetID int64 `gorm:"column:net_id"`
+	}{}
+	db := d.orm.Table(net.TableTransition).Where("net_id in (?)", netID)
+	if onlyAvailable {
+		db = db.Scopes(Available)
+	}
+	if onlyDispatch {
+		db = db.Where("`limit`>0").Scopes(manual)
+	}
+	if err = db.Find(&listi).Error; err != nil {
+		log.Error("TransitionIDByNet netid(%v) error(%v)", netID, err)
+		return
+	}
+
+	for _, item := range listi {
+		ids[item.NetID] = append(ids[item.NetID], item.ID)
+	}
+	return
+}
+
+func manual(db *gorm.DB) *gorm.DB {
+	return db.Where("`trigger`=?", net.TriggerManual)
+}
+
+// TranByNet .
+func (d *Dao) TranByNet(c context.Context, netID int64, onlyAvailable bool) (list []*net.Transition, err error) {
+	list = []*net.Transition{}
+	db := d.orm
+	if netID > 0 {
+		db = db.Where("net_id=?", netID)
+	}
+	if onlyAvailable {
+		db = db.Scopes(Available)
+	}
+	if err = db.Find(&list).Error; err != nil {
+		log.Error("TranByNet error(%v)", err)
+	}
+	return
+}

app/admin/main/aegis/dao/gorm/transition_test.go

@@ -0,0 +1,83 @@
+package gorm
+
+import (
+	"go-common/app/admin/main/aegis/model/net"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var tt = &net.Transition{
+	ID:          1,
+	NetID:       1,
+	Trigger:     net.TriggerManual,
+	Name:        "first",
+	ChName:      "第一次审核",
+	Description: "新建变迁",
+	UID:         421,
+}
+
+func TestDaoTransitionByID(t *testing.T) {
+	convey.Convey("TransitionByID", t, func(ctx convey.C) {
+		n, err := d.TransitionByID(cntx, tt.ID)
+		ctx.Convey("Then err should be nil.n should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(n, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTransitionList(t *testing.T) {
+	var (
+		pm = &net.ListNetElementParam{
+			NetID: 1,
+			Ps:    20,
+			ID:    []int64{1},
+			Name:  "1",
+		}
+	)
+	convey.Convey("TransitionList", t, func(ctx convey.C) {
+		result, err := d.TransitionList(cntx, pm)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTransitions(t *testing.T) {
+	convey.Convey("TransitionList", t, func(ctx convey.C) {
+		_, err := d.Transitions(cntx, []int64{})
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoTransitionByUnique(t *testing.T) {
+	convey.Convey("TransitionByUnique", t, func(ctx convey.C) {
+		_, err := d.TransitionByUnique(cntx, 0, "")
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoTransitionIDByNet(t *testing.T) {
+	convey.Convey("TransitionIDByNet", t, func(ctx convey.C) {
+		a, err := d.TransitionIDByNet(cntx, []int64{1}, true, true)
+		t.Logf("a(%+v)", a)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoTranByNet(t *testing.T) {
+	convey.Convey("TranByNet", t, func(ctx convey.C) {
+		_, err := d.TranByNet(cntx, 0, true)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/admin/main/aegis/dao/http/BUILD

@@ -0,0 +1,69 @@
+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",
+        "filter_test.go",
+        "log_test.go",
+        "resource_test.go",
+        "role_test.go",
+        "search_test.go",
+        "upload_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/aegis/conf:go_default_library",
+        "//app/admin/main/aegis/model: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 = [
+        "dao.go",
+        "filter.go",
+        "log.go",
+        "resource.go",
+        "role.go",
+        "search.go",
+        "upload.go",
+    ],
+    importpath = "go-common/app/admin/main/aegis/dao/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/aegis/conf:go_default_library",
+        "//app/admin/main/aegis/model:go_default_library",
+        "//app/admin/main/aegis/model/task:go_default_library",
+        "//library/database/elastic:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/xstr:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/aegis/dao/http/dao.go

@@ -0,0 +1,41 @@
+package http
+
+import (
+	"context"
+
+	"go-common/app/admin/main/aegis/conf"
+	"go-common/library/database/elastic"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao dao
+type Dao struct {
+	c *conf.Config
+
+	clientR, clientW *bm.Client
+	es               *elastic.Elastic
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:       c,
+		clientR: bm.NewClient(c.HTTPClient.Read),
+		clientW: bm.NewClient(c.HTTPClient.Write),
+		es: elastic.NewElastic(&elastic.Config{
+			Host:       c.Host.Manager,
+			HTTPClient: c.HTTPClient.Es,
+		}),
+	}
+
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	return nil
+}

app/admin/main/aegis/dao/http/dao_test.go

@@ -0,0 +1,62 @@
+package http
+
+import (
+	"context"
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"go-common/app/admin/main/aegis/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	d    *Dao
+	cntx context.Context
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.aegis-admin")
+		flag.Set("conf_token", "cad913269be022e1eb8c45a8d5408d78")
+		flag.Set("tree_id", "60977")
+		flag.Set("conf_version", "1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/aegis-admin.toml")
+	}
+
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	cntx = context.Background()
+	os.Exit(m.Run())
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	d.clientR.SetTransport(gock.DefaultTransport)
+	d.clientW.SetTransport(gock.DefaultTransport)
+	r.Method = strings.ToUpper(method)
+	return r
+}
+
+func TestHttpPing(t *testing.T) {
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		ctx.Convey("Ping", func(ctx convey.C) {
+			err := d.Ping(cntx)
+			ctx.Convey("Then err should not be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/http/filter.go

@@ -0,0 +1,49 @@
+package http
+
+import (
+	"context"
+	"net/url"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_filterURI = "/x/internal/filter/v3/hit"
+)
+
+// Res 筛选结果
+type Res struct {
+	Code int64 `json:"code"`
+	Data []struct {
+		Level int64  `json:"level"`
+		Msg   string `json:"msg"`
+	} `json:"data"`
+}
+
+// FilterMulti .批量过滤
+func (d *Dao) FilterMulti(c context.Context, area string, msg string) (hits []string, err error) {
+	params := url.Values{}
+	params.Set("area", area)
+	params.Set("msg", msg)
+	params.Set("level", "10")
+	res := new(Res)
+
+	log.Info("FilterMulti area(%s) msg(%s)", area, msg)
+	if err = d.clientR.Post(c, d.c.Host.API+_filterURI, "", params, res); err != nil {
+		log.Error("d.clientR.Get error(%v)", err)
+		return
+	}
+
+	if res.Code != 0 {
+		err = ecode.Code(res.Code)
+		log.Error("FilterMulti res(%+v) error(%+v)", res, err)
+		return
+	}
+
+	for _, dt := range res.Data {
+		hits = append(hits, dt.Msg)
+	}
+	log.Info("FilterMulti area(%s) msg(%s) hits(%v)", area, msg, hits)
+	return
+}

app/admin/main/aegis/dao/http/filter_test.go

@@ -0,0 +1,43 @@
+package http
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestHttpFilterMulti(t *testing.T) {
+	convey.Convey("FilterMulti", t, func(ctx convey.C) {
+		var (
+			c          = context.Background()
+			area       = ""
+			msg        = ""
+			successRes = `{"code":0,"data":[{"level":10,"msg":"女装大佬"}]}`
+			failRes    = `{"code":200,"data":[{"level":10,"msg":"女装大佬"}]}`
+		)
+		ctx.Convey("success", func(ctx convey.C) {
+			httpMock("POST", d.c.Host.API+_filterURI).Reply(200).JSON(successRes)
+			hits, err := d.FilterMulti(c, area, msg)
+			ctx.Convey("Then err should be nil.hits should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(reflect.DeepEqual(hits, []string{"女装大佬"}), convey.ShouldEqual, true)
+			})
+		})
+		ctx.Convey("request fail", func(ctx convey.C) {
+			httpMock("POST", d.c.Host.API+_filterURI).Reply(504)
+			_, err := d.FilterMulti(c, area, msg)
+			ctx.Convey("Then err should be nil.hits should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+		ctx.Convey("business fail", func(ctx convey.C) {
+			httpMock("POST", d.c.Host.API+_filterURI).Reply(200).JSON(failRes)
+			_, err := d.FilterMulti(c, area, msg)
+			ctx.Convey("Then err should be nil.hits should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/aegis/dao/http/log.go

@@ -0,0 +1,182 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/aegis/model"
+	"go-common/library/database/elastic"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+//const
+const (
+	LogMinYear = 2018
+	LogMinTime = "2018-11-01 10:00:00"
+)
+
+func setESParams(r *elastic.Request, args interface{}, cm model.EsCommon) {
+	av := reflect.ValueOf(args)
+	if av.Kind() == reflect.Ptr {
+		av = av.Elem()
+	}
+	if av.Kind() != reflect.Struct {
+		return
+	}
+
+	atp := av.Type()
+	ranges := map[string]map[string]interface{}{}
+	for i := atp.NumField() - 1; i >= 0; i-- {
+		fdt := atp.Field(i)
+		tag := fdt.Tag.Get("reflect")
+		if tag == "ignore" || tag == "" {
+			continue
+		}
+
+		fdv := av.Field(i)
+		fdk := fdt.Type.Kind()
+		if (fdk == reflect.Slice || fdk == reflect.String) && fdv.Len() == 0 {
+			continue
+		}
+
+		//default处理
+		omitdefault := strings.Index(tag, ",omitdefault")
+		tag = strings.Replace(tag, ",omitdefault", "", -1)
+		fdvv := fdv.Interface()
+		fdvslice := false
+		if omitdefault > -1 && fmt.Sprintf("%v", fdvv) == fdt.Tag.Get("default") {
+			continue
+		}
+
+		//字段值处理，parse额外处理
+		switch fdk {
+		case reflect.Int64, reflect.Int32, reflect.Int, reflect.Int16, reflect.Int8:
+			fdvv = fdv.Int()
+		case reflect.String:
+			if fdv.Len() == 0 {
+				continue
+			}
+
+			v := fdv.String()
+			parse := fdt.Tag.Get("parse")
+			if parse == "int" {
+				vi, err := strconv.ParseInt(v, 10, 64)
+				if err != nil {
+					log.Error("setESParams strconv.ParseInt(%s) error(%v)", v, err)
+					continue
+				}
+				fdvv = vi
+			} else if parse == "[]int" {
+				vi, err := xstr.SplitInts(v)
+				if err != nil {
+					log.Error("setESParams xstr.SplitInts(%s) error(%v)", v, err)
+					continue
+				}
+				fdvv = vi
+				fdvslice = true
+			} else {
+				fdvv = v
+			}
+		case reflect.Slice:
+			if fdv.Len() == 0 {
+				continue
+			}
+			fdvslice = true
+		default:
+			log.Warn("setESParams not support kind(%s) for tag(%s)", fdk.String(), tag)
+			continue
+		}
+
+		//范围处理
+		from := strings.Index(tag, ",from")
+		to := strings.Index(tag, ",to")
+		if from > -1 {
+			if _, exist := ranges[tag[:from]]; !exist {
+				ranges[tag[:from]] = map[string]interface{}{}
+			}
+			ranges[tag[:from]]["from"] = fdvv
+			continue
+		}
+		if to > -1 {
+			if _, exist := ranges[tag[:to]]; !exist {
+				ranges[tag[:to]] = map[string]interface{}{}
+			}
+			ranges[tag[:to]]["to"] = fdvv
+			continue
+		}
+
+		if fdvslice {
+			r.WhereIn(tag, fdvv)
+		} else {
+			r.WhereEq(tag, fdvv)
+		}
+	}
+
+	for field, items := range ranges {
+		r.WhereRange(field, items["from"], items["to"], elastic.RangeScopeLcRc)
+	}
+
+	r.Ps(cm.Ps).Pn(cm.Pn)
+	order := []map[string]string{}
+	if cm.Order != "" || cm.Sort != "" {
+		r.Order(cm.Order, cm.Sort)
+		order = append(order, map[string]string{cm.Order: cm.Sort})
+	}
+	if cm.Group != "" {
+		r.GroupBy(elastic.EnhancedModeDistinct, cm.Group, order)
+	}
+}
+
+//QueryLogSearch .
+func (d *Dao) QueryLogSearch(c context.Context, args *model.ParamsQueryLog, cm model.EsCommon) (resp *model.SearchLogResult, err error) {
+	var (
+		min                int = LogMinYear
+		max                int
+		ctimefrom, ctimeto time.Time
+	)
+	//默认获取所有行为日志，确定了时间范围的，只查询该段范围内的日志
+	if args.CtimeFrom != "" {
+		ctimefrom, _ = time.ParseInLocation("2006-01-02 15:04:05", args.CtimeFrom, time.Local)
+		if ctimefrom.Year() > min {
+			min = ctimefrom.Year()
+		}
+	}
+	if args.CtimeTo != "" {
+		ctimeto, _ = time.ParseInLocation("2006-01-02 15:04:05", args.CtimeTo, time.Local)
+		if ctimeto.Year() >= min {
+			max = ctimeto.Year()
+		}
+	} else {
+		max = time.Now().Year()
+	}
+
+	tmpl := ",log_audit_%d_%d"
+	index := ""
+	for i := min; i <= max; i++ {
+		index += fmt.Sprintf(tmpl, args.Business, i)
+	}
+	index = strings.TrimLeft(index, ",")
+
+	r := d.es.NewRequest("log_audit").Index(index).Fields(
+		"uid",
+		"uname",
+		"oid",
+		"type",
+		"action",
+		"str_0",
+		"str_1",
+		"str_2",
+		"int_0",
+		"int_1",
+		"int_2",
+		"ctime",
+		"extra_data")
+	setESParams(r, args, cm)
+	err = r.Scan(c, &resp)
+	return
+}

app/admin/main/aegis/dao/http/log_test.go

@@ -0,0 +1,33 @@
+package http
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/aegis/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestHttpQueryLogSearch(t *testing.T) {
+	convey.Convey("QueryLogSearch", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			args = &model.ParamsQueryLog{
+				Business:  231,
+				Int0From:  "0",
+				Int1:      []int64{0, 1},
+				Int2:      []int64{0},
+				Str0:      []string{"0"},
+				CtimeFrom: "2019-01-01 00:00:00",
+			}
+			escm = model.EsCommon{Ps: 10, Pn: 1, Order: "ctime", Sort: "desc"}
+		)
+
+		ctx.Convey("success", func(ctx convey.C) {
+			res, err := d.QueryLogSearch(c, args, escm)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}