change jwt-token

controllers/auth.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-	"strings"
-
-	"github.com/astaxie/beego"
+	"time"
 )
 
 // Authenticate 权限验证
 func (c *BaseController) authenticate() {
-
-	// 默认 service
 	serv := service.NewSysServ(c.Context)
 
-	orgID := c.GetString(":org")
-	if orgID == "" {
-		c.ResponseError(errors.New("接口地址访问不正确"))
-	}
-	serv.SetOrgByID(orgID)
-
-	// 客户端类型
-	clientType := utils.GetClientType(c.Ctx.Request)
-
-	switch clientType {
-	case utils.ClientAdmin:
-		c.authPCAdmin(serv)
-	case utils.ClientWechat:
-		c.authWechat(serv)
-	default:
-		c.ResponseError(
-			errors.New("暂不支持的 API 场景"),
-			http.StatusBadRequest,
-		)
-	}
-}
+	// 鉴权 - 并初始化上下文
+	res := serv.AuthAndInitCtx(c.Ctx)
 
-// authPCAdmin PC管理端
-func (c *BaseController) authPCAdmin(serv *service.SysServ) {
-	if !c.needAuth() {
-		return
-	}
+	// 设置 TOKEN
+	c.setToken()
 
-	// 用户ID
-	userID := ""
-	userIDRaw := c.GetSession(SNUserID)
-	if userIDRaw != nil {
-		userID = userIDRaw.(string)
-	}
+	if res != nil {
+		code := http.StatusOK
+		if res["code"] != nil {
+			code = res["code"].(int)
+		}
 
-	if userID == "" {
-		c.ResponseError(
-			errors.New("用户未登录"),
-			http.StatusUnauthorized,
-		)
-	}
+		if code != http.StatusOK {
+			err := res["error"].(error)
+			data := map[string]interface{}{}
 
-	if err := serv.SetUserProfile(userID); err != nil {
-		// utils.LogError(err.Error())
+			if res["message"] != nil {
+				data = res["message"].(map[string]interface{})
+			}
 
-		c.ResponseError(
-			utils.LogError(err.Error()),
-			http.StatusInternalServerError,
-		)
+			c.ResponseData(data, err, code)
+		}
 	}
-
-	// 设置 Session
-	c.SetSession(SNUserID, userID)
 }
 
-// authWechat 微信端
-func (c *BaseController) authWechat(serv *service.SysServ) {
-	custID := ""
-	custIDRaw := c.GetSession(SNCustID)
-	if custIDRaw != nil {
-		custID = custIDRaw.(string)
-	}
-
-	// 机构
-	org := c.Context.Get("org").(model.SysOrg)
-
-	// 微信配置
-	wxConf, err := serv.GetWeChatConfig(org.OrgId)
-	if err != nil {
-		utils.LogError("查询微信配置失败: " + err.Error())
-		c.ResponseError(
-			errors.New("没有找到微信相关配置"),
-			http.StatusBadRequest,
-		)
-	}
-	utils.WxClientSingleton(org.OrgId, wxConf)
+// setToken 设置 TOKEN
+// 15 分钟后过期
+func (c *BaseController) setToken() {
+	var token *utils.JWTToken
+	exp := time.Now().Local().Add(15 * time.Second)
 
-	// 用户微信信息
-	var wxDetail map[string]interface{}
+	if c.Context.Get("user") != nil {
+		user := c.Context.Get("user").(model.SysUser)
 
-	detailRaw := c.GetSession("wechat_user")
-	if detailRaw != nil {
-		wxDetail = detailRaw.(map[string]interface{})
-	} else {
-		// DEV MODE
-		if c.RunMode == "dev" {
-			wxDetail = map[string]interface{}{
-				"openid":     "OPENID",
-				"nickname":   "NICKNAME",
-				"sex":        "1",
-				"province":   "PROVINCE",
-				"city":       "CITY",
-				"country":    "COUNTRY",
-				"headimgurl": "http://thirdwx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/46",
-				"unionid":    "o6_bmasdasdsad6_2sgVt7hMZOPfL",
-			}
-		} else {
-			wxDetail = c.getWechatDetail(org.OrgId, serv)
+		token = &utils.JWTToken{
+			Guest:  false,
+			ID:     user.UserId,
+			Expire: exp,
 		}
+	} else if c.Context.Get("userMap") != nil {
+		userMap := c.Context.Get("userMap").(model.TaUserMapping)
 
-		c.SetSession("wechat_user", wxDetail)
-	}
-
-	c.Context.Set("wxInfo", wxDetail)
-
-	// 用户映射检查
-	userMap, err := serv.CheckWechatUserMapping(wxDetail)
-	if err != nil {
-		c.ResponseError(
-			utils.LogError("获取人员映射账户失败: "+err.Error()),
-			http.StatusInternalServerError,
-		)
-	}
-	c.Context.Set("userMap", *userMap)
-
-	if !c.needAuth() {
-		return
-	}
-	// 未登录或者绑定, 返回 406
-	if custID == "" && userMap.UserId == "" {
-		// 新增用户信息
-		cust, err := serv.SaveNewCustomer(wxDetail, userMap)
-		if err != nil {
-			c.ResponseError(err)
+		token = &utils.JWTToken{
+			Guest:  false,
+			ID:     userMap.Openid,
+			Expire: exp,
 		}
-		custID = cust.CustomerId
-		// c.ResponseError(
-		// 	errors.New("用户未登录或绑定"),
-		// 	http.StatusNotAcceptable,
-		// )
-	}
-
-	if custID == "" {
-		custID = userMap.UserId
-	}
-	if custID != "" {
-		if err := serv.SetCustomer(custID); err != nil {
-			utils.LogError(err.Error())
-
-			c.ResponseError(
-				errors.New("内部错误, 请重试"),
-				http.StatusInternalServerError,
-			)
+	} else {
+		token = &utils.JWTToken{
+			Guest:  true,
+			Expire: exp,
 		}
-
-		// 设置 Session
-		c.SetSession(SNCustID, custID)
-	}
-}
-
-func (c *BaseController) needAuth() bool {
-	route := c.Ctx.Input.URL()
-	apiPrefix := beego.AppConfig.String("api::prefix")
-	guestAPI := beego.AppConfig.String("api::guest")
-
-	if strings.Index(route, apiPrefix+strings.Split(guestAPI, ":")[0]) > -1 {
-		return false
-	}
-
-	return true
-}
-
-// getWechatDetail 获取微信个人信息详情
-func (c *BaseController) getWechatDetail(org string, serv *service.SysServ) map[string]interface{} {
-	// 微信 code
-	code := c.GetString("code")
-	if code == "" {
-		c.ResponseData(
-			map[string]interface{}{
-				"appid": utils.GetWxAppID(org),
-			},
-			errors.New("获取微信信息失败"),
-			http.StatusUnauthorized,
-		)
 	}
 
-	usr, err := utils.WxClientFor(org).GetUserInfo(code)
+	tokenEncode, err := utils.CreateToken(token.ToMap())
 	if err != nil {
+		utils.LogError("系统生成 Token 失败: " + err.Error())
 		c.ResponseError(
-			utils.LogError("获取微信个人信息失败: "+err.Error()),
+			errors.New("系统异常, 请退出重试"),
 			http.StatusInternalServerError,
 		)
 	}
 
-	return usr
+	c.Ctx.Output.Header(utils.TokenHeader, utils.TokenSchema+" "+tokenEncode)
 }

controllers/context.go

 * user					SysUser 									用户基本信息
 * customer			TaCustomer 								会员基本信息
 * userMap				TaUserMapping 						用户/会员 映射第三方账户
-* wxInfo				map[string]interface{} 		微信信息
 * cases					[]SysUserCase 						用户所有案场信息
 * currentCase		SysUserCase 							当前案场
 * org						SysOrg 										用户当前组织

models/constant.go

 	GIVE_GIFT_GYM            = "gym"
 )
 
+// 卡券发放类型
+const (
+	GIVE_TYPE_SYSTEM  = "system"
+	GIVE_TYPE_CASE    = "case"
+	GIVE_TYPE_CHANNEL = "channel"
+)
+
 // 游泳健身卡种类
 const (
 	GYM_CARD_ONCE    = "once"

service/customer/customer.go

 package customer
 
 import (
+	"encoding/json"
 	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/cases"
 	}
 
 	if cust == nil {
-		wxInfoRaw := s.ctx.Get("wxInfo")
-		if wxInfoRaw == nil {
-			return nil, errors.New("请确定使用微信端登录")
+		wxInfo := utils.WechatUser{}
+		if err := json.Unmarshal([]byte(userMap.AccountInfo), &wxInfo); err != nil {
+			utils.LogError("解析用户微信映射信息失败: " + err.Error())
+			return nil, errors.New("系统数据异常")
 		}
 
-		wxInfo := wxInfoRaw.(map[string]interface{})
 		// 更新用户手机号码信息及userid信息
-		openid := wxInfo["openid"].(string)
-		customer, err := s.dao.GetCustWithWXByOpenID(openid)
+		customer, err := s.dao.GetCustWithWXByOpenID(wxInfo.OpenID)
 
 		newCust := model.TaCustomer{
 			CustomerId: customer.CustomerId,
 			return nil, err
 		}
 
-		// newCust, err := s.SaveNewCustomer(wxInfo, "", "", user.Phone, user.UserId)
-		// if err != nil {
-		// 	utils.LogError(err.Error())
-		// 	return nil, err
-		// }
 		cust = &newCust
 	} else {
 		if cust.Status != models.STATUS_NORMAL {
 
 	// 用户不存在, 则新增
 	if cust == nil {
-		wxInfoRaw := s.ctx.Get("wxInfo")
-		if wxInfoRaw == nil {
-			return nil, errors.New("请确定使用微信端登录")
+		wxInfo := utils.WechatUser{}
+		if err := json.Unmarshal([]byte(userMap.AccountInfo), &wxInfo); err != nil {
+			utils.LogError("解析用户微信映射信息失败: " + err.Error())
+			return nil, errors.New("系统数据异常")
 		}
 
-		wxInfo := wxInfoRaw.(map[string]interface{})
-
 		// 更新用户手机号码信息及userid信息
-		openid := wxInfo["openid"].(string)
-		customer, err := s.dao.GetCustWithWXByOpenID(openid)
+		customer, err := s.dao.GetCustWithWXByOpenID(wxInfo.OpenID)
 		newCust := model.TaCustomer{
 			CustomerId:  customer.CustomerId,
 			Phone:       phone,
 			return nil, err
 		}
 
-		// newCust, err := s.SaveNewCustomer(wxInfo, caseID, userID, phone, "")
-		// if err != nil {
-		// 	utils.LogError(err.Error())
-		// 	return nil, err
-		// }
-
 		cust = &newCust
 	} else {
 		if cust.Status != models.STATUS_NORMAL {

service/sys.go

 import (
 	"encoding/json"
 	"errors"
+	"net/http"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/customer"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+	"strings"
 
 	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/context"
 )
 
 const (
 
 // SysServ 系统处理
 type SysServ struct {
+	org         model.SysOrg
 	ctx         *utils.Context
 	dao         *models.SysDAO
 	customerdao *customer.CustomerDAO
 	}
 }
 
+// AuthAndInitCtx 鉴权
+// gctx 是 beego 框架中的 Context
+func (s *SysServ) AuthAndInitCtx(gctx *context.Context) map[string]interface{} {
+	// 确认机构
+	orgID := gctx.Input.Query(":org")
+	if orgID == "" {
+		return map[string]interface{}{
+			"code":  http.StatusBadRequest,
+			"error": errors.New("接口地址访问不正确"),
+		}
+	}
+	if err := s.SetOrgByID(orgID); err != nil {
+		return map[string]interface{}{
+			"code":  http.StatusInternalServerError,
+			"error": err,
+		}
+	}
+
+	// 获取 token
+	token, err := s.getToken(gctx)
+	if err != nil {
+		return map[string]interface{}{
+			"code":  http.StatusInternalServerError,
+			"error": err,
+		}
+	}
+	if token != nil {
+		s.ctx.Set("token", *token)
+	}
+
+	// 客户端类型
+	// 通过 UA 判断
+	clientType := utils.GetClientType(gctx.Request)
+
+	// pc 管理端
+	if clientType == utils.ClientAdmin {
+		return s.authPCAdmin(gctx)
+	}
+
+	// wechat 端
+	if clientType == utils.ClientWechat {
+		return s.authWechat(gctx)
+	}
+
+	return map[string]interface{}{
+		"code":  http.StatusBadRequest,
+		"error": errors.New("暂无该客户端的 API"),
+	}
+}
+
+// authPCAdmin
+// 管理端 API 校验
+func (s *SysServ) authPCAdmin(gctx *context.Context) map[string]interface{} {
+	if !s.needAuth(gctx) {
+		return nil
+	}
+
+	token := utils.JWTToken{}
+	if s.ctx.Get("token") != nil {
+		token = s.ctx.Get("token").(utils.JWTToken)
+	}
+
+	if token.ID == "" || token.Guest == true {
+		return map[string]interface{}{
+			"code":  http.StatusUnauthorized,
+			"error": errors.New("用户未登录"),
+		}
+	}
+
+	if err := s.SetUserProfile(token.ID); err != nil {
+		return map[string]interface{}{
+			"code":  http.StatusInternalServerError,
+			"error": err,
+		}
+	}
+
+	return nil
+}
+
+func (s *SysServ) authWechat(gctx *context.Context) map[string]interface{} {
+	// 微信 code
+	code := gctx.Input.Query("code")
+
+	token := utils.JWTToken{}
+	if s.ctx.Get("token") != nil {
+		token = s.ctx.Get("token").(utils.JWTToken)
+	}
+
+	var wxUser *utils.WechatUser
+	var openID string
+
+	// 未登录 或 未验证
+	if token.ID == "" {
+		// 需要微信验证
+		if code == "" {
+			return map[string]interface{}{
+				"code":  http.StatusUnauthorized,
+				"error": errors.New("请授权微信用户登录"),
+				"message": map[string]interface{}{
+					"appid": utils.GetWxAppID(s.org.OrgId),
+				},
+			}
+		}
+
+		// 微信用户信息
+		var err error
+		wxUser, err = s.wechartSignIn(gctx, code)
+		if err != nil {
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": err,
+			}
+		}
+
+		if wxUser == nil {
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": errors.New("请先关注公众号"),
+			}
+		}
+
+		openID = wxUser.OpenID
+	} else {
+		openID = token.ID
+	}
+
+	// 查询数据库是否存在已有映射
+	userMapList, err := s.dao.GetUserMappingByOpenID(openID)
+	if err != nil {
+		utils.LogError("校验人员失败: " + err.Error())
+		return map[string]interface{}{
+			"code":  http.StatusInternalServerError,
+			"error": errors.New("校验人员失败"),
+		}
+	}
+
+	var userMapping *model.TaUserMapping
+	for _, ump := range userMapList {
+		if openID == ump.Openid && models.ACCMAP_WECHAT == ump.AccountType {
+			userMapping = &ump
+		}
+	}
+
+	// 如果尚无人员映射信息, 代表人员初次使用本系统
+	if userMapping == nil {
+		// 如果没有微信用户信息, 代表产生了未知异常
+		if wxUser == nil || wxUser.UnionID == "" {
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": errors.New("系统异常, 请清空缓存后重试"),
+			}
+		}
+
+		wxInfoJSON, err := json.Marshal(wxUser)
+		if err != nil {
+			utils.LogError("转换微信json信息失败: " + err.Error())
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": errors.New("微信信息异常"),
+			}
+		}
+
+		userMapping = &model.TaUserMapping{
+			AccountType: models.ACCMAP_WECHAT,
+			Openid:      openID,
+			Uuid:        wxUser.UnionID,
+			AccountInfo: string(wxInfoJSON),
+		}
+	}
+
+	// 更新映射信息, 没有的话则插入
+	err = s.dao.UpdateUserMapping(userMapping)
+	if err != nil {
+		utils.LogError("保存用户映射信息失败: " + err.Error())
+		return map[string]interface{}{
+			"code":  http.StatusInternalServerError,
+			"error": errors.New("更新用户信息失败"),
+		}
+	}
+	s.ctx.Set("userMap", *userMapping)
+
+	if !s.needAuth(gctx) {
+		return nil
+	}
+
+	var cust *model.TaCustomer
+
+	// 如果只有映射, 但是没有人员信息
+	// 则新增人员
+	if userMapping.UserId == "" {
+		cust, err = s.saveNewCustomer(wxUser, userMapping)
+		if err != nil {
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": err,
+			}
+		}
+	} else {
+		cust, err = s.customerdao.GetCustomerByID(userMapping.UserId)
+		if err != nil {
+			utils.LogError("查询用户信息失败: " + err.Error())
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": err,
+			}
+		}
+	}
+	s.ctx.Set("customer", *cust)
+
+	if cust.UserId != "" {
+		if err := s.SetUserProfile(cust.UserId); err != nil {
+			return map[string]interface{}{
+				"code":  http.StatusInternalServerError,
+				"error": err,
+			}
+		}
+	}
+
+	return nil
+}
+
+// wechartSignIn 使用 code 微信登录
+func (s *SysServ) wechartSignIn(gctx *context.Context, code string) (*utils.WechatUser, error) {
+	if beego.BConfig.RunMode == "dev" {
+		return &utils.WechatUser{
+			OpenID: "OPENID",
+		}, nil
+	}
+
+	// 初始化微信配置
+	if err := s.initWechatClient(s.org.OrgId); err != nil {
+		utils.LogError("初始化微信客户端失败: " + err.Error())
+		return nil, errors.New("初始化微信客户端失败")
+	}
+
+	// 获取 微信信息
+	// 可能出现的情况是 openid 获取到了, 但是详情没有获取到
+	wxUserMap, err := utils.WxClientFor(s.org.OrgId).GetUserInfo(code)
+	if err != nil {
+		utils.LogError("获取微信信息失败: " + err.Error())
+
+		if wxUserMap == nil {
+			return nil, errors.New("获取微信信息失败")
+		}
+	}
+
+	return utils.MapToWechatUser(wxUserMap), nil
+}
+
+func (s *SysServ) getToken(gctx *context.Context) (*utils.JWTToken, error) {
+	tokenRaw := gctx.Input.Header(utils.TokenHeader)
+	if tokenRaw == "" {
+		return nil, nil
+	}
+
+	tokenEnStr := strings.Trim(strings.TrimLeft(tokenRaw, utils.TokenSchema), " ")
+
+	token, err := utils.PareseToken(tokenEnStr)
+	if err != nil {
+		utils.LogError("解析 Token 失败: " + err.Error())
+		return nil, errors.New("解析 Token 失败")
+	}
+
+	return utils.MapToJWTToken(token), nil
+}
+
+func (s *SysServ) needAuth(gctx *context.Context) bool {
+	route := gctx.Input.URL()
+	apiPrefix := beego.AppConfig.String("api::prefix")
+	guestAPI := beego.AppConfig.String("api::guest")
+
+	if strings.Index(route, apiPrefix+strings.Split(guestAPI, ":")[0]) > -1 {
+		return false
+	}
+
+	return true
+}
+
 // SetUserProfile 设置用户信息
 func (s *SysServ) SetUserProfile(id string) error {
 	user, err := s.dao.GetPureUserInfo(id)
 	return nil
 }
 
-// SetCustomer 设置客户信息
-func (s *SysServ) SetCustomer(id string) error {
-	cust, err := s.dao.GetCustomer(id)
-	if err != nil {
-		return utils.LogError("获取客户基本信息失败: " + err.Error())
-	}
-
-	s.ctx.Set("customer", *cust)
-	return nil
-}
-
-// SaveNewCustomer 新增用户
-func (s *SysServ) SaveNewCustomer(wxInfo map[string]interface{}, userMap *model.TaUserMapping) (*model.TaCustomer, error) {
-	// 微信相关字段
-	nickyName := wxInfo["nickname"].(string)
-	sex := wxInfo["sex"].(float64)
-	headimgurl := wxInfo["headimgurl"].(string)
-
-	org := s.ctx.Get("org").(model.SysOrg)
-
+// saveNewCustomer 新增用户
+func (s *SysServ) saveNewCustomer(wxUser *utils.WechatUser, userMap *model.TaUserMapping) (*model.TaCustomer, error) {
 	cust := model.TaCustomer{
-		CustomerName: nickyName,
-		Name:         nickyName,
-		Sex:          int(sex),
-		Headimgurl:   headimgurl,
-		OrgId:        org.OrgId,
+		CustomerName: wxUser.NickName,
+		Name:         wxUser.NickName,
+		Sex:          int(wxUser.Sex),
+		Headimgurl:   wxUser.HeadImgURL,
+		OrgId:        s.org.OrgId,
 	}
 
 	if err := s.customerdao.SaveCustomer(&cust); err != nil {
 
 	accountRaw, err := json.Marshal(user)
 	if err != nil {
-		beego.Error(err)
 		return nil, err
 	}
 	account := string(accountRaw)
 	userMapList, err := s.dao.GetUserMappingByOpenID(openID)
 
 	if err != nil {
-		beego.Error(err)
 		return nil, err
 	}
 
 	return &userMapping, nil
 }
 
-// GetWeChatConfig 获取微信配置
-func (s SysServ) GetWeChatConfig(org string) (map[string]string, error) {
-	conf, err := s.dao.GetWeChatConfig(org)
+// initWechatClient 初始化微信客户端
+func (s SysServ) initWechatClient(orgID string) error {
+	conf, err := s.dao.GetWeChatConfig(orgID)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取微信配置失败: " + err.Error())
+		return errors.New("获取微信配置失败")
 	}
 
-	if conf.ConfId == "" {
-		return nil, errors.New("未找到微信配置")
+	if conf == nil || conf.ConfId == "" {
+		return errors.New("未找到微信配置")
 	}
 
-	return map[string]string{
+	cert := map[string]string{
 		"appid":  conf.Appid,
 		"secret": conf.Secret,
 		"token":  conf.Token,
 		"aeskey": conf.Aeskey,
 		"wxid":   conf.Wxid,
-	}, nil
+	}
+
+	utils.WxClientSingleton(orgID, cert)
+	return nil
 }
 
 // SetOrgByID 获取组织
 	}
 
 	s.ctx.Set("org", *org)
+	s.org = *org
 
 	return nil
 }

utils/jwt.go

 
 import (
 	"errors"
+	"time"
 
 	jwt "github.com/dgrijalva/jwt-go"
 )
 
+const (
+	TokenHeader = "Authorization"
+	TokenSchema = "Bearer"
+)
+
 var tokenSignedKey = []byte(`Yansen is so handsome!`)
 
 // CreateToken 获取token
 
 	return nil, errors.New("Token 解析 未知错误")
 }
+
+// JWTToken token 内容
+type JWTToken struct {
+	Guest    bool
+	ID       string
+	Password string
+	Expire   time.Time
+}
+
+// ToMap 转 map
+func (t *JWTToken) ToMap() map[string]interface{} {
+	return map[string]interface{}{
+		"guest":    t.Guest,
+		"user":     t.ID,
+		"password": t.Password,
+		"exp":      t.Expire,
+	}
+}
+
+// MapToJWTToken map 映射 Token
+func MapToJWTToken(data map[string]interface{}) *JWTToken {
+	token := JWTToken{}
+
+	if data["guest"] != nil {
+		token.Guest = data["guest"].(bool)
+	}
+
+	if data["user"] != nil {
+		token.ID = data["user"].(string)
+	}
+
+	if data["password"] != nil {
+		token.Password = data["password"].(string)
+	}
+
+	if data["exp"] != nil {
+		token.Expire = data["exp"].(time.Time)
+	}
+
+	return &token
+}

utils/wechat.go

 
 var wxClients map[string]*wx.Client
 
+type WechatUser struct {
+	OpenID     string  `json:"openid"`
+	NickName   string  `json:"nickname"`
+	Sex        float64 `json:"sex"`
+	Province   string  `json:"province"`
+	City       string  `json:"city"`
+	Country    string  `json:"country"`
+	HeadImgURL string  `json:"headimgurl"`
+	UnionID    string  `json:"unionid"`
+}
+
 // WxClientSingleton 初始化
 func WxClientSingleton(org string, cert map[string]string) {
 	if wxClients == nil {
 func init() {
 	wx.SetLogInst(defaultLogger)
 }
+
+// MapToWechatUser 映射微信人员
+func MapToWechatUser(data map[string]interface{}) *WechatUser {
+	subscribe, has := data["subscribe"]
+	if has {
+		if subscribe == nil {
+			return nil
+		}
+
+		sub := subscribe.(float64)
+		if sub == 0 {
+			return nil
+		}
+	}
+
+	user := WechatUser{
+		OpenID: data["openid"].(string),
+	}
+
+	if data["sex"] != nil {
+		user.Sex = data["sex"].(float64)
+	}
+
+	if data["province"] != nil {
+		user.Province = data["province"].(string)
+	}
+
+	if data["city"] != nil {
+		user.City = data["city"].(string)
+	}
+
+	if data["country"] != nil {
+		user.Country = data["country"].(string)
+	}
+
+	if data["headimgurl"] != nil {
+		user.HeadImgURL = data["headimgurl"].(string)
+	}
+
+	if data["unionid"] != nil {
+		user.UnionID = data["unionid"].(string)
+	}
+
+	return &user
+}