Create & Init Project...

app/admin/main/macross/service/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "mail.go",
+        "mng_auth.go",
+        "mng_role.go",
+        "mng_user.go",
+        "package.go",
+        "publish.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/admin/main/macross/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/macross/conf:go_default_library",
+        "//app/admin/main/macross/dao:go_default_library",
+        "//app/admin/main/macross/dao/oss:go_default_library",
+        "//app/admin/main/macross/model/mail:go_default_library",
+        "//app/admin/main/macross/model/manager:go_default_library",
+        "//app/admin/main/macross/model/package:go_default_library",
+        "//app/admin/main/macross/model/publish:go_default_library",
+        "//app/admin/main/macross/tools:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/gopkg.in/gomail.v2:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/macross/service/mail.go

@@ -0,0 +1,120 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/admin/main/macross/conf"
+	"go-common/app/admin/main/macross/model/mail"
+	"go-common/app/admin/main/macross/tools"
+	"go-common/library/log"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	gomail "gopkg.in/gomail.v2"
+)
+
+// SendMail send mail
+func (s *Service) SendMail(c context.Context, m *mail.Mail, attach *mail.Attach) (err error) {
+	var (
+		toUsers  []string
+		ccUsers  []string
+		bccUsers []string
+		msg      = gomail.NewMessage()
+	)
+
+	msg.SetAddressHeader("From", conf.Conf.Property.Mail.Address, conf.Conf.Property.Mail.Name) // 发件人
+	for _, ads := range m.ToAddresses {
+		toUsers = append(toUsers, msg.FormatAddress(ads.Address, ads.Name))
+	}
+
+	for _, ads := range m.CcAddresses {
+		ccUsers = append(ccUsers, msg.FormatAddress(ads.Address, ads.Name))
+	}
+
+	for _, ads := range m.BccAddresses {
+		bccUsers = append(bccUsers, msg.FormatAddress(ads.Address, ads.Name))
+	}
+
+	msg.SetHeader("To", toUsers...)
+	msg.SetHeader("Subject", m.Subject) // 主题
+
+	if len(ccUsers) > 0 {
+		msg.SetHeader("Cc", ccUsers...)
+	}
+	if len(bccUsers) > 0 {
+		msg.SetHeader("Bcc", bccUsers...)
+	}
+
+	if m.Type == mail.TypeTextHTML {
+		msg.SetBody("text/html", m.Body)
+	} else {
+		msg.SetBody("text/plain", m.Body)
+	}
+
+	// 附件处理
+	if attach != nil {
+		tmpSavePath := filepath.Join(os.TempDir(), "mail_tmp")
+		err = os.MkdirAll(tmpSavePath, 0755)
+		if err != nil {
+			log.Error("os.MkdirAll error(%v)", err)
+			return
+		}
+		destFilePath := filepath.Join(tmpSavePath, attach.Name)
+		destFile, cErr := os.Create(destFilePath)
+		if cErr != nil {
+			log.Error("os.Create(%s) error(%v)", destFilePath, cErr)
+			return cErr
+		}
+		defer os.RemoveAll(tmpSavePath)
+		io.Copy(destFile, attach.File)
+
+		// 如果 zip 文件需要解压以后放在邮件附件中
+		if attach.ShouldUnzip && strings.HasSuffix(attach.Name, ".zip") {
+			unzipFilePath := filepath.Join(tmpSavePath, "unzip")
+			err = os.MkdirAll(tmpSavePath, 0755)
+			if err != nil {
+				log.Error("os.MkdirAll error(%v)", err)
+				return
+			}
+			err = tools.Unzip(destFilePath, unzipFilePath)
+			if err != nil {
+				log.Error("unzip(%s, %s) error(%v)", destFilePath, unzipFilePath, err)
+				return
+			}
+			err = filepath.Walk(unzipFilePath, func(path string, f os.FileInfo, err error) error {
+				if err != nil {
+					log.Error("filepath.Walk error(%v)", err)
+					return err
+				}
+				if f == nil {
+					errMsg := "found no file"
+					err = fmt.Errorf(errMsg)
+					log.Error(errMsg)
+					return err
+				}
+				if f.IsDir() {
+					return nil
+				}
+				msg.Attach(path)
+				return err
+			})
+		} else {
+			msg.Attach(destFilePath)
+		}
+	}
+
+	d := gomail.NewDialer(
+		conf.Conf.Property.Mail.Host,
+		conf.Conf.Property.Mail.Port,
+		conf.Conf.Property.Mail.Address,
+		conf.Conf.Property.Mail.Pwd,
+	)
+	if err = d.DialAndSend(msg); err != nil {
+		log.Error("Send mail Fail(%v) diff(%s)", msg, err)
+		return
+	}
+
+	return
+}

app/admin/main/macross/service/mng_auth.go

@@ -0,0 +1,111 @@
+package service
+
+import (
+	"context"
+	"sort"
+
+	model "go-common/app/admin/main/macross/model/manager"
+	"go-common/library/log"
+)
+
+// GetAuths get auths.
+func (s *Service) GetAuths(c context.Context, name string) (res map[string]map[string]*model.Auth, err error) {
+	res = make(map[string]map[string]*model.Auth)
+	for system, users := range s.user {
+		var (
+			user    *model.User
+			authIDs []int64
+			auths   map[int64]*model.Auth
+			resTmp  map[string]*model.Auth
+			ok      bool
+		)
+		if user, ok = users[name]; !ok {
+			continue
+		}
+		if authIDs, ok = s.authRelation[user.RoleID]; !ok {
+			continue
+		}
+		if auths, ok = s.auth[system]; !ok {
+			continue
+		}
+		for _, authID := range authIDs {
+			if auth, ok := auths[authID]; ok {
+				if resTmp, ok = res[system]; !ok {
+					resTmp = make(map[string]*model.Auth)
+					res[system] = resTmp
+				}
+				resTmp[auth.AuthFlag] = auth
+			}
+		}
+	}
+	return
+}
+
+// Auth get auth.
+func (s *Service) Auth(c context.Context, system string) (res []*model.Auth) {
+	for _, auth := range s.auth[system] {
+		res = append(res, auth)
+	}
+	sort.Sort(model.Auths(res))
+	return
+}
+
+// SaveAuth save auth.
+func (s *Service) SaveAuth(c context.Context, authID int64, system, authName, authFlag string) (err error) {
+	var rows int64
+	if authID == 0 {
+		if rows, err = s.dao.AddAuth(c, system, authName, authFlag); err != nil {
+			log.Error("s.dao.AddAuth(%s, %s, %s) error(%v)", system, authName, authFlag, err)
+			return
+		}
+	} else {
+		if rows, err = s.dao.UpAuth(c, authName, authID); err != nil {
+			log.Error("s.dao.UpAuth(%s, %d) error(%v)", authName, authID, err)
+			return
+		}
+	}
+	if rows != 0 {
+		// update cache
+		s.loadAuthCache()
+	}
+	return
+}
+
+// DelAuth del auth.
+func (s *Service) DelAuth(c context.Context, authID int64) (err error) {
+	var rows int64
+	if rows, err = s.dao.DelAuth(c, authID); err != nil {
+		log.Error("s.dao.DelAuth(%d) error(%s)", authID, err)
+		return
+	} else if rows != 0 {
+		// update cache
+		s.loadAuthCache()
+		if rows, err = s.dao.CleanAuthRelationByAuth(c, authID); err != nil {
+			log.Error("s.dao.CleanAuthRelationByAuth(%d) error(%v)", authID, err)
+			return
+		} else if rows != 0 {
+			s.loadAuthRelationCache()
+		}
+	}
+	return
+}
+
+// AuthRelation get auth relation.
+func (s *Service) AuthRelation(c context.Context, roleID, authID int64, state int) (err error) {
+	var rows int64
+	if state == 0 {
+		if rows, err = s.dao.DelAuthRelation(c, roleID, authID); err != nil {
+			log.Error("s.dao.DelAuthRelation(%d, %d) error(%v)", roleID, authID, err)
+			return
+		}
+	} else {
+		if rows, err = s.dao.AddAuthRelation(c, roleID, authID); err != nil {
+			log.Error("s.dao.AddAuthRelation(%d, %d) error(%v)", roleID, authID, err)
+			return
+		}
+	}
+	if rows != 0 {
+		s.loadAuthRelationCache()
+	}
+	return
+}

app/admin/main/macross/service/mng_role.go

@@ -0,0 +1,72 @@
+package service
+
+import (
+	"context"
+	"sort"
+
+	"go-common/library/log"
+
+	model "go-common/app/admin/main/macross/model/manager"
+)
+
+// Role get role.
+func (s *Service) Role(c context.Context, system string) (res []*model.Role) {
+	for _, role := range s.role[system] {
+		if role == nil {
+			continue
+		}
+		role.Auths = make(map[string]*model.Auth)
+		if authIDs, ok := s.authRelation[role.RoleID]; ok {
+			if auths, ok := s.auth[system]; ok {
+				for _, authID := range authIDs {
+					if auth, ok := auths[authID]; ok {
+						role.Auths[auth.AuthFlag] = auth
+					}
+				}
+			}
+		}
+		res = append(res, role)
+	}
+	sort.Sort(model.Roles(res))
+	return
+}
+
+// SaveRole save role.
+func (s *Service) SaveRole(c context.Context, roleID int64, system, roleName string) (err error) {
+	var rows int64
+	if roleID == 0 {
+		if rows, err = s.dao.AddRole(c, system, roleName); err != nil {
+			log.Error("s.dao.AddRole(%s, %s) error(%v)", system, roleName, err)
+			return
+		}
+	} else {
+		if rows, err = s.dao.UpRole(c, roleName, roleID); err != nil {
+			log.Error("s.dao.UpRole(%s, %d) error(%v)", roleName, roleID, err)
+			return
+		}
+	}
+	if rows != 0 {
+		// update cache
+		s.loadRoleCache()
+	}
+	return
+}
+
+// DelRole del role.
+func (s *Service) DelRole(c context.Context, roleID int64) (err error) {
+	var rows int64
+	if rows, err = s.dao.DelRole(c, roleID); err != nil {
+		log.Error("s.dao.DelRole(%d) error(%s)", roleID, err)
+		return
+	} else if rows != 0 {
+		// update cache
+		s.loadRoleCache()
+		if rows, err = s.dao.CleanAuthRelationByRole(c, roleID); err != nil {
+			log.Error("s.dao.CleanAuthRelationByRole(%d) error(%s)", roleID, err)
+			return
+		} else if rows != 0 {
+			s.loadAuthRelationCache()
+		}
+	}
+	return
+}

app/admin/main/macross/service/mng_user.go

@@ -0,0 +1,56 @@
+package service
+
+import (
+	"context"
+	"sort"
+
+	"go-common/library/log"
+
+	model "go-common/app/admin/main/macross/model/manager"
+)
+
+// User get user.
+func (s *Service) User(c context.Context, system string) (res []*model.User) {
+	users, ok := s.user[system]
+	if ok {
+		for _, user := range users {
+			res = append(res, user)
+		}
+	}
+	sort.Sort(model.Users(res))
+	return
+}
+
+// SaveUser save user.
+func (s *Service) SaveUser(c context.Context, roleID, userID int64, system, userName string) (err error) {
+	var rows int64
+	if userID == 0 {
+		if rows, err = s.dao.AddUser(c, roleID, system, userName); err != nil {
+			log.Error("s.dao.AddUser(%d, %s, %s) error(%v)", roleID, system, userName, err)
+			return
+		}
+	} else {
+		if rows, err = s.dao.UpUser(c, userID, roleID, userName); err != nil {
+			log.Error("s.dao.UpUser(%d, %d, %s) error(%v)", userID, roleID, userName, err)
+			return
+		}
+	}
+	// update cache
+	if rows != 0 {
+		s.loadUserCache()
+	}
+	return
+}
+
+// DelUser del user.
+func (s *Service) DelUser(c context.Context, userID int64) (err error) {
+	var rows int64
+	if rows, err = s.dao.DelUser(c, userID); err != nil {
+		log.Error("s.dao.DelUser(%d) error(%v)", userID, err)
+		return
+	} else if rows != 0 {
+		// update cache
+		s.loadUserCache()
+	}
+	return
+}

app/admin/main/macross/service/package.go

@@ -0,0 +1,82 @@
+package service
+
+import (
+	"fmt"
+	"go-common/app/admin/main/macross/conf"
+	"go-common/app/admin/main/macross/model/package"
+	"go-common/app/admin/main/macross/tools"
+	"go-common/library/log"
+	"io"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// PackageUpload upload package zip file & unzip it
+func (s *Service) PackageUpload(file multipart.File, pkgInfo upload.PkgInfo) (err error) {
+	err = os.MkdirAll(pkgInfo.SaveDir, 0755)
+	if err != nil {
+		log.Error("os.MkdirAll error(%v)", err)
+		return
+	}
+
+	destFilePath := filepath.Join(pkgInfo.SaveDir, pkgInfo.FileName)
+	destFile, err := os.Create(destFilePath)
+	if err != nil {
+		log.Error("os.Create(%s) error(%v)", destFilePath, err)
+		return
+	}
+	io.Copy(destFile, file)
+
+	err = tools.Unzip(destFilePath, pkgInfo.SaveDir)
+	if err != nil {
+		log.Error("unzip(%s, %s) error(%v)", destFilePath, pkgInfo.SaveDir, err)
+		return
+	}
+
+	err = os.Remove(destFilePath)
+	if err != nil {
+		log.Error("os.Remove(%s) error(%v)", destFilePath, err)
+		return
+	}
+
+	// generate Android channel package
+	if pkgInfo.ClientType == "android" {
+		if len(pkgInfo.Channel) > 0 && len(pkgInfo.ApkName) > 0 {
+			dest := filepath.Join(pkgInfo.SaveDir, "channel")
+			targetFilePath := filepath.Join(pkgInfo.SaveDir, pkgInfo.ApkName)
+			_, err = tools.GenerateChannelApk(dest, pkgInfo.Channel, nil, targetFilePath, false, false)
+			if err != nil {
+				log.Error("tools.GenerateChannelApk(%s, %s, nil, %s, false, false) error(%v)", dest, pkgInfo.Channel, targetFilePath, err)
+				os.RemoveAll(pkgInfo.SaveDir)
+				return
+			}
+		}
+	}
+
+	return
+}
+
+// PackageList list the Package Files
+func (s *Service) PackageList(path string) (fileList []string, err error) {
+	err = filepath.Walk(path, func(path string, f os.FileInfo, err error) error {
+		if err != nil {
+			log.Error("filepath.Walk error(%v)", err)
+			return err
+		}
+		if f == nil {
+			errMsg := "found no file"
+			err = fmt.Errorf(errMsg)
+			log.Error(errMsg)
+			return err
+		}
+		if f.IsDir() {
+			return nil
+		}
+		fileURL := strings.Replace(path, conf.Conf.Property.Package.SavePath, conf.Conf.Property.Package.URLPrefix, -1)
+		fileList = append(fileList, fileURL)
+		return err
+	})
+	return
+}

app/admin/main/macross/service/publish.go

@@ -0,0 +1,24 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/macross/model/publish"
+	"go-common/library/log"
+)
+
+// Dashborad insert dashboard info and logs.
+func (s *Service) Dashborad(c context.Context, d *publish.Dashboard) (err error) {
+	var id int64
+	if id, err = s.dao.Dashborad(c, d); err != nil {
+		log.Error("Dashborad() error(%v)", err)
+		return
+	}
+	if len(d.Logs) > 0 && id > 0 {
+		if _, err = s.dao.DashboradLogs(c, id, d.Logs); err != nil {
+			log.Error("DashboradLogs() error(%v)", err)
+			return
+		}
+	}
+	return
+}

app/admin/main/macross/service/service.go

@@ -0,0 +1,131 @@
+package service
+
+import (
+	"context"
+	"io"
+	"time"
+
+	"go-common/library/log"
+
+	"go-common/app/admin/main/macross/conf"
+	"go-common/app/admin/main/macross/dao"
+	"go-common/app/admin/main/macross/dao/oss"
+	model "go-common/app/admin/main/macross/model/manager"
+)
+
+// Service service struct info.
+type Service struct {
+	c   *conf.Config
+	oss *oss.Dao
+	dao *dao.Dao
+	// manager cache
+	user         map[string]map[string]*model.User // system => { username => managerInfo }
+	role         map[string]map[int64]*model.Role  // system => { roleId => roleInfo }
+	authRelation map[int64][]int64                 // role_id => [ auth_id ]
+	auth         map[string]map[int64]*model.Auth  // system => { authId => authInfo }
+	// ios cache
+	modelNameCache map[string]map[string]int64
+}
+
+// New service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: dao.New(c),
+		oss: oss.New(c),
+		// init manager cache
+		user:         make(map[string]map[string]*model.User),
+		role:         make(map[string]map[int64]*model.Role),
+		authRelation: make(map[int64][]int64),
+		auth:         make(map[string]map[int64]*model.Auth),
+		// init ios cache
+		modelNameCache: make(map[string]map[string]int64),
+	}
+	// manager cache
+	if err := s.loadUserCache(); err != nil {
+		panic(err)
+	}
+	if err := s.loadRoleCache(); err != nil {
+		panic(err)
+	}
+	if err := s.loadAuthRelationCache(); err != nil {
+		panic(err)
+	}
+	if err := s.loadAuthCache(); err != nil {
+		panic(err)
+	}
+	go s.loadproc()
+	return
+}
+
+// loadproc is a routine load to cache
+func (s *Service) loadproc() {
+	for {
+		time.Sleep(time.Duration(conf.Conf.Reload))
+		s.loadUserCache()
+		s.loadRoleCache()
+		s.loadAuthRelationCache()
+		s.loadAuthCache()
+	}
+}
+
+func (s *Service) loadUserCache() (err error) {
+	var tmpUser map[string]map[string]*model.User
+	if tmpUser, err = s.dao.Users(context.TODO()); err != nil {
+		log.Error("s.dao.Users() error(%v)", err)
+		return
+	}
+	s.user = tmpUser
+	return
+}
+
+func (s *Service) loadRoleCache() (err error) {
+	var tmpRole map[string]map[int64]*model.Role
+	if tmpRole, err = s.dao.Roles(context.TODO()); err != nil {
+		log.Error("s.dao.Roles() error(%v)", err)
+		return
+	}
+	s.role = tmpRole
+	return
+}
+
+func (s *Service) loadAuthRelationCache() (err error) {
+	var tmpAuthRelation map[int64][]int64
+	if tmpAuthRelation, err = s.dao.AuthRelation(context.TODO()); err != nil {
+		log.Error("s.dao.AuthRelation() error(%v)", err)
+		return
+	}
+	s.authRelation = tmpAuthRelation
+	return
+}
+
+func (s *Service) loadAuthCache() (err error) {
+	var tmpAuth map[string]map[int64]*model.Auth
+	if tmpAuth, err = s.dao.Auths(context.TODO()); err != nil {
+		log.Error("s.dao.Auths() error(%v)", err)
+		return
+	}
+	s.auth = tmpAuth
+	return
+}
+
+// DiffPutOss upload diff to oss
+func (s *Service) DiffPutOss(c context.Context, f io.Reader, filename string) (uri string, err error) {
+	if uri, err = s.oss.Put(c, f, filename); err != nil {
+		log.Error("s.oss.Put(%s) error(%v)", filename, err)
+	}
+	return
+}
+
+// Ping dao
+func (s *Service) Ping(c context.Context) (err error) {
+	if err = s.dao.Ping(c); err != nil {
+		log.Error("s.dao error(%v)", err)
+	}
+	return
+}
+
+// Close dao
+func (s *Service) Close() {
+	s.dao.Close()
+}