Initial commit

app/admin/main/videoup/dao/oversea/BUILD

@@ -0,0 +1,54 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "oversea_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/videoup/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "oversea.go",
+    ],
+    importpath = "go-common/app/admin/main/videoup/dao/oversea",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/videoup/conf:go_default_library",
+        "//app/admin/main/videoup/model/oversea:go_default_library",
+        "//library/database/orm: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/videoup/dao/oversea/dao.go

@@ -0,0 +1,42 @@
+package manager
+
+import (
+	"context"
+
+	"github.com/jinzhu/gorm"
+	"go-common/app/admin/main/videoup/conf"
+	"go-common/library/database/orm"
+)
+
+// Dao is redis dao.
+type Dao struct {
+	c *conf.Config
+	// db
+	OverseaDB *gorm.DB
+}
+
+var (
+	d *Dao
+)
+
+// New new a dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:         c,
+		OverseaDB: orm.NewMySQL(c.DB.Oversea),
+	}
+	return d
+}
+
+// Close close.
+func (d *Dao) Close() {
+	if d.OverseaDB != nil {
+		d.OverseaDB.Close()
+	}
+}
+
+// Ping ping cpdb
+func (d *Dao) Ping(c context.Context) (err error) {
+	err = d.OverseaDB.DB().PingContext(c)
+	return
+}

app/admin/main/videoup/dao/oversea/dao_test.go

@@ -0,0 +1,38 @@
+package manager
+
+import (
+	"flag"
+	. "github.com/smartystreets/goconvey/convey"
+	"go-common/app/admin/main/videoup/conf"
+	"os"
+	"testing"
+)
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		Reset(func() {})
+		f(d)
+	}
+}
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.videoup-admin")
+		flag.Set("conf_token", "gRSfeavV7kJdY9875Gf29pbd2wrdKZ1a")
+		flag.Set("tree_id", "2307")
+		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/videoup-admin.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/admin/main/videoup/dao/oversea/oversea.go

@@ -0,0 +1,258 @@
+package manager
+
+import (
+	"context"
+
+	"go-common/app/admin/main/videoup/model/oversea"
+	"go-common/library/log"
+)
+
+// UpPolicyRelation update or into archive_relation.
+func (d *Dao) UpPolicyRelation(c context.Context, aid, gid int64) (relation *oversea.ArchiveRelation, err error) {
+	var assign = map[string]interface{}{
+		"policy_id": gid,
+		"aid":       aid,
+	}
+	relation = &oversea.ArchiveRelation{}
+	if err = d.OverseaDB.Where("aid=?", aid).Assign(assign).FirstOrCreate(&relation).Error; err != nil {
+		log.Error("d.UpPolicyRelation.FirstOrCreate error(%v)", err)
+		return
+	}
+	return
+}
+
+// PolicyRelation get archive policy group relation.
+func (d *Dao) PolicyRelation(c context.Context, aid int64) (relation *oversea.ArchiveRelation, err error) {
+	relation = &oversea.ArchiveRelation{}
+	res := d.OverseaDB.Where("aid=?", aid).Find(&relation)
+	if res.RecordNotFound() {
+		relation = nil
+		return
+	}
+	err = res.Error
+	return
+}
+
+// PolicyGroups get policy group
+func (d *Dao) PolicyGroups(c context.Context, uid, id int64, gType, state int8, count, page int64, order, sort string) (groups []*oversea.PolicyGroup, total int64, err error) {
+	var (
+		db     = d.OverseaDB.Model(&groups)
+		orders = map[string]int{
+			"mtime": 1,
+		}
+	)
+	db = db.Where("is_global=?", 1)
+	if uid > 0 {
+		db = db.Where("uid=?", uid)
+	}
+	if id > 0 {
+		db = db.Where("id=?", id)
+	}
+	if gType > 0 {
+		db = db.Where("type=?", gType)
+	}
+	if state >= 0 {
+		db = db.Where("state=?", state)
+	}
+	if order != "" && sort != "" {
+		if _, ok := orders[order]; ok {
+			db = db.Order(order + " " + sort)
+		}
+	}
+	if count <= 0 {
+		count = 20
+	}
+	if page <= 0 {
+		page = 1
+	}
+	db.Count(&total)
+	db = db.Offset((page - 1) * count)
+	db = db.Limit(count)
+	if err = db.Find(&groups).Error; err != nil {
+		log.Error("d.PolicyGroups.Find error(%v)", err)
+	}
+	err = d.ItemsByGroup(groups)
+	return
+}
+
+// PolicyGroupsByIds get policy groups by ids
+func (d *Dao) PolicyGroupsByIds(c context.Context, ids []int64) (groups []*oversea.PolicyGroup, err error) {
+	if err = d.OverseaDB.Where(ids).Find(&groups).Error; err != nil {
+		log.Error("d.PolicyGroupsByIds.Find error(%v)", err)
+	}
+	return
+}
+
+// PolicyGroup get policy group by id
+func (d *Dao) PolicyGroup(c context.Context, id int64) (group *oversea.PolicyGroup, err error) {
+	var (
+		groups []*oversea.PolicyGroup
+	)
+	group = &oversea.PolicyGroup{}
+	res := d.OverseaDB.Where("id=?", id).Find(&group)
+	if res.RecordNotFound() {
+		group = nil
+		return
+	}
+	err = res.Error
+	if err != nil {
+		log.Error("d.PolicyGroup.Find error(%v)", err)
+		return
+	}
+	groups = append(groups, group)
+	if err = d.ItemsByGroup(groups); err != nil {
+		log.Error("d.ItemsByGroup.Find error(%v)", err)
+		return
+	}
+	if len(groups) != 0 {
+		group = groups[0]
+	}
+	return
+}
+
+// ArchiveGroups get archive's policy groups
+func (d *Dao) ArchiveGroups(c context.Context, aid int64) (groups []*oversea.PolicyGroup, err error) {
+	var (
+		db        = d.OverseaDB
+		relations []*oversea.ArchiveRelation
+		gids      []int64
+	)
+	err = db.Where("aid=?", aid).Find(&relations).Error
+	if err != nil {
+		log.Error("d.ArchiveGroups.Find error(%v)", err)
+		return
+	}
+	gids = make([]int64, len(relations))
+	for i, v := range relations {
+		gids[i] = v.GroupID
+	}
+	db = d.OverseaDB
+	err = db.Where(gids).Find(&groups).Error
+	if err != nil {
+		log.Error("d.ArchiveGroups.Find error(%v)", err)
+		return
+	}
+	err = d.ItemsByGroup(groups)
+	return
+}
+
+// ItemsByGroup get policy items into group
+func (d *Dao) ItemsByGroup(groups []*oversea.PolicyGroup) (err error) {
+	var (
+		items   []*oversea.PolicyItem
+		itemMap = make(map[int64][]*oversea.PolicyItem)
+	)
+	gids := make([]int64, len(groups))
+	for i, v := range groups {
+		gids[i] = v.ID
+	}
+	db := d.OverseaDB
+	err = db.Where("group_id in (?) and state=?", gids, oversea.StateOK).Find(&items).Error
+	if err != nil {
+		log.Error("d.ArchiveGroups.Find error(%v)", err)
+		return
+	}
+	for _, v := range items {
+		itemMap[v.GroupID] = append(itemMap[v.GroupID], v)
+	}
+	for i, g := range groups {
+		if _, ok := itemMap[g.ID]; !ok {
+			groups[i].Items = make([]*oversea.PolicyItem, 0)
+			continue
+		}
+		groups[i].Items = itemMap[g.ID]
+	}
+	return
+}
+
+// AddPolicyGroup add policy group
+func (d *Dao) AddPolicyGroup(c context.Context, group *oversea.PolicyGroup) (err error) {
+	var (
+		db = d.OverseaDB
+	)
+	group.IsGlobal = 1
+	group.Aid = 0
+	group.State = 1
+	err = db.Create(&group).Error
+	if err != nil {
+		group = &oversea.PolicyGroup{}
+		log.Error("d.AddPolicyGroup.Create error(%v)", err)
+	}
+	return
+}
+
+// UpdatePolicyGroup update policy group
+func (d *Dao) UpdatePolicyGroup(c context.Context, id int64, attrs map[string]interface{}) (err error) {
+	var (
+		db = d.OverseaDB
+	)
+	err = db.Model(&oversea.PolicyGroup{}).Where("id=?", id).Update(attrs).Error
+	if err != nil {
+		log.Error("d.UpdatePolicyGroup.Update error(%v)", err)
+	}
+	return
+}
+
+// UpdatePolicyGroups multi update policy groups
+func (d *Dao) UpdatePolicyGroups(c context.Context, ids []int64, attrs map[string]interface{}) (err error) {
+	var (
+		db = d.OverseaDB
+	)
+	err = db.Model(&oversea.PolicyGroup{}).Where(ids).Update(attrs).Error
+	if err != nil {
+		log.Error("d.UpdatePolicyGroup.Update error(%v)", err)
+	}
+	return
+}
+
+// PolicyItems get policy items
+func (d *Dao) PolicyItems(c context.Context, gid int64) (items []*oversea.PolicyItem, err error) {
+	err = d.OverseaDB.Where("group_id=? AND state=?", gid, oversea.StateOK).Find(&items).Error
+	return
+}
+
+// ZoneIDs get zone ids by area ids
+func (d *Dao) ZoneIDs(c context.Context, aids []int64) (ids []int64, err error) {
+	var items []*oversea.Zone
+	if err = d.OverseaDB.Where(aids).Find(&items).Pluck("zone_id", &ids).Error; err != nil {
+		log.Error("d.ZoneIDs.Find error(%v)", err)
+	}
+	return
+}
+
+// AddPolicies add policy items
+func (d *Dao) AddPolicies(c context.Context, policies []oversea.PolicyItem) (err error) {
+	var assign = map[string]interface{}{
+		"group_id":  0,
+		"play_auth": 0,
+		"down_auth": 0,
+		"area_id":   "",
+		"zone_id":   "",
+	}
+	for _, v := range policies {
+		if v.ID > 0 {
+			assign["group_id"] = v.GroupID
+			assign["play_auth"] = v.PlayAuth
+			assign["down_auth"] = v.DownAuth
+			assign["area_id"] = v.AreaID
+			assign["zone_id"] = v.ZoneID
+			err = d.OverseaDB.Model(&v).Where("id=?", v.ID).Update(assign).Error
+		} else {
+			err = d.OverseaDB.Create(&v).Error
+		}
+		if err != nil {
+			log.Error("d.AddPolicies.FirstOrCreate error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DelPolices soft delete policy items
+func (d *Dao) DelPolices(c context.Context, gid int64, ids []int64) (err error) {
+	err = d.OverseaDB.Debug().Model(&oversea.PolicyItem{}).Where(ids).Where("group_id=?", gid).Update("state", oversea.StateDeleted).Error
+	if err != nil {
+		log.Error("d.DelPolices.Update error(%v)", err)
+	}
+	return
+}

app/admin/main/videoup/dao/oversea/oversea_test.go

@@ -0,0 +1,51 @@
+package manager
+
+import (
+	"context"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func Test_UpArea(t *testing.T) {
+	Convey("UpArea", t, WithDao(func(d *Dao) {
+		_, err := d.UpPolicyRelation(context.TODO(), 1212121, 1)
+		So(err, ShouldBeNil)
+	}))
+}
+func Test_PolicyGroup(t *testing.T) {
+	Convey("PolicyGroup", t, WithDao(func(d *Dao) {
+		_, _, err := d.PolicyGroups(context.TODO(), 0, 0, 0, 0, 0, 0, "", "")
+		So(err, ShouldBeNil)
+	}))
+}
+func Test_PolicyRelation(t *testing.T) {
+	Convey("PolicyRelation", t, WithDao(func(d *Dao) {
+		_, err := d.PolicyRelation(context.TODO(), 1212121)
+		So(err, ShouldBeNil)
+	}))
+}
+func Test_PolicyGroupsByIds(t *testing.T) {
+	Convey("PolicyGroupsByIds", t, WithDao(func(d *Dao) {
+		_, err := d.PolicyGroupsByIds(context.TODO(), []int64{1212121})
+		So(err, ShouldBeNil)
+	}))
+}
+
+func Test_ArchiveGroups(t *testing.T) {
+	Convey("ArchiveGroups", t, WithDao(func(d *Dao) {
+		_, err := d.ArchiveGroups(context.TODO(), 1212121)
+		So(err, ShouldBeNil)
+	}))
+}
+func Test_PolicyItems(t *testing.T) {
+	Convey("ItemsByGroup", t, WithDao(func(d *Dao) {
+		_, err := d.PolicyItems(context.Background(), 1)
+		So(err, ShouldBeNil)
+	}))
+}
+func Test_ZoneIDs(t *testing.T) {
+	Convey("ZoneIDs", t, WithDao(func(d *Dao) {
+		_, err := d.ZoneIDs(context.TODO(), []int64{1212121})
+		So(err, ShouldBeNil)
+	}))
+}