Create & Init Project...

app/admin/main/card/service/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "card.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/admin/main/card/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/card/conf:go_default_library",
+        "//app/admin/main/card/dao:go_default_library",
+        "//app/admin/main/card/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["card_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/card/conf:go_default_library",
+        "//app/admin/main/card/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/card/service/card.go

@@ -0,0 +1,198 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/card/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+// CardsByGid get cards by gid.
+func (s *Service) CardsByGid(c context.Context, gid int64) ([]*model.Card, error) {
+	return s.dao.CardsByGid(c, gid)
+}
+
+// UpdateCardState update card state.
+func (s *Service) UpdateCardState(c context.Context, req *model.ArgState) error {
+	return s.dao.UpdateCardState(c, req.ID, req.State)
+}
+
+// DeleteCard delete card.
+func (s *Service) DeleteCard(c context.Context, id int64) error {
+	return s.dao.DeleteCard(c, id)
+}
+
+// UpdateGroupState update group state.
+func (s *Service) UpdateGroupState(c context.Context, req *model.ArgState) error {
+	return s.dao.UpdateGroupState(c, req.ID, req.State)
+}
+
+// DeleteGroup delete group.
+func (s *Service) DeleteGroup(c context.Context, id int64) error {
+	return s.dao.DeleteGroup(c, id)
+}
+
+// GroupList group list.
+func (s *Service) GroupList(c context.Context, req *model.ArgQueryGroup) (res []*model.CardGroup, err error) {
+	if res, err = s.dao.Groups(c, req); err != nil {
+		return
+	}
+	if len(res) <= 0 {
+		return
+	}
+	var cs []*model.Card
+	if cs, err = s.dao.Cards(c); err != nil {
+		return
+	}
+	tmp := make(map[int64][]*model.Card, len(res))
+	for _, v := range cs {
+		if len(tmp[v.GroupID]) <= 0 {
+			tmp[v.GroupID] = []*model.Card{}
+		}
+		tmp[v.GroupID] = append(tmp[v.GroupID], v)
+	}
+	for _, v := range res {
+		v.Cards = tmp[v.ID]
+	}
+	return
+}
+
+// CardOrderChange card order change.
+func (s *Service) CardOrderChange(c context.Context, req *model.ArgIds) (err error) {
+	var cs []*model.Card
+	if cs, err = s.dao.CardsByIds(c, req.Ids); err != nil {
+		return
+	}
+	if len(req.Ids) != len(cs) {
+		err = ecode.CardIDNotFoundErr
+		return
+	}
+	orders := make(map[int]*model.Card, len(cs))
+	for i, v := range cs {
+		orders[i] = v
+	}
+	us := []*model.Card{}
+	for i, v := range req.Ids {
+		if orders[i].ID != v {
+			us = append(us, &model.Card{ID: v, OrderNum: orders[i].OrderNum})
+		}
+	}
+	if len(us) > 0 {
+		err = s.dao.BatchUpdateCardOrder(c, us)
+	}
+	return
+}
+
+// GroupOrderChange group order change.
+func (s *Service) GroupOrderChange(c context.Context, req *model.ArgIds) (err error) {
+	var cs []*model.CardGroup
+	if cs, err = s.dao.GroupsByIds(c, req.Ids); err != nil {
+		return
+	}
+	if len(req.Ids) != len(cs) {
+		err = ecode.CardIDNotFoundErr
+		return
+	}
+	orders := make(map[int]*model.CardGroup, len(cs))
+	for i, v := range cs {
+		orders[i] = v
+	}
+	us := []*model.CardGroup{}
+	for i, v := range req.Ids {
+		if orders[i].ID != v {
+			us = append(us, &model.CardGroup{ID: v, OrderNum: orders[i].OrderNum})
+		}
+	}
+	if len(us) > 0 {
+		err = s.dao.BatchUpdateCardGroupOrder(c, us)
+	}
+	return
+}
+
+// AddCard add card.
+func (s *Service) AddCard(c context.Context, req *model.AddCard) (err error) {
+	var exist *model.Card
+	if exist, err = s.dao.CardByName(req.Name); err != nil || exist != nil {
+		return ecode.CardNameExistErr
+	}
+	var g errgroup.Group
+	g.Go(func() (err error) {
+		if req.CardURL, err = s.dao.Upload(c, "", req.CardFileType, req.CardBody, s.c.Bfs); err != nil {
+			log.Error("d.Upload iconURL(%+v) error(%v)", req, err)
+		}
+		return
+	})
+	g.Go(func() (err error) {
+		if req.BigCradURL, err = s.dao.Upload(c, "", req.BigCardFileType, req.BigCardBody, s.c.Bfs); err != nil {
+			log.Error("d.Upload bigCardURL(%+v) error(%v)", req, err)
+		}
+		return
+	})
+	if err = g.Wait(); err != nil {
+		return
+	}
+	if req.CardURL == "" || req.BigCradURL == "" {
+		err = ecode.CardFileUploadFaildErr
+		return
+	}
+	var order int64
+	if order, err = s.dao.MaxCardOrder(); err != nil {
+		return
+	}
+	order++
+	req.OrderNum = order
+	err = s.dao.AddCard(req)
+	return
+}
+
+// UpdateCard update card.
+func (s *Service) UpdateCard(c context.Context, req *model.UpdateCard) (err error) {
+	var g errgroup.Group
+	g.Go(func() (err error) {
+		if req.CardFileType != "" {
+			if req.CardURL, err = s.dao.Upload(c, "", req.CardFileType, req.CardBody, s.c.Bfs); err != nil {
+				log.Error("d.Upload iconURL(%+v) error(%v)", req, err)
+			}
+		}
+		return
+	})
+	g.Go(func() (err error) {
+		if req.BigCardFileType != "" {
+			if req.BigCradURL, err = s.dao.Upload(c, "", req.BigCardFileType, req.BigCardBody, s.c.Bfs); err != nil {
+				log.Error("d.Upload bigCardURL(%+v) error(%v)", req, err)
+			}
+		}
+		return
+	})
+	if err = g.Wait(); err != nil {
+		return
+	}
+	err = s.dao.UpdateCard(req)
+	return
+}
+
+// AddGroup add group.
+func (s *Service) AddGroup(c context.Context, req *model.AddGroup) (err error) {
+	var exist *model.CardGroup
+	if exist, err = s.dao.GroupByName(req.Name); err != nil {
+		log.Error("s.dao.GroupByName(%+v) error(%v)", req, err)
+		return
+	}
+	if exist != nil {
+		return ecode.CardGroupNameExistErr
+	}
+	var order int64
+	if order, err = s.dao.MaxGroupOrder(); err != nil {
+		return
+	}
+	order++
+	req.OrderNum = order
+	return s.dao.AddGroup(c, req)
+}
+
+// UpdateGroup update group.
+func (s *Service) UpdateGroup(c context.Context, req *model.UpdateGroup) error {
+	return s.dao.UpdateGroup(c, req)
+}

app/admin/main/card/service/card_test.go

@@ -0,0 +1,100 @@
+package service
+
+import (
+	"context"
+	"flag"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/card/conf"
+	"go-common/app/admin/main/card/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	c = context.TODO()
+	s *Service
+)
+
+func init() {
+	var (
+		err error
+	)
+	flag.Set("conf", "../cmd/test.toml")
+	if err = conf.Init(); err != nil {
+		panic(err)
+	}
+	c = context.Background()
+	if s == nil {
+		s = New(conf.Conf)
+	}
+	time.Sleep(time.Second)
+}
+
+// go test  -test.v -test.run TestCardsByGid
+func TestCardsByGid(t *testing.T) {
+	Convey("TestCardsByGid ", t, func() {
+		card, err := s.CardsByGid(c, 2)
+		t.Logf("v(%v)", card)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestUpdateCardState(t *testing.T) {
+	Convey("TestUpdateCardState ", t, func() {
+		err := s.UpdateCardState(c, &model.ArgState{ID: 1, State: 1})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDeleteCard(t *testing.T) {
+	Convey("TestDeleteCard ", t, func() {
+		err := s.DeleteCard(c, 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestUpdateGroupState(t *testing.T) {
+	Convey("TestUpdateGroupState ", t, func() {
+		err := s.UpdateGroupState(c, &model.ArgState{ID: 2, State: 1})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDeleteGroup(t *testing.T) {
+	Convey("TestDeleteGroup ", t, func() {
+		err := s.DeleteGroup(c, 2)
+		So(err, ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestGroupList
+func TestGroupList(t *testing.T) {
+	Convey("TestGroupList ", t, func() {
+		card, err := s.GroupList(c, &model.ArgQueryGroup{GroupID: 2})
+		t.Logf("v(%v)", card)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestCardOrderChange(t *testing.T) {
+	Convey("TestCardOrderChange ", t, func() {
+		err := s.CardOrderChange(c, &model.ArgIds{Ids: []int64{2, 3}})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestGroupOrderChange(t *testing.T) {
+	Convey("TestGroupOrderChange ", t, func() {
+		err := s.GroupOrderChange(c, &model.ArgIds{Ids: []int64{1}})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestAddGroup(t *testing.T) {
+	Convey("TestAddGroup ", t, func() {
+		err := s.AddGroup(c, &model.AddGroup{Name: "test17", State: 0})
+		So(err, ShouldBeNil)
+	})
+}

app/admin/main/card/service/service.go

@@ -0,0 +1,33 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/card/conf"
+	"go-common/app/admin/main/card/dao"
+)
+
+// Service struct
+type Service struct {
+	c   *conf.Config
+	dao *dao.Dao
+}
+
+// New init
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: dao.New(c),
+	}
+	return s
+}
+
+// Ping Service
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Close Service
+func (s *Service) Close() {
+	s.dao.Close()
+}