feats

conf/log.conf

+[common]
+filename="E:\\GoProjects\\src\\spaceofcheng\\services\\log\\common.log"
+# log level "emergency", "alert", "critical", "error", "warning", "notice", "info", "debug"
+level="debug"

controllers/auth.go

 import (
 	"errors"
 	"net/http"
+	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strings"
 
 // Authenticate 权限验证
 func (c *BaseController) authenticate() {
-	if !c.needAuth() {
-		return
-	}
-
 	// 默认 service
 	serv := service.NewSysServ(c.Context)
 
+	// 客户端类型
+	clientType := utils.GetClientType(c.Ctx.Request)
+
 	// 用户类型, 此处与数据库定义的不是一个概念
 	// 此处主要用来区分是 系统用户, 还是 系统客户
-	userType := c.GetSession(SNUserType).(string)
+	userType := UserGuest
+	userTypeRaw := c.GetSession(SNUserType)
+	if userTypeRaw != nil {
+		userType = userTypeRaw.(string)
+	}
+
+	// 用户类型不同, 此处ID代表的内容也是不一样的
+	userID := ""
+	userIDRaw := c.GetSession(SNUserID)
+	if userIDRaw != nil {
+		userID = userIDRaw.(string)
+	}
+
+	// 用户映射表
+	var userMap *model.TaUserMapping
+
+	if clientType == utils.ClientWechat && userID == "" {
+		var err error
+		userMap, err = c.checkWechat(serv)
+		if err != nil {
+			utils.LogError("获取并校验微信信息失败: " + err.Error())
+		}
+
+		c.SetSession("openid", userMap.Openid)
+	}
+
+	if !c.needAuth() {
+		return
+	}
 
 	// 如果是普通游客, 暂时没有任何设置
 	if userType == UserGuest {
 		return
 	}
 
-	// 客户端类型
-	clientType := utils.GetClientType(c.Ctx.Request)
-
-	// 用户类型不同, 此处ID代表的内容也是不一样的
-	userID, _ := c.GetSession(SNUserID).(string)
+	// 如果存在用户映射
+	mapUserID := c.getUserIDByUserMap(userMap, userID, userType)
+	if mapUserID != "" {
+		userID = mapUserID
+	}
 
 	// 未登录状态
 	if userID == "" {
 		if clientType == utils.ClientWechat {
-			if err := c.getWechatInfo(); err != nil {
-				wxConf, ok := c.Configer[WeChatConf]
-				if ok {
-					utils.LogError("获取微信信息失败: " + err.Error())
-
-					c.ResponseData(
-						map[string]interface{}{
-							"appid": wxConf.String("appid"),
-						},
-						errors.New("用户未登录"),
-						http.StatusUnauthorized,
-					)
-				} else {
-					c.ResponseError(
-						errors.New("用户未登录"),
-						http.StatusUnauthorized,
-					)
-				}
+			wxConf, ok := c.Configer[WeChatConf]
+			if ok {
+				c.ResponseData(
+					map[string]interface{}{
+						"appid": wxConf.String("appid"),
+					},
+					errors.New("用户未登录"),
+					http.StatusUnauthorized,
+				)
+			} else {
+				c.ResponseError(
+					errors.New("用户未登录"),
+					http.StatusUnauthorized,
+				)
 			}
 		} else {
 			c.ResponseError(
 		}
 	}
 
+	// 设置 Session
+	c.SetSession(SNUserID, userID)
+	c.SetSession(SNUserType, userType)
+
 	var err error
-	if clientType == utils.ClientAdmin {
+
+	// 设置 Context
+	// 放到 serv 的方法里面了
+	if userType == UserAdmin {
+		// 普通管理人员
 		err = serv.SetUserProfile(userID)
+
 	} else {
+		// 系统客户
 		err = serv.SetCustomer(userID)
 	}
 
 	return true
 }
 
-func (c *BaseController) getWechatInfo() error {
-	// code := c.GetString("code")
-	return nil
-}
+func (c *BaseController) checkWechat(serv *service.SysServ) (*model.TaUserMapping, error) {
+	// 确定客户端类型
+	adminClient := c.GetString("admin")
+	userType := service.USERTYPE_CUSTOMER
+	if adminClient != "" {
+		userType = service.USERTYPE_USER
+	}
+
+	openIDRaw := c.GetSession("openid")
+	if openIDRaw != nil {
+		openID := openIDRaw.(string)
+		wxUser := map[string]interface{}{
+			"openid": openID,
+		}
+		return serv.CheckWechatUserMapping(wxUser, userType)
+	}
 
-func (c *BaseController) getSysUserInfo(userID string) error {
+	// 微信 code
+	code := c.GetString("code")
+	if code == "" {
+		return nil, errors.New("没有微信 code")
+	}
 
+	// 获取微信信息
+	wxUser, err := utils.GetWxUserInfo(code)
+	if err != nil {
+		return nil, err
+	}
+
+	return serv.CheckWechatUserMapping(wxUser, userType)
 }
 
-func (c *BaseController) getCustomer(customerID string) error {
+// getUserIDByUserMap 校验用户映射是否与 Session 一致
+func (c *BaseController) getUserIDByUserMap(user *model.TaUserMapping, userID, userType string) string {
+	// 如果映射信息不存在
+	if user == nil {
+		return ""
+	}
+
+	// 如果 session 数据存在, 以 session 为准
+	if userID != "" {
+		return ""
+	}
+
+	// 如果是系统内置用户
+	if user.UserType == service.USERTYPE_USER {
+		if userType != UserAdmin {
+			return ""
+		}
+	}
+
+	// 如果是普通客户
+	if user.UserType == service.USERTYPE_CUSTOMER {
+		if userType != UserCustomer {
+			return ""
+		}
+	}
 
+	return user.UserId
 }

controllers/session.go

 	SNUserID = "userid"
 	// 用户类型
 	SNUserType = "userType"
+
+	// 内置 openid
+	// 请勿使用 openid 作为 session 的key
 )

controllers/types.go

 // 用户类型列表
 const (
 	UserGuest    = "guest"
-	UserCommon   = "common"
+	UserAdmin    = "admin"
 	UserCustomer = "customer"
 )
 

models/constant.go

 package models
 
+// 状态列表
 const (
 	STATUS_NORMAL = 1
 	STATUS_DEL    = -1
 )
+
+// 映射数据库的布尔型
+const (
+	BOOL_FALSE = 0
+	BOOL_TRUE  = 1
+)
+
+// 映射表账户类型
+const (
+	ACCMAP_WECHAT = "wechat"
+	ACCMAP_MINI   = "mini"
+)

models/sys.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 
+	"github.com/yl10/kit/guid"
+
 	"github.com/go-xorm/xorm"
 )
 
 		return nil, errors.New("没有查询到 ID (" + id + ") 对应的用户")
 	}
 
-	if user.Status != STATUS_NOMAIL {
+	if user.Status != STATUS_NORMAL {
 		return nil, errors.New("用户状态不正确")
 	}
 
 	`
 
 	var menus []model.SysMenu
-	if err := m.db.SQL(query, userID, STATUS_NOMAIL).Find(&menus); err != nil {
+	if err := m.db.SQL(query, userID, STATUS_NORMAL).Find(&menus); err != nil {
 		return nil, err
 	}
 
 	`
 
 	var cases []model.SysUserCase
-	if err := m.db.SQL(query, userID, STATUS_NOMAIL).Find(&cases); err != nil {
+	if err := m.db.SQL(query, userID, STATUS_NORMAL).Find(&cases); err != nil {
 		return nil, err
 	}
 
 	return cases, nil
 }
 
-// GetUserOrg 获取人员机构信息
-func (m *SysDAO) GetUserOrg(userID string) (*model.SysOrg, error) {
-	query := `
-		SELECT t.*
-		FROM sys_org t
-		JOIN sys_user s USING (org_id)
-		WHERE s.user_id = ?
-		AND t.status = ?
-	`
-
+// GetOrg 获取机构信息
+func (m *SysDAO) GetOrg(orgID string) (*model.SysOrg, error) {
 	var org model.SysOrg
-	has, err := m.db.SQL(query, userID, STATUS_NOMAIL).Get(&org)
+	has, err := m.db.Where("org_id=?", orgID).And("status=?", STATUS_NORMAL).Get(&org)
 	if err != nil {
 		return nil, err
 	}
 func (m *SysDAO) GetCustomer(custID string) (*model.TaCustomer, error) {
 	var cust model.TaCustomer
 
-	has, err := m.db.Where("customer_id=?", custID).And("status=?", STATUS_NOMAIL).Get(&cust)
+	has, err := m.db.Where("customer_id=?", custID).And("status=?", STATUS_NORMAL).Get(&cust)
 	if err != nil {
 		return nil, err
 	}
 
 	return &cust, nil
 }
+
+// CheckUserMappingByOpenID 校验并更新客户信息
+// 如果不存在, 则插入新数据
+func (m *SysDAO) CheckUserMappingByOpenID(user *model.TaUserMapping) error {
+	var innerUsers []model.TaUserMapping
+
+	if err := m.db.Where("account_type=?", user.AccountType).
+		And("openid=?", user.Openid).
+		Find(&innerUsers); err != nil {
+		return err
+	}
+
+	// 如果没有, 则插入新数据
+	if len(innerUsers) == 0 {
+		user.MappingId = guid.NewGUIDString()
+		_, err := m.db.Insert(&user)
+		return err
+	}
+
+	// 如果 userid 是空, 则需要找到数据的正常映射
+	if user.UserId == "" {
+		for _, u := range innerUsers {
+			if u.UserId != "" && u.UserType == user.UserType {
+				user.UserId = u.UserId
+				user.MappingId = u.MappingId
+			}
+		}
+	}
+
+	// 否则更新数据
+	if user.AccountInfo == "" {
+		return nil
+	}
+
+	cols := []string{
+		"account_info",
+	}
+
+	_, err := m.db.Cols(cols...).
+		Where("account_type=?", user.AccountType).
+		And("openid=?", user.Openid).
+		Update(&user)
+	return err
+}
+
+// GetUserMappingByOpenID 获取用户映射信息
+func (m *SysDAO) GetUserMappingByOpenID(openID, userType, accType string) (*model.TaUserMapping, error) {
+	user := model.TaUserMapping{}
+
+	_, err := m.db.Where("user_type=?", userType).
+		And("account_type=?", accType).
+		And("openid=?", openID).
+		Get(&user)
+
+	return &user, err
+}

service/sys.go

 package service
 
 import (
+	"encoding/json"
 	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 )
 
 
 	found := false
 	for _, cs := range cases {
-		if cs.IsBelong == 1 {
+		if cs.IsBelong == models.BOOL_TRUE {
 			found = true
 			s.ctx.Set("currentCase", cs)
 		}
 		return utils.LogError("用户没有设置默认案场")
 	}
 
-	org, err := s.dao.GetUserOrg(org)
+	org, err := s.dao.GetOrg(user.OrgId)
 	if err != nil {
 		return utils.LogError("获取用户组织信息失败: " + err.Error())
 	}
 	s.ctx.Set("customer", *cust)
 	return nil
 }
+
+// CheckWechatUserMapping 校验并更新客户信息
+// 如果不存在, 则插入新数据
+func (s *SysServ) CheckWechatUserMapping(user map[string]interface{}, userType string) (*model.TaUserMapping, error) {
+	openID := user["openid"].(string)
+	uuID := ""
+	uuidRaw, ok := user["unionid"]
+	if ok {
+		uuID = uuidRaw.(string)
+	}
+
+	accountRaw, err := json.Marshal(user)
+	if err != nil {
+		return nil, err
+	}
+	account := string(accountRaw)
+
+	userMapping := model.TaUserMapping{
+		UserType:    userType,
+		AccountType: models.ACCMAP_WECHAT,
+		Openid:      openID,
+		Uuid:        uuID,
+		AccountInfo: account,
+	}
+
+	if err := s.dao.CheckUserMappingByOpenID(&userMapping); err != nil {
+		return nil, err
+	}
+
+	return &userMapping, nil
+}

utils/log.go

 import (
 	"errors"
 
-	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/config"
+	"github.com/astaxie/beego/logs"
 )
 
+var defaultLogger *logs.BeeLogger
+var instances map[string]*logs.BeeLogger
+
+// NewLog 构造日志对象
+func NewLog(tp ...string) *logs.BeeLogger {
+	logType := "common"
+	if len(tp) > 0 {
+		if tp[0] != "" {
+			logType = tp[0]
+		}
+	}
+
+	if v, ok := instances[logType]; ok {
+		return v
+	}
+
+	log := logs.NewLogger()
+	instances[logType] = log
+
+	// 读取配置文件
+	conf, err := config.NewConfig("ini", "./conf/log.conf")
+	if err != nil {
+		log.SetLogger(logs.AdapterConsole)
+		return log
+	}
+
+	// 读文件存储位置
+	filename := conf.String(logType + "::filename")
+	// 输出级别
+	level := conf.String(logType + "::level")
+	if level == "" {
+		level = "error"
+	}
+
+	if filename == "" {
+		filename = "./" + logType + ".log"
+	}
+
+	log.Async()
+	log.SetLogger(logs.AdapterFile, `{"filename":"`+filename+`"}`)
+	return log
+}
+
 // LogError 错误日志
 func LogError(v ...interface{}) error {
-	beego.Error(v...)
+	log := instances["common"]
 
 	if len(v) > 0 {
-		switch err := v[0].(type) {
+		firstV := v[0]
+		leftV := v[1:]
+
+		switch err := firstV.(type) {
 		case string:
+			log.Error(err, leftV...)
 			return errors.New(err)
 		case error:
+			log.Error(err.Error(), leftV...)
 			return err
 		default:
-			return errors.New("Unknown error type")
+			msg := "Unknown error type"
+			log.Error(msg, leftV...)
+			return errors.New(msg)
 		}
 	}
 
 	return nil
 }
+
+// GetDefaultLogger 获取默认 logger
+func GetDefaultLogger() *logs.BeeLogger {
+	log := instances["common"]
+	return log
+}
+
+func init() {
+	instances = make(map[string]*logs.BeeLogger)
+	NewLog()
+
+	defaultLogger = GetDefaultLogger()
+}

utils/wechat.go

+package utils
+
+import (
+	"github.com/zjxpcyc/wechat/wx"
+)
+
+var wxCli *wx.Client
+
+// InitWeChatClient 初始化
+func InitWeChatClient(cert map[string]string) {
+	wxCli = wx.NewClient(cert)
+	wx.SetLogInst(defaultLogger)
+}
+
+// GetWxUserInfo 微信获取用户信息
+func GetWxUserInfo(code string) (map[string]interface{}, error) {
+	return wxCli.GetUserInfo(code)
+}
+
+// WechatSignature 启用 Wechat 接口
+func WechatSignature(timestamp, nonce string) string {
+	return wxCli.Signature(timestamp, nonce)
+}