Create & Init Project...

app/admin/main/manager/service/BUILD

@@ -0,0 +1,62 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/manager/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "auth.go",
+        "business.go",
+        "department.go",
+        "journal.go",
+        "permit.go",
+        "rank.go",
+        "reason.go",
+        "service.go",
+        "tag.go",
+        "user.go",
+    ],
+    importpath = "go-common/app/admin/main/manager/service",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/manager/conf:go_default_library",
+        "//app/admin/main/manager/dao:go_default_library",
+        "//app/admin/main/manager/model: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",
+        "//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/manager/service/auth.go

@@ -0,0 +1,85 @@
+package service
+
+import (
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/log"
+)
+
+func (s *Service) authItems(typ int) (items []*model.AuthItem, err error) {
+	if err = s.dao.DB().Where("type = ?", typ).Find(&items).Error; err != nil {
+		log.Error("s.authItem(%d) error(%v)", typ, err)
+	}
+	return
+}
+
+func (s *Service) assigns(id int) (assigns []*model.AuthAssign, err error) {
+	if err = s.dao.DB().Where("item_id = ?", id).Find(&assigns).Error; err != nil {
+		log.Error("s.assigns(%d) error(%v)", id, err)
+	}
+	return
+}
+
+// admins
+func (s *Service) adms() (as map[int64]bool, err error) {
+	assigns, err := s.assigns(model.Admin)
+	if err != nil {
+		return
+	}
+	as = make(map[int64]bool)
+	for _, v := range assigns {
+		as[v.UserID] = true
+	}
+	return
+}
+
+// points
+func (s *Service) ptrs() (ps []*model.AuthItem, mps map[int64]*model.AuthItem, err error) {
+	ps, err = s.authItems(model.TypePointer)
+	if err != nil {
+		return
+	}
+	mps = make(map[int64]*model.AuthItem)
+	for _, v := range ps {
+		mps[v.ID] = v
+	}
+	return
+}
+
+func (s *Service) roleAuths() (ra map[int64][]int64, err error) {
+	var aic []*model.AuthItemChild
+	if err = s.dao.DB().Joins("left join auth_item on auth_item_child.parent=auth_item.id").Where("auth_item.type=?", model.TypeRole).Find(&aic).Error; err != nil {
+		log.Error("s.roleAuths() error(%v)", err)
+		return
+	}
+	ra = make(map[int64][]int64)
+	for _, v := range aic {
+		ra[v.Parent] = append(ra[v.Parent], v.Child)
+	}
+	return
+}
+
+func (s *Service) groupAuths() (ga map[int64][]int64, err error) {
+	var aic []*model.AuthItemChild
+	if err = s.dao.DB().Joins("left join auth_item on auth_item_child.parent=auth_item.id").Where("auth_item.type=?", model.TypeGroup).Find(&aic).Error; err != nil {
+		log.Error("s.groupAuths() error(%v)", err)
+		return
+	}
+	ga = make(map[int64][]int64)
+	for _, v := range aic {
+		ga[v.Parent] = append(ga[v.Parent], v.Child)
+	}
+	return
+}
+
+func (s *Service) orgAuths() (gsInfo map[int64]*model.AuthOrg, err error) {
+	var aic []*model.AuthOrg
+	if err = s.dao.DB().Where("auth_item.type IN (?,?)", model.TypeGroup, model.TypeRole).Find(&aic).Error; err != nil {
+		log.Error("s.groups() error(%v)", err)
+		return
+	}
+	gsInfo = make(map[int64]*model.AuthOrg)
+	for _, v := range aic {
+		gsInfo[v.ID] = v
+	}
+	return
+}

app/admin/main/manager/service/business.go

@@ -0,0 +1,563 @@
+package service
+
+import (
+	"context"
+	"sort"
+	"strconv"
+	"strings"
+
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// AddBusiness .
+func (s *Service) AddBusiness(c context.Context, b *model.Business) (err error) {
+	if err = s.dao.AddBusiness(c, b); err != nil {
+		log.Error("s.dao.AddBusiness error(%v)", err)
+	}
+	return
+}
+
+// UpdateBusiness .
+func (s *Service) UpdateBusiness(c context.Context, b *model.Business) (err error) {
+	flowState := []int64{}
+	binStr := strconv.FormatInt(b.Flow, 2)
+	for k, v := range []byte(binStr) {
+		if string(v) == "1" {
+			flowState = append(flowState, int64(len(binStr)-k))
+		}
+	}
+	if err = s.dao.BatchUpdateChildState(c, b.ID, flowState); err != nil {
+		log.Error("s.dao.BatchUpdateChildState error(%v)", err)
+		return
+	}
+	if err = s.dao.UpdateBusiness(c, b); err != nil {
+		log.Error("s.dao.UpdateBusiness error(%v)", err)
+	}
+	return
+}
+
+// AddRole .
+func (s *Service) AddRole(c context.Context, br *model.BusinessRole) (err error) {
+	var (
+		maxRid    interface{}
+		maxRidInt int64
+	)
+	if maxRid, err = s.dao.MaxRidByBid(c, br.BID); err != nil {
+		return
+	}
+	if maxRid != nil {
+		maxRidInt = maxRid.(int64)
+	}
+	maxRidInt++
+	br.RID = maxRidInt
+	if err = s.dao.AddRole(c, br); err != nil {
+		log.Error("s.dao.AddRole error(%v)", err)
+	}
+	return
+}
+
+// UpdateRole .
+func (s *Service) UpdateRole(c context.Context, br *model.BusinessRole) (err error) {
+	if err = s.dao.UpdateRole(c, br); err != nil {
+		log.Error("s.dao.UpdateRole error(%v)", err)
+	}
+	return
+}
+
+// AddUser .
+func (s *Service) AddUser(c context.Context, bur *model.BusinessUserRole) (err error) {
+	for _, uid := range bur.UIDs {
+		if _, ok := s.userNames[uid]; !ok {
+			err = ecode.ManagerUIDNOTExist
+			return
+		}
+	}
+	if err = s.dao.AddUser(c, bur); err != nil {
+		log.Error("s.dao.AddUser error(%v)", err)
+	}
+	return
+}
+
+// UpdateUser .
+func (s *Service) UpdateUser(c context.Context, bur *model.BusinessUserRole) (err error) {
+	if err = s.dao.UpdateUser(c, bur); err != nil {
+		log.Error("s.dao.Update error(%v)", err)
+	}
+	return
+}
+
+// UpdateState .
+func (s *Service) UpdateState(c context.Context, su *model.StateUpdate) (err error) {
+	var (
+		childInfo  *model.BusinessList
+		parentInfo *model.BusinessList
+	)
+	if su.Type == model.BusinessOpenType { // business
+		if su.State == model.BusinessOpenState {
+			if childInfo, err = s.dao.BusinessByID(c, su.ID); err != nil {
+				log.Error("s.dao.BusinessByID param id (%d) error(%v)", su.ID, err)
+				return
+			}
+			if childInfo.PID != 0 {
+				if parentInfo, err = s.dao.BusinessByID(c, childInfo.PID); err != nil {
+					log.Error("s.dao.BusinessByID param id (%d) error(%v)", childInfo, err)
+					return
+				}
+				flowState := map[int64]int64{}
+				binStr := strconv.FormatInt(parentInfo.Flow, 2)
+				for k, v := range []byte(binStr) {
+					if string(v) == "1" {
+						flowState[int64(len(binStr)-k)] = int64(len(binStr) - k)
+					}
+				}
+				if _, ok := flowState[childInfo.FlowState]; !ok {
+					err = ecode.ManagerFlowForbidden
+					return
+				}
+			}
+		}
+		if err = s.dao.UpdateBusinessState(c, su); err != nil {
+			log.Error("s.dao.UpdateBusinessState error(%v)", err)
+		}
+		return
+	}
+	// role
+	if err = s.dao.UpdateBusinessRoleState(c, su); err != nil {
+		log.Error("s.dao.UpdateBusinessRoleState error(%v)", err)
+	}
+	return
+}
+
+// BusinessList .
+func (s *Service) BusinessList(c context.Context, bp *model.BusinessListParams) (res []*model.BusinessList, err error) {
+	var (
+		pids        []int64
+		sKeys       []int
+		cKeys       []int
+		pidChildRes map[int64][]*model.BusinessList
+		fKeys       = make(map[int64][]int)
+		pidsMap     = make(map[int64]int64)
+		tempRes     = make(map[int64]*model.BusinessList)
+		childRes    = make(map[int64]*model.BusinessList)
+	)
+	flowBusinessMap := make(map[int64]map[int64][]*model.BusinessList)
+	if tempRes, err = s.dao.ParentBusiness(c, bp.State); err != nil {
+		log.Error("s.dao.ParentBusiness error(%v)", err)
+		return
+	}
+	if len(tempRes) <= 0 {
+		res = []*model.BusinessList{}
+		return
+	}
+	if childRes, err = s.dao.ChildBusiness(c, bp); err != nil {
+		log.Error("s.dao.ChildBusiness error(%v)", err)
+		return
+	}
+	for _, cr := range childRes {
+		cKeys = append(cKeys, int(cr.ID))
+	}
+	// auth verify
+	if bp.Auth > 0 {
+		up := &model.UserListParams{
+			UID:  bp.UID,
+			Role: model.UserRoleDefaultVal,
+		}
+		var userBusiness []*model.BusinessUserRoleList
+		if userBusiness, err = s.dao.UserList(c, up); err != nil {
+			log.Error("s.dao.UserList error(%v)", err)
+			return
+		}
+		if len(userBusiness) <= 0 {
+			res = []*model.BusinessList{}
+			return
+		}
+		bidsMap := make(map[int64]struct{})
+		for _, u := range userBusiness {
+			bidsMap[u.BID] = struct{}{}
+		}
+		cKeys = []int{}
+		for _, cr := range childRes {
+			if _, ok := bidsMap[cr.BID]; ok {
+				cKeys = append(cKeys, int(cr.ID))
+			}
+		}
+	}
+	sort.Ints(cKeys)
+	for _, c := range cKeys {
+		cidR := childRes[int64(c)]
+		if _, ok := pidsMap[cidR.PID]; !ok {
+			pidsMap[cidR.PID] = cidR.PID
+			pids = append(pids, cidR.PID)
+		}
+		cidR.FlowChild = []*model.FlowBusiness{}
+		if _, ok := flowBusinessMap[cidR.PID]; !ok {
+			flowBusinessMap[cidR.PID] = make(map[int64][]*model.BusinessList)
+		}
+		fKeys[cidR.PID] = append(fKeys[cidR.PID], int(cidR.FlowState))
+		flowBusinessMap[cidR.PID][cidR.FlowState] = append(flowBusinessMap[cidR.PID][cidR.FlowState], cidR)
+	}
+	if bp.Check != 0 {
+		if pidChildRes, err = s.dao.ChildBusinessByPIDs(c, pids); err != nil {
+			log.Error("s.dao.ChildBusinessByPIDs error(%v)", err)
+			return
+		}
+	}
+	for k, r := range tempRes {
+		r.FlowChild = []*model.FlowBusiness{}
+		if _, ok := pidChildRes[k]; !ok && bp.Check != 0 {
+			delete(tempRes, k)
+			continue
+		}
+		if _, ok := flowBusinessMap[k]; !ok && bp.Check != 0 {
+			continue
+		}
+		flowsMap := make(map[int]int)
+		flowsSlice := []int{}
+		if flows, ok := fKeys[r.ID]; ok {
+			for _, f := range flows {
+				if _, ok := flowsMap[f]; ok {
+					continue
+				}
+				flowsMap[f] = f
+				flowsSlice = append(flowsSlice, f)
+			}
+			sort.Ints(flowsSlice)
+			for _, f := range flowsSlice {
+				r.FlowChild = append(r.FlowChild, &model.FlowBusiness{
+					FlowState: int64(f),
+					Child:     flowBusinessMap[r.ID][int64(f)],
+				})
+			}
+		}
+		sKeys = append(sKeys, int(k))
+	}
+	sort.Ints(sKeys)
+	for _, k := range sKeys {
+		if _, ok := tempRes[int64(k)]; !ok {
+			continue
+		}
+		res = append(res, tempRes[int64(k)])
+	}
+	return
+}
+
+// FlowList .
+func (s *Service) FlowList(c context.Context, bp *model.BusinessListParams) (res []*model.BusinessList, err error) {
+	var (
+		tempRes = []*model.BusinessList{}
+		userRes = []*model.BusinessUserRoleList{}
+	)
+	res = []*model.BusinessList{}
+	if tempRes, err = s.dao.FlowList(c, bp); err != nil {
+		log.Error("s.dao.FlowList error(%v)", err)
+		return
+	}
+	if bp.Auth <= 0 {
+		res = tempRes
+		return
+	}
+	up := &model.UserListParams{
+		UID:  bp.UID,
+		Role: model.UserRoleDefaultVal,
+	}
+
+	if userRes, err = s.dao.UserList(c, up); err != nil {
+		log.Error("s.dao.UserList error(%v)", err)
+		return
+	}
+	if len(userRes) <= 0 {
+		return
+	}
+	tMap := make(map[int64]*model.BusinessList)
+	for _, t := range tempRes {
+		tMap[t.BID] = t
+	}
+	for _, u := range userRes {
+		if u.Role == "" {
+			continue
+		}
+		if t, ok := tMap[u.BID]; ok {
+			res = append(res, t)
+		}
+	}
+	return
+}
+
+// RoleList .
+func (s *Service) RoleList(c context.Context, br *model.BusinessRole) (res []*model.BusinessRole, err error) {
+	var (
+		rids       = []int{}
+		tempRes    = []*model.BusinessRole{}
+		userRes    = []*model.BusinessUserRoleList{}
+		tempResMap = make(map[int64]*model.BusinessRole)
+	)
+	res = []*model.BusinessRole{}
+	if tempRes, err = s.dao.RoleListByBID(c, br); err != nil {
+		log.Error("s.dao.RoleList error(%v)", err)
+		return
+	}
+	for _, tr := range tempRes {
+		rids = append(rids, int(tr.RID))
+		tempResMap[tr.RID] = tr
+	}
+	if br.Auth <= 0 {
+		res = tempRes
+		return
+	}
+	up := &model.UserListParams{
+		BID:  br.BID,
+		UID:  br.UID,
+		Role: model.UserRoleDefaultVal,
+	}
+	if userRes, err = s.dao.UserList(c, up); err != nil {
+		log.Error("s.dao.UserList error(%v)", err)
+		return
+	}
+	if len(userRes) <= 0 {
+		return
+	}
+	roleStr := userRes[0].Role
+	roleSlice := strings.Split(roleStr, ",")
+	sort.Ints(rids)
+	for _, r := range rids {
+		for _, rs := range roleSlice {
+			rsInt64, _ := strconv.ParseInt(rs, 10, 64)
+			if int64(r) == rsInt64 {
+				res = append(res, tempResMap[int64(r)])
+			}
+		}
+	}
+	return
+}
+
+// UserList .
+func (s *Service) UserList(c context.Context, u *model.UserListParams) (res []*model.BusinessUserRoleList, total int64, err error) {
+	if u.UName != "" {
+		if uid, ok := s.userIds[u.UName]; ok {
+			u.UID = uid
+		}
+	}
+	if res, err = s.dao.UserList(c, u); err != nil {
+		log.Error("s.dao.UserList error(%v)", err)
+		return
+	}
+	rids := []int64{}
+	for _, r := range res {
+		if uname, ok := s.userNames[r.UID]; ok {
+			r.UName = uname
+		}
+		if unickname, ok := s.userNicknames[r.UID]; ok {
+			r.UNickname = unickname
+		}
+		if cuname, ok := s.userNames[r.CUID]; ok {
+			r.CUName = cuname
+		}
+		roleSlice := strings.Split(r.Role, ",")
+		for _, ridStr := range roleSlice {
+			ridInt64, _ := strconv.ParseInt(ridStr, 10, 64)
+			rids = append(rids, ridInt64)
+		}
+	}
+	var roleRes []*model.BusinessRole
+	if roleRes, err = s.dao.RoleListByRIDs(c, u.BID, rids); err != nil {
+		log.Error("s.dao.RoleListByIDs error(%v)", err)
+		return
+	}
+	for _, r := range res {
+		r.RoleName = []string{}
+		rids := strings.Split(r.Role, ",")
+		for _, rid := range rids {
+			ridInt64, _ := strconv.ParseInt(rid, 10, 64)
+			for _, rr := range roleRes {
+				if ridInt64 == rr.RID && r.BID == rr.BID {
+					r.RoleName = append(r.RoleName, rr.Name)
+				}
+			}
+		}
+	}
+	total = int64(len(res))
+	start := (u.PN - 1) * u.PS
+	if start >= total {
+		res = []*model.BusinessUserRoleList{}
+		return
+	}
+	end := start + u.PS
+	if end > total {
+		end = total
+	}
+	res = res[start:end]
+	return
+}
+
+// DeleteUser .
+func (s *Service) DeleteUser(c context.Context, bur *model.BusinessUserRole) (err error) {
+	if err = s.dao.DeleteUser(c, bur); err != nil {
+		log.Error("s.dao.DeleteUser error(%v)", err)
+	}
+	return
+}
+
+// UserRole .
+func (s *Service) UserRole(c context.Context, brl *model.BusinessUserRoleList) (res []*model.UserRole, err error) {
+	var (
+		ridsInt64 []int64
+		userRole  []*model.BusinessUserRoleList
+		roleList  []*model.BusinessRole
+		u         = &model.UserListParams{
+			BID:  brl.BID,
+			UID:  brl.UID,
+			Role: -1,
+		}
+	)
+	if userRole, err = s.dao.UserList(c, u); err != nil {
+		log.Error("s.dao.UserList error(%v)", err)
+		return
+	}
+	if len(userRole) <= 0 {
+		res = []*model.UserRole{}
+		return
+	}
+	rids := strings.Split(userRole[0].Role, ",")
+	for _, rid := range rids {
+		ridInt64, _ := strconv.ParseInt(rid, 10, 64)
+		ridsInt64 = append(ridsInt64, ridInt64)
+	}
+	if roleList, err = s.dao.RoleListByRIDs(c, brl.BID, ridsInt64); err != nil {
+		log.Error("s.dao.RoleListByRIDs error(%v)", err)
+		return
+	}
+	for _, rid := range ridsInt64 {
+		for _, rl := range roleList {
+			if rid == rl.RID {
+				r := &model.UserRole{
+					ID:   rl.ID,
+					BID:  rl.BID,
+					RID:  rl.RID,
+					Type: rl.Type,
+					Name: rl.Name,
+				}
+				res = append(res, r)
+			}
+		}
+	}
+	return
+}
+
+// StateUp .
+func (s *Service) StateUp(c context.Context, p *model.UserStateUp) (err error) {
+	err = s.dao.DB().Table("manager_business_user_role").Where("bid = ? AND uid = ?", p.BID, p.AdminID).Update("state = ?", p.State).Error
+	return
+}
+
+// UserRoles .
+func (s *Service) UserRoles(c context.Context, uid int64) (res []*model.UserRole, err error) {
+	var roleRes []*model.BusinessUserRoleList
+	if roleRes, err = s.dao.UserRoles(c, uid); err != nil {
+		log.Error("s.dao.UserRoles error(%v)", err)
+		return
+	}
+	if len(roleRes) <= 0 {
+		res = []*model.UserRole{}
+		return
+	}
+	var roleList []*model.BusinessRole
+	for _, r := range roleRes {
+		bid := r.BID
+		rids := []int64{}
+		ridsStr := strings.Split(r.Role, ",")
+		for _, r := range ridsStr {
+			rid, _ := strconv.ParseInt(r, 10, 64)
+			rids = append(rids, rid)
+		}
+		var tmpRoleList []*model.BusinessRole
+		if tmpRoleList, err = s.dao.RoleListByRIDs(c, bid, rids); err != nil {
+			log.Error("s.dao.RoleListByRIDs error(%v)", err)
+			return
+		}
+		roleList = append(roleList, tmpRoleList...)
+	}
+	for _, rl := range roleList {
+		r := &model.UserRole{
+			ID:   rl.ID,
+			BID:  rl.BID,
+			RID:  rl.RID,
+			Type: rl.Type,
+			Name: rl.Name,
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// AllRoles .
+func (s *Service) AllRoles(c context.Context, pid, uid int64) (res []*model.UserRole, err error) {
+	var childs []*model.Business
+	if childs, err = s.dao.BusinessChilds(c, pid); err != nil {
+		log.Error("s.dao.BusinessChilds error(%v)", err)
+		return
+	}
+	var childIDs []int64
+	for _, c := range childs {
+		childIDs = append(childIDs, c.BID)
+	}
+	var roleRes []*model.BusinessUserRoleList
+	if roleRes, err = s.dao.UserRoleByBIDs(c, uid, childIDs); err != nil {
+		log.Error("s.dao.UserRoleByBIDs error(%v)", err)
+		return
+	}
+	if len(roleRes) <= 0 {
+		res = []*model.UserRole{}
+		return
+	}
+	var roleList []*model.BusinessRole
+	for _, r := range roleRes {
+		bid := r.BID
+		rids := []int64{}
+		ridsStr := strings.Split(r.Role, ",")
+		for _, r := range ridsStr {
+			rid, _ := strconv.ParseInt(r, 10, 64)
+			rids = append(rids, rid)
+		}
+		var tmpRoleList []*model.BusinessRole
+		if tmpRoleList, err = s.dao.RoleListByRIDs(c, bid, rids); err != nil {
+			log.Error("s.dao.RoleListByRIDs error(%v)", err)
+			return
+		}
+		roleList = append(roleList, tmpRoleList...)
+	}
+	for _, rl := range roleList {
+		r := &model.UserRole{
+			ID:   rl.ID,
+			BID:  rl.BID,
+			RID:  rl.RID,
+			Type: rl.Type,
+			Name: rl.Name,
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// IsAdmin .
+func (s *Service) IsAdmin(c context.Context, bid, uid int64) bool {
+	var (
+		err error
+		res []*model.UserRole
+	)
+	p := &model.BusinessUserRoleList{
+		BID: bid,
+		UID: uid,
+	}
+	if res, err = s.UserRole(c, p); err != nil {
+		log.Error("s.UserRole error(%v)", err)
+		return false
+	}
+	for _, r := range res {
+		if r.Type == 1 {
+			return true
+		}
+	}
+	return false
+}

app/admin/main/manager/service/department.go

@@ -0,0 +1,49 @@
+package service
+
+import (
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Departments .
+func (s *Service) Departments(c *bm.Context) (res []*model.DepartCustom, err error) {
+	if err = s.dao.DB().Table("user_department").Where("status = ?", model.ValidateState).Find(&res).Error; err != nil {
+		log.Error("s.Departments err (%v)", err)
+	}
+	return
+}
+
+// Roles .
+func (s *Service) Roles(c *bm.Context) (res []*model.RoleCustom, err error) {
+	if err = s.dao.DB().Table("auth_item").Where("type = ?", model.TypeRole).Find(&res).Error; err != nil {
+		log.Error("s.Roles error (%v)", err)
+	}
+	return
+}
+
+// UsersByDepartment .
+func (s *Service) UsersByDepartment(c *bm.Context, ID int64) (res []*model.UserCustom, err error) {
+	if err = s.dao.DB().Table("user").Where("state =? and department_id = ?", model.ValidateState, ID).Find(&res).Error; err != nil {
+		log.Error("s.UsersByDepartment ID (%d) error (%v)", ID, err)
+	}
+	return
+}
+
+// UsersByRole .
+func (s *Service) UsersByRole(c *bm.Context, ID int64) (res []*model.UserCustom, err error) {
+	resAuthAssign := []*model.AuthAssign{}
+	if err = s.dao.DB().Table("auth_assignment").Where("item_id = ?", ID).Find(&resAuthAssign).Error; err != nil {
+		log.Error("s.UsersByRole ID (%d) error (%v)", ID, err)
+		return
+	}
+	for _, v := range resAuthAssign {
+		temp := &model.UserCustom{
+			ID:       v.UserID,
+			Username: s.userNames[v.UserID],
+			Nickname: s.userNicknames[v.UserID],
+		}
+		res = append(res, temp)
+	}
+	return
+}

app/admin/main/manager/service/journal.go

@@ -0,0 +1,138 @@
+package service
+
+import (
+	"bytes"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// SearchLogAudit .
+func (s *Service) SearchLogAudit(c *bm.Context) (result []byte, err error) {
+	var (
+		res *model.LogRes
+	)
+	if res, err = s.dao.SearchLogAudit(c); err != nil {
+		log.Error("s.dao.SearchLogAduit error (%v)", err)
+		return
+	}
+	result, err = outData(res)
+	return
+}
+
+// SearchLogAction .
+func (s *Service) SearchLogAction(c *bm.Context) (result []byte, err error) {
+	var (
+		res *model.LogRes
+	)
+	if res, err = s.dao.SearchLogAction(c); err != nil {
+		log.Error("s.dao.SearchLogAduit error (%v)", err)
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		log.Error("res.Code error (%d)", res.Code)
+		return
+	}
+	result, err = outData(res)
+	return
+}
+
+// OutData .
+func outData(res *model.LogRes) (result []byte, err error) {
+	var resultMap []map[string]interface{}
+	//Output the data
+	for _, j := range res.Data.Result {
+		item := map[string]interface{}{}
+		decoder := json.NewDecoder(bytes.NewReader(j))
+		decoder.UseNumber()
+		decoder.Decode(&item)
+		item = numberToInt64(item)
+		resultMap = append(resultMap, item)
+	}
+
+	for parentKey, parentValue := range resultMap {
+		if extraValue, ok := parentValue["extra_data"]; ok {
+			if extraData, ok := extraValue.(string); ok {
+				p := make(map[string]interface{})
+				if e := json.Unmarshal([]byte(extraData), &p); e == nil {
+					for childKey, childValue := range backtrace(p) {
+						resultMap[parentKey][childKey] = childValue
+					}
+				}
+			}
+		}
+	}
+
+	titleMap := make(map[string]string)
+	// Iterator title collections
+	for _, v := range resultMap {
+		for key := range v {
+			titleMap[key] = key
+		}
+	}
+	// Get the titles
+	titleStr := []string{}
+	for _, v := range titleMap {
+		titleStr = append(titleStr, v)
+	}
+	data := [][]string{}
+	data = append(data, titleStr)
+	for _, value := range resultMap {
+		fields := []string{}
+		for _, parentTitle := range titleStr {
+			if value[parentTitle] != nil {
+				fields = append(fields, fmt.Sprintf("%v", value[parentTitle]))
+			} else {
+				fields = append(fields, "")
+			}
+		}
+		data = append(data, fields)
+	}
+	buf := bytes.NewBuffer(nil)
+	w := csv.NewWriter(buf)
+	for _, record := range data {
+		if err = w.Write(record); err != nil {
+			log.Error("w Write (%v) error (%v)", record, err)
+			return
+		}
+	}
+	w.Flush()
+	result = buf.Bytes()
+	return
+}
+
+// backtrace .
+func backtrace(in map[string]interface{}) (out map[string]interface{}) {
+	out = make(map[string]interface{})
+	for k, v := range in {
+		if z, ok := v.(map[string]interface{}); ok {
+			for childKey, childValue := range backtrace(z) {
+				out[childKey] = childValue
+			}
+		} else {
+			out[k] = v
+		}
+	}
+	return
+}
+
+// numberToInt64 .
+func numberToInt64(in map[string]interface{}) (out map[string]interface{}) {
+	var err error
+	out = map[string]interface{}{}
+	for k, v := range in {
+		if integer, ok := v.(json.Number); ok {
+			if out[k], err = integer.Int64(); err != nil {
+				log.Error("service.log.numberToInt64(%v)(%v)", integer, err)
+			}
+		} else {
+			out[k] = v
+		}
+	}
+	return
+}

app/admin/main/manager/service/permit.go

@@ -0,0 +1,44 @@
+package service
+
+import (
+	"context"
+
+	"go-common/library/log"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+const (
+	_sessUnKey  = "username"
+	_sessUIDKey = "uid"
+)
+
+// Login .
+func (s *Service) Login(ctx context.Context, mngsid, dsbsid string) (sid, uname string, err error) {
+	si := s.session(ctx, mngsid)
+	var username string
+	if si.Get(_sessUnKey) == nil {
+		if username, err = s.dao.VerifyDsb(ctx, dsbsid); err != nil {
+			log.Error("s.dao.VerifyDsb error(%v)", err)
+			return
+		}
+		si.Set(_sessUnKey, username)
+		si.Set(_sessUIDKey, s.userIds[username])
+		if err = s.dao.SetSession(ctx, si); err != nil {
+			log.Error("s.dao.SetSession(%v) error(%v)", si, err)
+			err = nil
+		}
+	} else {
+		username = si.Get(_sessUnKey).(string)
+	}
+	sid = si.Sid
+	uname = username
+	return
+}
+
+// session .
+func (s *Service) session(ctx context.Context, sid string) (res *permit.Session) {
+	if res, _ = s.dao.Session(ctx, sid); res == nil {
+		res = s.dao.NewSession(ctx)
+	}
+	return
+}

app/admin/main/manager/service/rank.go

@@ -0,0 +1,218 @@
+package service
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/log"
+)
+
+// RankGroups gets archive groups.
+func (s *Service) RankGroups(c context.Context, pn, ps int) (res []*model.RankGroup, total int, err error) {
+	start := (pn - 1) * ps
+	if err = s.dao.DB().Where("isdel=0").Offset(start).Limit(ps).Find(&res).Error; err != nil {
+		log.Error("s.RankGroups() get groups error(%v)", err)
+		return
+	}
+	if err = s.dao.DB().Model(&model.RankGroup{}).Where("isdel=0").Count(&total).Error; err != nil {
+		log.Error("s.RankGroups() get total error(%v)", err)
+		return
+	}
+	// todo 优化，合并查询
+	for _, g := range res {
+		g.Auths, _ = s.rankAuths(c, g.ID)
+	}
+	return
+}
+
+// RankGroup gets rank group info.
+func (s *Service) RankGroup(c context.Context, id int64) (res *model.RankGroup, err error) {
+	res = new(model.RankGroup)
+	if err = s.dao.DB().Where("id=? and isdel=0", id).First(res).Error; err != nil {
+		log.Error("s.RankGroup(%d) error(%v)", id, err)
+		return
+	}
+	res.Auths, _ = s.rankAuths(c, id)
+	return
+}
+
+// AddRankGroup adds rank group.
+func (s *Service) AddRankGroup(c context.Context, g *model.RankGroup, auths []int64) (id int64, err error) {
+	if err = s.dao.DB().Create(g).Error; err != nil {
+		log.Error("s.AddRankGroup(%+v) error(%v)", g, err)
+		return
+	}
+	id = g.ID
+	for _, a := range auths {
+		if err = s.dao.DB().Exec("insert into rank_auths (group_id,auth_id,isdel) values (?,?,0)", id, a).Error; err != nil {
+			log.Error("s.AddRankGroup(%d,%d) add auth error(%v)", id, a, err)
+			return
+		}
+	}
+	return
+}
+
+// UpdateRankGroup udpates rank group.
+func (s *Service) UpdateRankGroup(c context.Context, g *model.RankGroup, auths []int64) (err error) {
+	if err = s.dao.DB().Model(g).Update(g).Error; err != nil {
+		log.Error("s.UpdateRankGroup(%+v) error(%v)", g, err)
+		return
+	}
+	// todo 优化，找出差异auth，多了删，少了加
+	if err = s.delRankAuthAll(c, g.ID); err != nil {
+		log.Error("s.delRankAuthAll(%d) error(%d)", g.ID, err)
+		return
+	}
+	for _, a := range auths {
+		if err = s.dao.DB().Exec("insert into rank_auths (group_id,auth_id,isdel) values (?,?,0) on duplicate key update isdel=0", g.ID, a).Error; err != nil {
+			log.Error("s.UpdateRankGroup(%d,%d) add auth error(%v)", g.ID, a, err)
+			return
+		}
+	}
+	return
+}
+
+// DelRankGroup deletes rank group...
+func (s *Service) DelRankGroup(c context.Context, id int64) (err error) {
+	if err = s.delRankAuthAll(c, id); err != nil {
+		log.Error("s.delRankAuthAll(%d) error(%v)", id, err)
+		return
+	}
+	if err = s.dao.DB().Model(&model.RankGroup{ID: id}).Update("isdel", 1).Error; err != nil {
+		log.Error("s.DelRankGroup(%d) error(%v)", id, err)
+	}
+	return
+}
+
+// AddRankUser adds rank user.
+func (s *Service) AddRankUser(c context.Context, uid int64) (err error) {
+	if err = s.dao.DB().Create(&model.RankUser{UID: uid}).Error; err != nil {
+		log.Error("s.AddRankUser(%d) error(%v)", uid, err)
+	}
+	return
+}
+
+// RankUsers gets rank user list.
+func (s *Service) RankUsers(c context.Context, pn, ps int, username string) (res []*model.RankUserScores, total int, err error) {
+	var (
+		tmpUids, uids, ids []int64
+		users              []*model.RankUser
+	)
+	if username != "" {
+		var (
+			us        []*model.User
+			condition = fmt.Sprintf("%%%s%%", username)
+		)
+		if err = s.dao.DB().Where("username like ?", condition).Find(&us).Error; err != nil {
+			log.Error("s.RankUsers search by username(%s) error(%v)", username, err)
+			return
+		}
+		for _, u := range us {
+			ids = append(ids, u.ID)
+		}
+	}
+	if len(ids) > 0 {
+		err = s.dao.DB().Where("uid in(?) and isdel=0", ids).Find(&users).Error
+	} else {
+		err = s.dao.DB().Where("isdel=0").Find(&users).Error
+	}
+	if err != nil {
+		log.Error("s.RankUsers() get groups error(%v)", err)
+		return
+	}
+	us := make(map[int64]map[int64]int)
+	for _, u := range users {
+		tmpUids = append(tmpUids, u.UID)
+		if us[u.UID] == nil {
+			us[u.UID] = make(map[int64]int)
+		}
+		if u.GroupID == 0 {
+			continue
+		}
+		us[u.UID][u.GroupID] = u.Rank
+	}
+	dic := make(map[int64]bool)
+	for _, i := range tmpUids {
+		if !dic[i] {
+			dic[i] = true
+			uids = append(uids, i)
+		}
+	}
+	names, err := s.usernames(uids)
+	if err != nil {
+		return
+	}
+	for _, uid := range uids {
+		if names[uid] == nil {
+			continue
+		}
+		u := &model.RankUserScores{
+			UID:      uid,
+			Username: names[uid].Username,
+			Nickname: names[uid].Nickname,
+			Ranks:    us[uid],
+		}
+		res = append(res, u)
+	}
+	total = len(res)
+	start := (pn - 1) * ps
+	if start >= total {
+		res = []*model.RankUserScores{}
+		return
+	}
+	end := start + ps
+	if end > total {
+		end = total
+	}
+	res = res[start:end]
+	return
+}
+
+func (s *Service) usernames(uids []int64) (res map[int64]*model.User, err error) {
+	var users []*model.User
+	if err = s.dao.DB().Model(&model.User{}).Where("id in (?)", uids).Find(&users).Error; err != nil {
+		log.Error("s.username(%v) error(%v)", uids, err)
+		return
+	}
+	res = make(map[int64]*model.User, len(users))
+	for _, u := range users {
+		res[u.ID] = u
+	}
+	return
+}
+
+// SaveRankUser saves user group's rank.
+func (s *Service) SaveRankUser(c context.Context, uid int64, ranks map[int64]int) (err error) {
+	for gid, rank := range ranks {
+		if err = s.dao.DB().Exec("insert into rank_users (group_id,uid,rank) values (?,?,?) on duplicate key update rank=?,isdel=0", gid, uid, rank, rank).Error; err != nil {
+			log.Error("s.SaveRankUser(%d,%d,%d) save user rank error(%v)", gid, uid, rank, err)
+			return
+		}
+	}
+	return
+}
+
+// DelRankUser deletes user.
+func (s *Service) DelRankUser(c context.Context, uid int64) (err error) {
+	if err = s.dao.DB().Model(&model.RankUser{}).Where("uid=?", uid).Update("isdel", 1).Error; err != nil {
+		log.Error("s.DelRankUser(%d) error(%v)", uid, err)
+	}
+	return
+}
+
+// delRankAuthAll deletes all rank auths by group.
+func (s *Service) delRankAuthAll(c context.Context, gid int64) (err error) {
+	if err = s.dao.DB().Model(&model.RankAuth{}).Where("group_id=?", gid).Update("isdel", 1).Error; err != nil {
+		log.Error("s.DelRankAuthAll(%d) error(%v)", gid, err)
+	}
+	return
+}
+
+// rankAuths gets auths by group.
+func (s *Service) rankAuths(c context.Context, gid int64) (res []*model.AuthItem, err error) {
+	if err = s.dao.DB().Model(&model.RankAuth{}).Where("group_id=? and isdel=0", gid).Select("auth_item.id, auth_item.name, auth_item.data").Joins("left join auth_item on auth_item.id=rank_auths.auth_id").Scan(&res).Error; err != nil {
+		log.Error("s.RankAuths(%d) error(%v)", gid, err)
+	}
+	return
+}

app/admin/main/manager/service/reason.go

@@ -0,0 +1,329 @@
+package service
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+// CateSecExtList .
+func (s *Service) CateSecExtList(c context.Context, e *model.CateSecExt) (res []*model.CateSecExt, err error) {
+	if res, err = s.dao.CateSecExtList(c, e); err != nil {
+		log.Error("s.CateSecExtList type (%d) error (%v)", e.Type, err)
+	}
+	return
+}
+
+// AssociationList .
+func (s *Service) AssociationList(c context.Context, e *model.Association) (res []*model.Association, err error) {
+	var (
+		aRes       []*model.Association
+		rRes       []*model.BusinessRole
+		catesecRes []*model.CateSecExt
+	)
+	// Display all record of Association
+	if aRes, err = s.dao.AssociationList(c, model.AllState, e.BusinessID); err != nil {
+		log.Error("s.AssociationList error (%v)", err)
+		return
+	}
+	if len(aRes) <= 0 {
+		res = []*model.Association{}
+		return
+	}
+	// Get all mapping of role
+	rMap := make(map[int64]string)
+	bean := &model.BusinessRole{
+		BID:   e.BusinessID,
+		Type:  model.AllType,
+		State: model.AllState,
+	}
+	if rRes, err = s.dao.RoleListByBID(c, bean); err != nil {
+		log.Error("s.RoleListByBID error (%v)", err)
+		return
+	}
+	for _, r := range rRes {
+		rMap[r.RID] = r.Name
+	}
+	// GET all mapping of category and second
+	cMap := make(map[int64]string)
+	sMap := make(map[int64]*model.CateSecExt)
+	if catesecRes, err = s.dao.CateSecList(c, e.BusinessID); err != nil {
+		log.Error("s.CateSecList error (%v)", err)
+		return
+	}
+	for _, cs := range catesecRes {
+		if cs.Type == model.CategoryCode {
+			cMap[cs.ID] = cs.Name
+		} else if cs.Type == model.SecondeCode {
+			sMap[cs.ID] = cs
+		}
+	}
+	res = []*model.Association{}
+	for _, value := range aRes {
+		temp := &model.Association{
+			ID:           value.ID,
+			RoleID:       value.RoleID,
+			BusinessID:   value.BusinessID,
+			RoleName:     rMap[value.RoleID],
+			CategoryID:   value.CategoryID,
+			CategoryName: cMap[value.CategoryID],
+			SecondIDs:    value.SecondIDs,
+			Ctime:        value.Ctime,
+			Mtime:        value.Mtime,
+			State:        value.State,
+		}
+		sids := strings.Split(value.SecondIDs, ",")
+		temp.Child = []*model.CateSecExt{}
+		if sids[0] != "" {
+			for _, sid := range sids {
+				id, _ := strconv.ParseInt(sid, 10, 64)
+				if value, ok := sMap[id]; ok {
+					temp.Child = append(temp.Child, value)
+				}
+			}
+		}
+		res = append(res, temp)
+	}
+	return
+}
+
+// AddCateSecExt .
+func (s *Service) AddCateSecExt(c context.Context, arg *model.CateSecExt) (err error) {
+	if err = s.dao.AddCateSecExt(c, arg); err != nil {
+		log.Error("s.AddCateSecExt (%s) error (%v)", arg.Name, err)
+	}
+	return
+}
+
+// UpdateCateSecExt .
+func (s *Service) UpdateCateSecExt(c context.Context, arg *model.CateSecExt) (err error) {
+	if err = s.dao.UpdateCateSecExt(c, arg); err != nil {
+		log.Error("s.UpdateCateSecExt (%s) error (%v)", arg.Name, err)
+	}
+	return
+}
+
+// BanCateSecExt .
+func (s *Service) BanCateSecExt(c context.Context, arg *model.CateSecExt) (err error) {
+	if err = s.dao.BanCateSecExt(c, arg); err != nil {
+		log.Error("s.BanCateSecExt (%d) error (%v)", arg.ID, err)
+	}
+	return
+}
+
+// AddAssociation .
+func (s *Service) AddAssociation(c context.Context, arg *model.Association) (err error) {
+	if err = s.dao.AddAssociation(c, arg); err != nil {
+		log.Error("s.AddAssociation error %v", err)
+	}
+	return
+}
+
+// UpdateAssociation .
+func (s *Service) UpdateAssociation(c context.Context, arg *model.Association) (err error) {
+	if err = s.dao.UpdateAssociation(c, arg); err != nil {
+		log.Error("s.UpdateAssociation error %v", err)
+	}
+	return
+}
+
+// BanAssociation .
+func (s *Service) BanAssociation(c context.Context, arg *model.Association) (err error) {
+	if err = s.dao.BanAssociation(c, arg); err != nil {
+		log.Error("s.BanAssociation error %v", err)
+	}
+	return
+}
+
+// AddReason .
+func (s *Service) AddReason(c context.Context, arg *model.Reason) (err error) {
+	if err = s.dao.AddReason(c, arg); err != nil {
+		log.Error("s.AddReason (%v) error (%v)", arg, err)
+	}
+	return
+}
+
+// UpdateReason .
+func (s *Service) UpdateReason(c context.Context, arg *model.Reason) (err error) {
+	if err = s.dao.UpdateReason(c, arg); err != nil {
+		log.Error("s.UpdateReason (%v) error (%v)", arg, err)
+	}
+	return
+}
+
+// ReasonList .
+func (s *Service) ReasonList(c context.Context, e *model.SearchReasonParams) (res []*model.Reason, total int64, err error) {
+	var (
+		rids  []int64
+		csids []int64
+		eRes  map[int64]*model.BusinessRole
+		csRes map[int64]string
+	)
+	// Search the user_id
+	if e.UName != "" {
+		if userID, ok := s.userIds[e.UName]; ok {
+			e.UID = userID
+		}
+	}
+	if res, err = s.dao.ReasonList(c, e); err != nil {
+		log.Error("s.dao.ReasonList error (%v)", err)
+		return
+	}
+	if len(res) <= 0 {
+		return
+	}
+	// Search relation data
+	for _, r := range res {
+		rids = append(rids, r.RoleID)
+		csids = append(csids, r.CategoryID)
+		csids = append(csids, r.SecondID)
+	}
+	if eRes, err = s.dao.RoleByRIDs(c, e.BusinessID, rids); err != nil {
+		log.Error("s.dao.ExecutorByIDs error (%v)", err)
+		return
+	}
+	if csRes, err = s.dao.CateSecByIDs(c, csids); err != nil {
+		log.Error("s.dao.CateSecByIDs error (%v)", err)
+		return
+	}
+	for _, value := range res {
+		if r, ok := eRes[value.RoleID]; ok {
+			value.RoleName = r.Name
+		}
+		if c, ok := csRes[value.CategoryID]; ok {
+			value.CategoryName = c
+		}
+		if s, ok := csRes[value.SecondID]; ok {
+			value.SecondName = s
+		}
+		if u, ok := s.userNames[value.UID]; ok {
+			value.UName = u
+		}
+	}
+	total = int64(len(res))
+	start := (e.PN - 1) * e.PS
+	if start >= total {
+		res = []*model.Reason{}
+		return
+	}
+	end := start + e.PS
+	if end > total {
+		end = total
+	}
+	res = res[start:end]
+	return
+}
+
+// BatchUpdateReasonState .
+func (s *Service) BatchUpdateReasonState(c context.Context, b *model.BatchUpdateReasonState) (err error) {
+	if err = s.dao.BatchUpdateReasonState(c, b); err != nil {
+		log.Error("s.dao.BatchUpdateReasonState %v error (%v)", b.IDs, err)
+	}
+	return
+}
+
+// DropDownList .
+func (s *Service) DropDownList(c context.Context, e *model.Association) (res []*model.DropList, err error) {
+	var (
+		aRes  []*model.Association
+		rRes  []*model.BusinessRole
+		csRes []*model.CateSecExt
+	)
+	// Only display validate association
+	if aRes, err = s.dao.AssociationList(c, model.ValidateState, e.BusinessID); err != nil {
+		log.Error("s.AssociationList error (%v)", err)
+		return
+	}
+	// Get all association record
+	rMap := make(map[int64]string)
+	bean := &model.BusinessRole{
+		BID:   e.BusinessID,
+		Type:  model.AllType,
+		State: model.AllState,
+	}
+	if rRes, err = s.dao.RoleListByBID(c, bean); err != nil {
+		log.Error("s.RoleListByBID error (%v)", err)
+		return
+	}
+	for _, r := range rRes {
+		rMap[r.RID] = r.Name
+	}
+	// Get all mapping of category and second
+	csMap := make(map[int64]string)
+	if csRes, err = s.dao.CateSecList(c, e.BusinessID); err != nil {
+		log.Error("s.CateSecList error (%v)", err)
+		return
+	}
+	for _, cs := range csRes {
+		csMap[cs.ID] = cs.Name
+	}
+	// Mapping data,use map store unique data
+	resMap := make(map[int64]map[int64]map[int64]int64)
+	for _, v := range aRes {
+		if _, ok := resMap[v.RoleID]; !ok {
+			//first element
+			resMap[v.RoleID] = make(map[int64]map[int64]int64)
+		}
+		if _, ok := resMap[v.RoleID][v.CategoryID]; !ok {
+			resMap[v.RoleID][v.CategoryID] = make(map[int64]int64)
+		}
+		sids := strings.Split(v.SecondIDs, ",")
+		for _, sid := range sids {
+			id, _ := strconv.ParseInt(sid, 10, 64)
+			resMap[v.RoleID][v.CategoryID][id] = id
+		}
+	}
+	// Output the data
+	res = []*model.DropList{}
+	for keyR, valueR := range resMap {
+		temprRes := &model.DropList{
+			ID:   keyR,
+			Name: rMap[keyR],
+		}
+		childCategory := []*model.DropList{}
+		for keyC, valueC := range valueR {
+			tempcRes := &model.DropList{
+				ID:   keyC,
+				Name: csMap[keyC],
+			}
+			childSecond := []*model.DropList{}
+			for keyS, valueS := range valueC {
+				tempsRes := &model.DropList{
+					ID:    keyS,
+					Name:  csMap[valueS],
+					Child: []*model.DropList{},
+				}
+				childSecond = append(childSecond, tempsRes)
+			}
+			tempcRes.Child = childSecond
+			childCategory = append(childCategory, tempcRes)
+		}
+		temprRes.Child = childCategory
+		res = append(res, temprRes)
+	}
+	return
+}
+
+// BusinessAttr .
+func (s *Service) BusinessAttr(c context.Context, b *model.BusinessAttr) (res map[string]bool, err error) {
+	res = make(map[string]bool)
+	res["isTag"] = false
+	var tempRes []*model.CateSecExt
+	if tempRes, err = s.dao.CateSecList(c, b.BID); err != nil {
+		if err == gorm.ErrRecordNotFound {
+			err = nil
+		}
+		return
+	}
+	for _, tr := range tempRes {
+		if tr.Type == model.ExtensionCode && tr.State == 1 {
+			res["isTag"] = true
+		}
+	}
+	return
+}

app/admin/main/manager/service/service.go

@@ -0,0 +1,90 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/manager/conf"
+	"go-common/app/admin/main/manager/dao"
+	"go-common/app/admin/main/manager/model"
+)
+
+// Service biz service def.
+type Service struct {
+	c   *conf.Config
+	dao *dao.Dao
+	// rbac may not change frequent, can update every few seconds. only assignment must get from db.
+	points        map[int64]*model.AuthItem
+	pointList     []*model.AuthItem
+	groupAuth     map[int64][]int64
+	orgAuth       map[int64]*model.AuthOrg // group + role info
+	roleAuth      map[int64][]int64
+	admins        map[int64]bool
+	userNames     map[int64]string // users' name
+	userNicknames map[int64]string // user's nickname
+	userDeps      map[int64]string // users' department
+	userIds       map[string]int64 // users' ids
+}
+
+// New new a Service and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: dao.New(c),
+	}
+	s.syncRbac()
+	s.loadUnames()
+	go s.syncRbacproc()
+	go s.loadUnamesproc()
+	return s
+}
+
+func (s *Service) syncRbacproc() {
+	for {
+		time.Sleep(time.Second * 10)
+		s.syncRbac()
+	}
+}
+
+func (s *Service) syncRbac() {
+	if points, mpoints, err := s.ptrs(); err != nil {
+		return
+	} else if len(mpoints) > 0 {
+		s.pointList = points
+		s.points = mpoints
+	}
+	if admins, err := s.adms(); err != nil {
+		return
+	} else if len(admins) > 0 {
+		s.admins = admins
+	}
+	if ra, err := s.roleAuths(); err != nil {
+		return
+	} else if len(ra) > 0 {
+		s.roleAuth = ra
+	}
+	if ga, err := s.groupAuths(); err != nil {
+		return
+	} else if len(ga) > 0 {
+		s.groupAuth = ga
+	}
+	if oa, err := s.orgAuths(); err != nil {
+		return
+	} else if len(oa) > 0 {
+		s.orgAuth = oa
+	}
+}
+
+// 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/manager/service/service_test.go

@@ -0,0 +1,130 @@
+package service
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/manager/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	srv *Service
+	ctx = context.Background()
+)
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/manager-admin-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	srv = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		// Reset(func() { CleanCache() })
+		f(srv)
+	}
+}
+
+func Test_Admins(t *testing.T) {
+	Convey("admins", t, WithService(func(s *Service) {
+		res, err := s.adms()
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+		t.Logf("admins len(%d)", len(res))
+	}))
+}
+
+func Test_Pointers(t *testing.T) {
+	Convey("pointers", t, WithService(func(s *Service) {
+		res, _, err := s.ptrs()
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+		t.Logf("points len(%d)", len(res))
+	}))
+}
+
+func Test_RoleAuths(t *testing.T) {
+	Convey("role auths", t, WithService(func(s *Service) {
+		res, err := s.roleAuths()
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+		t.Logf("role auths len(%d)", len(res))
+	}))
+}
+
+func Test_GroupAuths(t *testing.T) {
+	Convey("group auths", t, WithService(func(s *Service) {
+		res, err := s.groupAuths()
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+		t.Logf("group auths len(%d)", len(res))
+	}))
+}
+
+func TestService_Unames(t *testing.T) {
+	Convey("unames check", t, WithService(func(s *Service) {
+		var uids []int64
+		uids = append(uids, 1, 2, 3)
+		res := s.Unames(ctx, uids)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func TestService_UsersTotal(t *testing.T) {
+	Convey("TestService_UsersTotal", t, WithService(func(s *Service) {
+		res, err := s.UsersTotal(ctx)
+		So(err, ShouldBeNil)
+		So(res, ShouldBeGreaterThan, 0)
+	}))
+}
+
+func TestService_Users(t *testing.T) {
+	Convey("TestService_Users", t, WithService(func(s *Service) {
+		res, err := s.Users(ctx, 1, 20)
+		So(err, ShouldBeNil)
+		So(len(res.Items), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func TestService_RankUsers(t *testing.T) {
+	Convey("TestService_RankUsers", t, WithService(func(s *Service) {
+		res, count, err := s.RankUsers(ctx, 1, 20, "zhaoshichen")
+		So(err, ShouldBeNil)
+		fmt.Println(res)
+		fmt.Println(count)
+	}))
+}
+
+func TestService_Ping(t *testing.T) {
+	Convey("TestService_RankUsers", t, WithService(func(s *Service) {
+		err := s.Ping(ctx)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestService_Heartbeat(t *testing.T) {
+	Convey("TestService_RankUsers", t, WithService(func(s *Service) {
+		err := s.Heartbeat(ctx, "zhaoshichen")
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestService_Close(t *testing.T) {
+	Convey("TestService_Close", t, WithService(func(s *Service) {
+		s.Close()
+	}))
+}
+
+func TestService_Wait(t *testing.T) {
+	Convey("TestService_Wait", t, WithService(func(s *Service) {
+		s.Wait()
+	}))
+}

app/admin/main/manager/service/tag.go

@@ -0,0 +1,222 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// AddType .
+func (s *Service) AddType(c context.Context, tt *model.TagType) (err error) {
+	if err = s.dao.AddType(c, tt); err != nil {
+		log.Error("s.dao.AddType error(%v)", err)
+	}
+	return
+}
+
+// UpdateType .
+func (s *Service) UpdateType(c context.Context, tt *model.TagType) (err error) {
+	if err = s.dao.UpdateTypeName(c, tt); err != nil {
+		log.Error("s.dao.UpdateTypeName error(%v)", err)
+		return
+	}
+	if err = s.dao.DeleteNonRole(c, tt); err != nil {
+		log.Error("s.dao.DeleteNonRole error(%v)", err)
+		return
+	}
+	if err = s.dao.UpdateType(c, tt); err != nil {
+		log.Error("s.dao.UpdateType error(%v)", err)
+	}
+	return
+}
+
+// DeleteType .
+func (s *Service) DeleteType(c context.Context, td *model.TagTypeDel) (err error) {
+	// judge before deleting
+	var typeRes []*model.Tag
+	if typeRes, err = s.dao.TagByType(c, td.ID); err != nil {
+		log.Error("s.dao.TagByType error(%v)", err)
+		return
+	}
+	if len(typeRes) != 0 {
+		err = ecode.ManagerTagTypeDelErr
+		return
+	}
+	if err = s.dao.DeleteType(c, td); err != nil {
+		log.Error("s.dao.DeleteType error(%v)", err)
+	}
+	return
+}
+
+// AddTag .
+func (s *Service) AddTag(c context.Context, t *model.Tag) (err error) {
+	if err = s.dao.AddTag(c, t); err != nil {
+		log.Error("s.dao.AddTag error(%v)", err)
+	}
+	return
+}
+
+// UpdateTag .
+func (s *Service) UpdateTag(c context.Context, t *model.Tag) (err error) {
+	if err = s.dao.UpdateTag(c, t); err != nil {
+		log.Error("s.dao.UpdateTag error(%v)", err)
+	}
+	return
+}
+
+// AddControl .
+func (s *Service) AddControl(c context.Context, tc *model.TagControl) (err error) {
+	if err = s.dao.AddControl(c, tc); err != nil {
+		log.Error("s.dao.AddControl error(%v)", err)
+	}
+	return
+}
+
+// UpdateControl .
+func (s *Service) UpdateControl(c context.Context, tc *model.TagControl) (err error) {
+	if err = s.dao.UpdateControl(c, tc); err != nil {
+		log.Error("s.dao.UpdateControl error(%v)", err)
+	}
+	return
+}
+
+// BatchUpdateState .
+func (s *Service) BatchUpdateState(c context.Context, b *model.BatchUpdateState) (err error) {
+	if err = s.dao.BatchUpdateState(c, b); err != nil {
+		log.Error("s.dao.BatchUpdateState error(%v)", err)
+	}
+	return
+}
+
+// TagList .
+func (s *Service) TagList(c context.Context, t *model.SearchTagParams) (res []*model.Tag, total int64, err error) {
+	var (
+		tRes map[int64]*model.TagType
+		rRes map[int64]*model.BusinessRole
+	)
+	if t.UName != "" {
+		if uid, ok := s.userIds[t.UName]; ok {
+			t.UID = uid
+		}
+	}
+	if res, err = s.dao.TagList(c, t); err != nil {
+		log.Error("s.dao.TagList error(%v)", err)
+		return
+	}
+	tids := []int64{}
+	rids := []int64{}
+	for _, r := range res {
+		tids = append(tids, r.Tid)
+		rids = append(rids, r.Rid)
+	}
+	if tRes, err = s.dao.TypeByIDs(c, tids); err != nil {
+		log.Error("s.dao.TypeByIDs error(%v)", err)
+		return
+	}
+	if rRes, err = s.dao.RoleByRIDs(c, t.Bid, rids); err != nil {
+		log.Error("s.dao.RoleByIDs error(%v)", err)
+		return
+	}
+	for _, r := range res {
+		if tr, ok := tRes[r.Tid]; ok {
+			r.TName = tr.Name
+		}
+		if rr, ok := rRes[r.Rid]; ok {
+			r.RName = rr.Name
+		}
+		if u, ok := s.userNames[r.UID]; ok {
+			r.UName = u
+		}
+	}
+	total = int64(len(res))
+	start := (t.PN - 1) * t.PS
+	if start >= total {
+		res = []*model.Tag{}
+		return
+	}
+	end := start + t.PS
+	if end > total {
+		end = total
+	}
+	res = res[start:end]
+	return
+}
+
+// TypeList .
+func (s *Service) TypeList(c context.Context, tt *model.TagTypeList) (res []*model.TagType, err error) {
+	var (
+		tids  []int64
+		rids  []int64
+		tRole []*model.TagTypeRole
+		rRes  map[int64]*model.BusinessRole
+	)
+	if res, err = s.dao.TagTypeByBID(c, tt.BID); err != nil {
+		log.Error("s.dao.TagTypeByBID error(%v)", err)
+		return
+	}
+	for _, r := range res {
+		tids = append(tids, r.ID)
+	}
+	if tRole, err = s.dao.TagTypeRoleByTids(c, tids); err != nil {
+		log.Error("s.dao.TagTypeRoleByTids error(%v)", err)
+		return
+	}
+	for _, rt := range tRole {
+		rids = append(rids, rt.Rid)
+	}
+	if rRes, err = s.dao.RoleByRIDs(c, tt.BID, rids); err != nil {
+		log.Error("s.dao.RoleByRIDs error(%v)", err)
+		return
+	}
+	for _, r := range res {
+		for _, t := range tRole {
+			if r.ID == t.Tid {
+				if role, ok := rRes[t.Rid]; ok {
+					r.Roles = append(r.Roles, role)
+				}
+			}
+		}
+	}
+	return
+}
+
+// AttrList .
+func (s *Service) AttrList(c context.Context, tba *model.TagBusinessAttr) (res *model.TagBusinessAttr, err error) {
+	if res, err = s.dao.AttrList(c, tba.Bid); err != nil {
+		log.Error("s.dao.AttrList error(%v)", err)
+		return
+	}
+	if res.ID == 0 {
+		t := &model.TagBusinessAttr{
+			Bid:    tba.Bid,
+			Button: model.DefaultButton,
+		}
+		if err = s.dao.InsertAttr(c, t); err != nil {
+			log.Error("s.dao.InsertAttr error(%v)", err)
+			return
+		}
+		if res, err = s.dao.AttrList(c, tba.Bid); err != nil {
+			log.Error("s.dao.AttrList error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// AttrUpdate .
+func (s *Service) AttrUpdate(c context.Context, tba *model.TagBusinessAttr) (err error) {
+	if err = s.dao.AttrUpdate(c, tba); err != nil {
+		log.Error("s.dao.AttrUpdate error(%v)", err)
+	}
+	return
+}
+
+// TagControl .
+func (s *Service) TagControl(c context.Context, tc *model.TagControlParam) (res []*model.TagControl, err error) {
+	if res, err = s.dao.TagControl(c, tc); err != nil {
+		log.Error("s.dao.TagControl error(%v)", err)
+	}
+	return
+}

app/admin/main/manager/service/user.go

@@ -0,0 +1,284 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/manager/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+	"github.com/pkg/errors"
+)
+
+// Auth return user's auth infomation.
+func (s *Service) Auth(c context.Context, username string) (res *model.Auth, err error) {
+	var (
+		user model.User
+		resp *model.RespPerm
+	)
+	if err = s.dao.DB().Where("username = ?", username).First(&user).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = ecode.Int(10001)
+			return
+		}
+		err = errors.Wrapf(err, "s.dao.DB().user.fitst(%s)", username)
+		return
+	}
+	res = &model.Auth{
+		UID:      user.ID,
+		Username: user.Username,
+		Nickname: user.Nickname,
+	}
+	if resp, err = s.permsByMid(c, user.ID); err != nil {
+		err = errors.Wrapf(err, "s.permsByMid(%d)", user.ID)
+		return
+	}
+	res.Perms = resp.Res
+	res.Admin = resp.Admin
+	var aa []*model.AuthAssign
+	if result := s.dao.DB().Joins("left join auth_item on auth_item.id=auth_assignment.item_id").Where("auth_assignment.user_id=? and auth_item.type=?", user.ID, model.TypeGroup).Find(&aa); !result.RecordNotFound() {
+		res.Assignable = true
+	}
+	return
+}
+
+// Permissions return user's permissions.
+func (s *Service) Permissions(c context.Context, username string) (res *model.Permissions, err error) {
+	res = new(model.Permissions)
+	var (
+		user model.User
+		resp *model.RespPerm
+	)
+	if err = s.dao.DB().Where("username = ?", username).First(&user).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			err = ecode.NothingFound
+		}
+		log.Error("find user username(%s) error(%v)", username, err)
+		return
+	}
+	res.UID = user.ID
+	if resp, err = s.permsByMid(c, user.ID); err != nil {
+		if err == gorm.ErrRecordNotFound {
+			err = ecode.NothingFound
+		}
+		log.Error("s.permsByMid(%d) error(%v)", user.ID, err)
+		return
+	}
+	res.Perms = resp.Res
+	res.Admin = resp.Admin
+	res.Orgs = resp.Groups
+	res.Roles = resp.Roles
+	return
+}
+
+func (s *Service) permsByMid(c context.Context, mid int64) (resp *model.RespPerm, err error) {
+	var (
+		pointIDs []int64
+		as       []*model.AuthAssign
+	)
+	resp = &model.RespPerm{}
+	resp.Res = make([]string, 0)
+	resp.Groups = make([]*model.AuthOrg, 0)
+	resp.Roles = make([]*model.AuthOrg, 0)
+	if s.admins[mid] {
+		resp.Admin = true
+		for _, p := range s.pointList {
+			resp.Res = append(resp.Res, p.Data)
+		}
+		return
+	}
+	if err = s.dao.DB().Where("user_id = ?", mid).Find(&as).Error; err != nil {
+		err = errors.Wrapf(err, "s.dao.DB().user.find(%d)", mid)
+		return
+	}
+	for _, a := range as {
+		if info, found := s.orgAuth[a.ItemID]; found { // group & role information
+			if info.Type == model.TypeRole {
+				resp.Roles = append(resp.Roles, info)
+			}
+			if info.Type == model.TypeGroup {
+				resp.Groups = append(resp.Groups, info)
+			}
+		}
+		if vs, ok := s.roleAuth[a.ItemID]; ok {
+			pointIDs = append(pointIDs, vs...)
+			continue
+		}
+		if vs, ok := s.groupAuth[a.ItemID]; ok {
+			pointIDs = append(pointIDs, vs...)
+		}
+	}
+	repeat := map[string]byte{}
+	for _, id := range pointIDs {
+		if assign, ok := s.points[id]; ok {
+			l := len(repeat)
+			repeat[assign.Data] = 0
+			if len(repeat) != l {
+				resp.Res = append(resp.Res, assign.Data)
+			}
+		}
+	}
+	return
+}
+
+// Users get user list.
+func (s *Service) Users(c context.Context, pn, ps int) (res *model.UserPager, err error) {
+	res = &model.UserPager{
+		Pn: pn,
+		Ps: ps,
+	}
+	var items []*model.User
+	if err = s.dao.DB().Where("state = ?", model.UserStateOn).Offset((pn - 1) * ps).Limit(ps).Find(&items).Error; err != nil {
+		if err != ecode.NothingFound {
+			err = errors.Wrapf(err, "s.dao.DB().users.find(%d,%d)", pn, ps)
+			return
+		}
+		err = nil
+	}
+	res.Items = items
+	return
+}
+
+// UsersTotal get user total
+func (s *Service) UsersTotal(c context.Context) (total int64, err error) {
+	var item *model.User
+	if err = s.dao.DB().Model(&item).Where("state = ?", model.UserStateOn).Count(&total).Error; err != nil {
+		err = errors.Wrap(err, "s.dao.DB().users.count")
+	}
+	return
+}
+
+// Heartbeat user activity record
+func (s *Service) Heartbeat(c context.Context, username string) (err error) {
+	var user model.User
+	if err = s.dao.DB().Where("username = ?", username).First(&user).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = ecode.Int(10001)
+			return
+		}
+		err = errors.Wrapf(err, "s.dao.DB().user.fitst(%s)", username)
+		return
+	}
+	now := time.Now()
+	if err = s.dao.DB().Exec("insert into user_heartbeat (uid,mtime) values (?,?) on duplicate key update mtime=?", user.ID, now, now).Error; err != nil {
+		err = errors.Wrapf(err, "s.dao.DB().heartbeat(%d)", user.ID)
+	}
+	return
+}
+
+// loadUnames loads the relation of uid & unames in two maps
+func (s *Service) loadUnames() {
+	var (
+		err        error
+		items      []*model.User
+		unames     = make(map[int64]string)
+		unicknames = make(map[int64]string)
+		uids       = make(map[string]int64)
+	)
+	if err = s.dao.DB().Where("state = ?", model.UserStateOn).Find(&items).Error; err != nil {
+		if err != ecode.NothingFound {
+			log.Error("LoadUnames Error (%v)", err)
+			return
+		}
+		if len(items) == 0 {
+			log.Info("LoadUnames No Active User was found")
+			return
+		}
+	}
+	for _, v := range items {
+		unames[v.ID] = v.Username
+		unicknames[v.ID] = v.Nickname
+		uids[v.Username] = v.ID
+	}
+	if length := len(unames); length != 0 {
+		s.userNames = unames
+		s.userNicknames = unicknames
+		log.Info("LoadUnames Refresh Success! Lines:%d", length)
+	}
+	if length := len(uids); length != 0 {
+		s.userIds = uids
+		log.Info("LoadUIds Refresh Success! Lines:%d", length)
+	}
+}
+
+// regularly load unames
+func (s *Service) loadUnamesproc() {
+	var duration time.Duration
+	if duration = time.Duration(s.c.UnameTicker); duration == 0 {
+		duration = time.Duration(5 * time.Minute) // default value
+	}
+	ticker := time.NewTicker(duration)
+	for range ticker.C {
+		s.loadUnames()
+		s.loadUdepts()
+	}
+	ticker.Stop()
+}
+
+// Unames treats the param "uids" and give back the unames data
+func (s *Service) Unames(c context.Context, uids []int64) (res map[int64]string) {
+	res = make(map[int64]string)
+	for _, v := range uids {
+		if uname, ok := s.userNames[v]; ok {
+			res[v] = uname
+		}
+	}
+	return
+}
+
+// UIds treats the param "unames" and give back the uids data
+func (s *Service) UIds(c context.Context, unames []string) (res map[string]int64) {
+	res = make(map[string]int64)
+	for _, v := range unames {
+		if uid, ok := s.userIds[v]; ok {
+			res[v] = uid
+		}
+	}
+	return
+}
+
+// loadUdeps loads the relation of uid & department in one map
+func (s *Service) loadUdepts() {
+	var (
+		items  []*model.UserDept
+		udepts = make(map[int64]string)
+	)
+	/**
+	select `user`.id,user_department.`name` from `user` LEFT JOIN user_department on `user`.department_id = user_department.id where user_department.`status` = 1 and `user`.state = 0
+	*/
+	err := s.dao.DB().Table("user").
+		Select("user.id, user_department.`name` AS department").
+		Joins("LEFT JOIN user_department ON `user`.department_id = user_department.id").
+		Where("user_department.`status` = ?", model.UserDepOn).
+		Where("state = ?", model.UserStateOn).Find(&items).Error
+	if err != nil {
+		if err != ecode.NothingFound {
+			log.Error("loadUdepts Error (%v)", err)
+			return
+		}
+		if len(items) == 0 {
+			log.Info("loadUdepts No Active User was found")
+			return
+		}
+	}
+	for _, v := range items {
+		udepts[v.ID] = v.Department
+	}
+	if length := len(udepts); length != 0 {
+		s.userDeps = udepts
+		log.Info("loadUdepts Refresh Success! Lines:%d", length)
+	}
+}
+
+// Udepts treats the param "uids" and give back the users' department data
+func (s *Service) Udepts(c context.Context, uids []int64) (res map[int64]string) {
+	res = make(map[int64]string)
+	for _, v := range uids {
+		if udept, ok := s.userDeps[v]; ok {
+			res[v] = udept
+		}
+	}
+	return
+}