feats

conf/db.conf

 
 ; 数据库地址，可以使用IP
 # db_addr      = 192.168.0.122
-db_addr      = localhost
+db_addr      = 192.168.0.122
 
 ; 端口
 db_port      = 3306

controllers/base.go

 	}
 
 	c.destroyContext(status < http.StatusMultipleChoices)
-
 	c.crosPolicy()
 	c.ServeJSON()
 	c.StopRun()

controllers/card/card.go

 
 // GetCardWithCustomer 获取卡及领取信息
 func (c *CardController) GetCardWithCustomer() {
-
+	c.ResponseJSON("ok")
 }

controllers/customer/customer.go

 		}
 	}
 	userMapping := c.Context.Get("userMap").(model.TaUserMapping)
-	cust, err := c.serv.BindWechatUser(&userMapping, phone)
+	_, err := c.serv.BindWechatUser(&userMapping, phone)
 	if err != nil {
 		c.ResponseError(err)
 	}
 
-	c.SetSession(controllers.SNCustID, cust.CustomerId)
-
 	c.ResponseJSON("ok")
 }
 
 
 	userMapping := c.Context.Get("userMap").(model.TaUserMapping)
 
-	cust, err := c.serv.BindWechatCust(&userMapping, phone, csID, arID)
+	_, err := c.serv.BindWechatCust(&userMapping, phone, csID, arID)
 	if err != nil {
 		c.ResponseError(err)
 	}
 
-	c.SetSession(controllers.SNCustID, cust.CustomerId)
-
 	c.ResponseJSON("ok")
 }
 

controllers/file.go

 
 	r := bytes.NewReader(buf.Bytes())
 	http.ServeContent(c.Ctx.ResponseWriter, c.Ctx.Request, fn, time.Now().Local(), r)
+
+	c.destroyContext(true)
 	c.StopRun()
 }

controllers/session.go

-package controllers
-
-// session key 列表
-const (
-	// 用户ID
-	SNUserID = "userid"
-
-	// 客户ID
-	SNCustID = "custid"
-
-	// 内置 wechat_user
-	// 请勿使用 wechat_user 作为 session 的key
-)

controllers/wechat.go

+package controllers
+
+import (
+	"errors"
+	"net/url"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+)
+
+// GetWxJsSDKSignature 获取 微信 jssdk 签名
+func (c *BaseController) GetWxJsSDKSignature() {
+	org := c.Context.Get("org").(model.SysOrg)
+	url, _ := url.QueryUnescape(c.GetString("url"))
+
+	cli := utils.WxClientFor(org.OrgId)
+	if cli == nil {
+		c.ResponseError(errors.New("初始化微信服务失败"))
+	}
+
+	res := cli.GetJsTicketSignature(url)
+	c.ResponseJSON(res)
+}
+
+// MiniLogin 获取小程序 OPENID
+func (c *BaseController) MiniLogin() {
+	org := c.Context.Get("org").(model.SysOrg)
+	code := c.GetString("code")
+
+	cli := utils.MiniClientFor(org.OrgId)
+	if cli == nil {
+		c.ResponseError(errors.New("初始化小程序服务失败"))
+	}
+
+	res, err := cli.GetOpenID(code)
+	if err != nil {
+		utils.LogError("获取用户信息失败: " + err.Error())
+		c.ResponseError(errors.New("获取用户信息失败"))
+	}
+
+	c.ResponseJSON(res)
+}
+
+// DecodeMiniData 解密小程序信息
+func (c *BaseController) DecodeMiniData() {
+	org := c.Context.Get("org").(model.SysOrg)
+
+	cli := utils.MiniClientFor(org.OrgId)
+	if cli == nil {
+		c.ResponseError(errors.New("初始化小程序服务失败"))
+	}
+
+	data := c.GetString("encrypted_data")
+	key := c.GetString("session_key")
+	iv := c.GetString("iv")
+
+	res, err := cli.GetUserFromEncryptData(data, key, iv)
+	if err != nil {
+		utils.LogError("解密用户信息失败: " + err.Error())
+		c.ResponseError(errors.New("解密用户信息失败"))
+	}
+
+	c.ResponseJSON(res)
+}

models/models.go

 	dns := getMySQLDNS()
 
 	engine, err := xorm.NewEngine(dbType, dns)
-	// dao.ShowSQL()
+	// engine.ShowSQL()
 
 	if err != nil {
 		panic(err)

models/sys.go

 import (
 	"errors"
 	"spaceofcheng/services/models/model"
-	"spaceofcheng/services/utils"
 	"time"
 
 	"github.com/yl10/kit/guid"
-
-	"github.com/go-xorm/xorm"
 )
 
-// SysDAO 系统
-type SysDAO struct {
-	ctx *utils.Context
-	db  *xorm.Session
-}
-
-// NewSysDAO New Inst
-func NewSysDAO(ctx *utils.Context) *SysDAO {
-	return &SysDAO{
-		ctx: ctx,
-		db:  ctx.DB,
-	}
-}
-
 // GetPureUserInfo 获取用户基本信息
-func (m *SysDAO) GetPureUserInfo(id string) (*model.SysUser, error) {
+func GetPureUserInfo(id string) (*model.SysUser, error) {
 	user := model.SysUser{}
 
-	has, err := m.db.Where("user_id=?", id).Get(&user)
+	has, err := DBEngine.Where("user_id=?", id).Get(&user)
 	if err != nil {
 		return nil, err
 	}
 }
 
 // GetUserMenu 获取用户菜单
-func (m *SysDAO) GetUserMenu(userID string) ([]model.SysMenu, error) {
+func GetUserMenu(userID string) ([]model.SysMenu, error) {
 	query := `
 		SELECT t.*
 		FROM sys_menu t
 	`
 
 	var menus []model.SysMenu
-	if err := m.db.SQL(query, userID, STATUS_NORMAL).Find(&menus); err != nil {
+	if err := DBEngine.SQL(query, userID, STATUS_NORMAL).Find(&menus); err != nil {
 		return nil, err
 	}
 
 }
 
 // GetUserCase 获取用户案场
-func (m *SysDAO) GetUserCase(userID string) ([]model.SysUserCase, error) {
+func GetUserCase(userID string) ([]model.SysUserCase, error) {
 	query := `
 		SELECT t.*
 		FROM sys_user_case t
 	`
 
 	var cases []model.SysUserCase
-	if err := m.db.SQL(query, userID, STATUS_NORMAL).Find(&cases); err != nil {
+	if err := DBEngine.SQL(query, userID, STATUS_NORMAL).Find(&cases); err != nil {
 		return nil, err
 	}
 
 }
 
 // GetOrg 获取机构信息
-func (m *SysDAO) GetOrg(orgID string) (*model.SysOrg, error) {
+func GetOrg(orgID string) (*model.SysOrg, error) {
 	var org model.SysOrg
-	has, err := m.db.Where("org_id=?", orgID).And("status=?", STATUS_NORMAL).Get(&org)
+	has, err := DBEngine.Where("org_id=?", orgID).And("status=?", STATUS_NORMAL).Get(&org)
 	if err != nil {
 		return nil, err
 	}
 
 // GetCustomer 获取用户信息
 // 暂时无法解决 一个用户 多组织架构的问题
-func (m *SysDAO) GetCustomer(custID string) (*model.TaCustomer, error) {
+func GetCustomer(custID string) (*model.TaCustomer, error) {
 	var cust model.TaCustomer
 
-	has, err := m.db.Where("customer_id=?", custID).And("status=?", STATUS_NORMAL).Get(&cust)
+	has, err := DBEngine.Where("customer_id=?", custID).And("status=?", STATUS_NORMAL).Get(&cust)
 	if err != nil {
 		return nil, err
 	}
 }
 
 // GetUserMappingByOpenID 获取用户映射信息
-func (m *SysDAO) GetUserMappingByOpenID(openID string) ([]model.TaUserMapping, error) {
+func GetUserMappingByOpenID(openID string) ([]model.TaUserMapping, error) {
 	var users []model.TaUserMapping
 
-	err := m.db.Where("openid=?", openID).Find(&users)
+	err := DBEngine.Where("openid=?", openID).Find(&users)
 	return users, err
 }
 
-// UpdateUserMapping 保存用户映射信息
-func (m *SysDAO) UpdateUserMapping(user *model.TaUserMapping) error {
+// EditUserMapping 保存用户映射信息
+func EditUserMapping(user *model.TaUserMapping) error {
 	// 如果没有映射ID, 则新增记录
 	if user.MappingId == "" {
 		user.MappingId = guid.NewGUIDString()
-		_, err := m.db.Insert(user)
+		_, err := DBEngine.Insert(user)
 		return err
 	}
 
 	cols := []string{
 		"account_info",
 	}
-	_, err := m.db.Cols(cols...).
+	_, err := DBEngine.Cols(cols...).
 		Where("account_type=?", user.AccountType).
 		And("openid=?", user.Openid).
 		Update(user)
 	return err
 }
 
-// GetCaseByContext 获取案场
-func GetCaseByContext(ctx *utils.Context) (string, error) {
-	csRaw := ctx.Get("currentCase")
-	if csRaw == nil {
-		return "", errors.New("当前人员无案场权限")
-	}
-
-	cs := csRaw.(model.SysUserCase)
-	if cs.CaseId == "" || cs.Status == STATUS_DEL {
-		return "", errors.New("当前人员无案场权限")
-	}
-
-	return cs.CaseId, nil
-}
-
 // GetWeChatConfig 获取微信配置
-func (m *SysDAO) GetWeChatConfig(org string) (*model.SysWechatConf, error) {
+func GetWeChatConfig(org, cliType string) (*model.SysWechatConf, error) {
 	conf := new(model.SysWechatConf)
 
-	if _, err := m.db.Where("org_id=?", org).And("type=?", WECHAT_WX).Get(conf); err != nil {
+	if _, err := DBEngine.Where("org_id=?", org).And("type=?", cliType).Get(conf); err != nil {
 		return nil, err
 	}
 
 }
 
 // InsertToken 插入 token 生成记录
-func (m *SysDAO) InsertToken(token string) error {
+func InsertToken(token string) error {
 	tk := model.SysTokenLog{
 		Token:      token,
 		Status:     STATUS_NORMAL,
 		CreateDate: time.Now().Local(),
 	}
 
-	if _, err := m.db.Insert(&tk); err != nil {
+	if _, err := DBEngine.Insert(&tk); err != nil {
 		return err
 	}
 
 }
 
 // UpdateTokenExpire 设置 token 过期
-func (m *SysDAO) UpdateTokenExpire(token string) error {
+func UpdateTokenExpire(token string) error {
 	tk := model.SysTokenLog{
 		Status: STATUS_DEL,
 	}
 
-	if _, err := m.db.Cols("status").Where("token=?", token).Update(&tk); err != nil {
+	if _, err := DBEngine.Cols("status").Where("token=?", token).Update(&tk); err != nil {
 		return err
 	}
 
 }
 
 // GetToken 获取 token
-func (m *SysDAO) GetToken(token string) (*model.SysTokenLog, error) {
+func GetToken(token string) (*model.SysTokenLog, error) {
 	tk := model.SysTokenLog{}
 
-	if _, err := m.db.Where("token=?", token).Get(&tk); err != nil {
+	if _, err := DBEngine.Where("token=?", token).Get(&tk); err != nil {
 		return nil, err
 	}
 
 	return &tk, nil
 }
+
+// GetCustomerByID 依据ID获取客户
+func GetCustomerByID(id string) (*model.TaCustomer, error) {
+	cust := new(model.TaCustomer)
+
+	if _, err := DBEngine.Where("customer_id=?", id).Get(cust); err != nil {
+		return nil, err
+	}
+
+	return cust, nil
+}
+
+func SaveCustomer(cust *model.TaCustomer) error {
+	cust.CustomerId = guid.NewGUIDString()
+	cust.CreateDate = time.Now().Local()
+	cust.Status = STATUS_NORMAL
+
+	_, err := DBEngine.Insert(cust)
+	return err
+}
+
+// SaveAccount 保存账户信息
+func SaveAccount(account *model.TaCustomerAccount) error {
+	if account.CustomerId == "" {
+		return errors.New("账户未关联人员")
+	}
+
+	account.Status = STATUS_NORMAL
+	account.CreateDate = time.Now().Local()
+	account.AccountId = guid.NewGUIDString()
+
+	_, err := DBEngine.Insert(account)
+	return err
+}
+
+// UpdateUserMapping 更新用户映射
+func UpdateUserMapping(userMap *model.TaUserMapping, cols []string) error {
+	if userMap.MappingId == "" {
+		return errors.New("用户映射信息不存在")
+	}
+
+	_, err := DBEngine.Where("mapping_id=?", userMap.MappingId).Cols(cols...).Update(userMap)
+	return err
+}

routers/guest.go

 		// 登录
 		beego.NSRouter("/signin", &user.UserController{}, "post:SignIn"),
 
+		// 微信
+		// js sdk 签名
+		beego.NSRouter("/wechat/jssdk/signature", &controllers.BaseController{}, "get:GetWxJsSDKSignature"),
+		beego.NSRouter("/wechat/mini/login", &controllers.BaseController{}, "post:MiniLogin"),
+		beego.NSRouter("/wechat/mini/decodedata", &controllers.BaseController{}, "post:DecodeMiniData"),
+
 		beego.NSRouter("/websocket/:grps/:id", &controllers.BaseController{}, "get:Ws"),
 	)
 }

service/sys.go

 	"errors"
 	"net/http"
 	"spaceofcheng/services/models"
-	"spaceofcheng/services/models/customer"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 	"strings"
 
 // SysServ 系统处理
 type SysServ struct {
-	org         model.SysOrg
-	ctx         *utils.Context
-	dao         *models.SysDAO
-	customerdao *customer.CustomerDAO
+	org model.SysOrg
+	ctx *utils.Context
 }
 
 // NewSysServ 初始化
 func NewSysServ(ctx *utils.Context) *SysServ {
 	return &SysServ{
-		ctx:         ctx,
-		dao:         models.NewSysDAO(ctx),
-		customerdao: customer.NewCustomerDAO(ctx),
+		ctx: ctx,
 	}
 }
 
 		return s.authWechat(gctx)
 	}
 
+	// 小程序 端
+	if clientType == utils.ClientMini {
+		return s.authMini(gctx)
+	}
+
 	return map[string]interface{}{
 		"code":  http.StatusBadRequest,
 		"error": errors.New("暂无该客户端的 API"),
 
 	// 入库
 	if !token.Guest {
-		if err := s.dao.InsertToken(tokenEncodeStr); err != nil {
+		if err := models.InsertToken(tokenEncodeStr); err != nil {
 			utils.LogError("入库 Token 失败: " + err.Error())
 			return tokenEncodeStr
 		}
 	} else {
 		// 初始化微信配置
 		if err := s.initWechatClient(s.org.OrgId); err != nil {
-			utils.LogError("初始化微信客户端失败: " + err.Error())
+			utils.LogError("初始化微信服务失败: " + err.Error())
 
 			return map[string]interface{}{
 				"code":  http.StatusInternalServerError,
-				"error": errors.New("初始化微信客户端失败"),
+				"error": errors.New("初始化微信服务失败"),
 			}
 		}
 
 	}
 
 	// 查询数据库是否存在已有映射
-	userMapList, err := s.dao.GetUserMappingByOpenID(openID)
+	userMapList, err := models.GetUserMappingByOpenID(openID)
 	if err != nil {
 		utils.LogError("校验人员失败: " + err.Error())
 		return map[string]interface{}{
 	}
 
 	// 更新映射信息, 没有的话则插入
-	err = s.dao.UpdateUserMapping(userMapping)
+	err = models.EditUserMapping(userMapping)
 	if err != nil {
 		utils.LogError("保存用户映射信息失败: " + err.Error())
 		return map[string]interface{}{
 			}
 		}
 	} else {
-		cust, err = s.customerdao.GetCustomerByID(userMapping.UserId)
+		cust, err = models.GetCustomerByID(userMapping.UserId)
 		if err != nil {
 			utils.LogError("查询用户信息失败: " + err.Error())
 			return map[string]interface{}{
 	return nil
 }
 
+// 小程序端暂时无人员或者其他业务要求
+func (s *SysServ) authMini(gctx *context.Context) map[string]interface{} {
+	if err := s.initMiniClient(s.org.OrgId); err != nil {
+		utils.LogError("初始化小程序服务失败: " + err.Error())
+
+		return map[string]interface{}{
+			"code":  http.StatusInternalServerError,
+			"error": errors.New("初始化小程序服务失败"),
+		}
+	}
+
+	return nil
+}
+
 // wechartSignIn 使用 code 微信登录
 func (s *SysServ) wechartSignIn(gctx *context.Context, code string) (*utils.WechatUser, error) {
 	// 获取 微信信息
 	}
 
 	// 校验 token
-	tk, err := s.dao.GetToken(tokenEnStr)
+	tk, err := models.GetToken(tokenEnStr)
 	if err != nil {
 		utils.LogError("查询 Token 失败: " + err.Error())
 		return nil, errors.New("校验Token失败或已过期")
 // UpdateTokenExpire 更新 token 为过期
 // 如果发生错误, 此处选择忽略
 func (s *SysServ) UpdateTokenExpire(token string) {
-	if err := s.dao.UpdateTokenExpire(token); err != nil {
+	if err := models.UpdateTokenExpire(token); err != nil {
 		utils.LogError("更新 Token 过期失败: " + err.Error())
 	}
 }
 
 // SetUserProfile 设置用户信息
 func (s *SysServ) SetUserProfile(id string) error {
-	user, err := s.dao.GetPureUserInfo(id)
+	user, err := models.GetPureUserInfo(id)
 	if err != nil {
 		return utils.LogError("获取用户基本信息失败: " + err.Error())
 	}
 	s.ctx.Set("user", *user)
 
-	cases, err := s.dao.GetUserCase(id)
+	cases, err := models.GetUserCase(id)
 	if err != nil {
 		return utils.LogError("获取用户案场信息失败: " + err.Error())
 	}
 		OrgId:        s.org.OrgId,
 	}
 
-	if err := s.customerdao.SaveCustomer(&cust); err != nil {
+	if err := models.SaveCustomer(&cust); err != nil {
 		utils.LogError("更新客户信息失败: " + err.Error())
 		return nil, errors.New("更新客户信息失败")
 	}
 	account.PayedAmount = "0"
 	account.PayedPoints = "0"
 
-	if err := s.customerdao.SaveAccount(account); err != nil {
+	if err := models.SaveAccount(account); err != nil {
 		utils.LogError("插入账户信息失败: " + err.Error())
 		return nil, errors.New("更新客户信息失败")
 	}
 
 	// 更新映射表信息
 	userMap.UserId = cust.CustomerId
-	if err := s.customerdao.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
+	if err := models.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
 		utils.LogError("更新用户映射信息失败:" + err.Error())
 		return nil, errors.New("映射用户信息失败")
 	}
 	return &cust, nil
 }
 
-// CheckWechatUserMapping 校验并更新客户信息
-// 如果不存在, 则插入新数据
-func (s *SysServ) CheckWechatUserMapping(user map[string]interface{}) (*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{
-		AccountType: models.ACCMAP_WECHAT,
-		Openid:      openID,
-		Uuid:        uuID,
-		AccountInfo: account,
-	}
-
-	// 查询数据库是否存在已有映射
-	userMapList, err := s.dao.GetUserMappingByOpenID(openID)
-
-	if err != nil {
-		return nil, err
-	}
-
-	// 如果存在
-	if len(userMapList) > 0 {
-		for _, um := range userMapList {
-			if userMapping.Openid == um.Openid &&
-				userMapping.AccountType == um.AccountType {
-				userMapping.UserId = um.UserId
-
-				// 存在的用户, 使用 ID 作为检查条件去更新
-				userMapping.MappingId = um.MappingId
-			}
-		}
-	}
-
-	// 更新数据库内容, 没有的话则插入
-	err = s.dao.UpdateUserMapping(&userMapping)
-	if err != nil {
-		return nil, err
-	}
-
-	return &userMapping, nil
-}
-
 // initWechatClient 初始化微信客户端
 func (s *SysServ) initWechatClient(orgID string) error {
-	conf, err := s.dao.GetWeChatConfig(orgID)
+	conf, err := models.GetWeChatConfig(orgID, models.WECHAT_WX)
 	if err != nil {
 		utils.LogError("获取微信配置失败: " + err.Error())
 		return errors.New("获取微信配置失败")
 	return nil
 }
 
+func (s *SysServ) initMiniClient(orgID string) error {
+	conf, err := models.GetWeChatConfig(orgID, models.WECHAT_MINI)
+	if err != nil {
+		utils.LogError("获取小程序配置失败: " + err.Error())
+		return errors.New("获取小程序配置失败")
+	}
+
+	if conf == nil || conf.ConfId == "" {
+		return errors.New("未找到小程序配置")
+	}
+
+	cert := map[string]string{
+		"appid":  conf.Appid,
+		"secret": conf.Secret,
+	}
+
+	utils.MiniClientSingleton(orgID, cert)
+	return nil
+}
+
 // SetOrgByID 获取组织
 func (s *SysServ) SetOrgByID(orgID string) error {
 	orgID = utils.DecodeBase64NoTail(orgID)
 
-	org, err := s.dao.GetOrg(orgID)
+	org, err := models.GetOrg(orgID)
 	if err != nil {
 		utils.LogError("获取组织信息失败: " + err.Error())
 		return errors.New("获取组织信息失败")

utils/wechat.go

 package utils
 
 import (
+	"github.com/zjxpcyc/wechat/mini"
 	"github.com/zjxpcyc/wechat/wx"
 )
 
 var wxClients map[string]*wx.Client
+var miniClients map[string]*mini.Client
 
 type WechatUser struct {
 	OpenID     string  `json:"openid"`
 	}
 }
 
+// MiniClientSingleton 初始化
+func MiniClientSingleton(org string, cert map[string]string) {
+	if miniClients == nil {
+		miniClients = map[string]*mini.Client{
+			org: mini.NewClient(cert),
+		}
+	} else {
+		if _, ok := miniClients[org]; !ok {
+			miniClients[org] = mini.NewClient(cert)
+		}
+	}
+}
+
 // WxClientFor 微信客户端
 func WxClientFor(org string) *wx.Client {
 	return wxClients[org]
 }
 
+// MiniClientFor 小程序客户端
+func MiniClientFor(org string) *mini.Client {
+	return miniClients[org]
+}
+
 // GetWxAppID 获取微信ID
 func GetWxAppID(org string) string {
 	return wxClients[org].GetAppID()
 
 func init() {
 	wx.SetLogInst(defaultLogger)
+	mini.SetLogInst(defaultLogger)
 }
 
 // MapToWechatUser 映射微信人员