merge yansen

conf/app.conf

 autorender = false
 copyrequestbody = true
 EnableDocs = true
-sessionon = true
+sessionon = false
 excelpath = ./
 clienturl = http://dev.ycjcjy.com/c-v2
 

controllers/auth.go

 package controllers
 
 import (
-	"errors"
 	"net/http"
-	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
-	"spaceofcheng/services/utils"
-	"strings"
-
-	"github.com/astaxie/beego"
 )
 
 // Authenticate 权限验证
+// 其中 token 的处理方式是
+// 1、获取 request 中 token
+// 2、放入 Context 中
+// 3、校验 token
+// 4、结束后，设置过期并从 Context 中删除
+// 5、生成新的 token， 并放入 Context 中
 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,
-		)
-	}
-}
-
-// authPCAdmin PC管理端
-func (c *BaseController) authPCAdmin(serv *service.SysServ) {
-	if !c.needAuth() {
-		return
-	}
-
-	// 用户ID
-	userID := ""
-	userIDRaw := c.GetSession(SNUserID)
-	if userIDRaw != nil {
-		userID = userIDRaw.(string)
-	}
-
-	if userID == "" {
-		c.ResponseError(
-			errors.New("用户未登录"),
-			http.StatusUnauthorized,
-		)
-	}
-
-	if err := serv.SetUserProfile(userID); err != nil {
-		// utils.LogError(err.Error())
-
-		c.ResponseError(
-			utils.LogError(err.Error()),
-			http.StatusInternalServerError,
-		)
-	}
-
-	// 设置 Session
-	c.SetSession(SNUserID, userID)
-}
-
-// authWechat 微信端
-func (c *BaseController) authWechat(serv *service.SysServ) {
-	custID := ""
-	custIDRaw := c.GetSession(SNCustID)
-	if custIDRaw != nil {
-		custID = custIDRaw.(string)
-	}
+	// 鉴权 - 并初始化上下文
+	res := serv.AuthAndInitCtx(c.Ctx)
 
-	// 机构
-	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)
-
-	// 用户微信信息
-	var wxDetail map[string]interface{}
-
-	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)
+	if res != nil {
+		code := http.StatusOK
+		if res["code"] != nil {
+			code = res["code"].(int)
 		}
 
-		c.SetSession("wechat_user", wxDetail)
-	}
+		if code != http.StatusOK {
+			err := res["error"].(error)
+			data := map[string]interface{}{}
 
-	c.Context.Set("wxInfo", wxDetail)
+			if res["message"] != nil {
+				data = res["message"].(map[string]interface{})
+			}
 
-	// 用户映射检查
-	userMap, err := serv.CheckWechatUserMapping(wxDetail)
-	if err != nil {
-		c.ResponseError(
-			utils.LogError("获取人员映射账户失败: "+err.Error()),
-			http.StatusInternalServerError,
-		)
-	}
-	c.Context.Set("userMap", *userMap)
+			// 设置旧 token 过期
+			c.SetTokenExipre()
 
-	if !c.needAuth() {
-		return
-	}
-	// 未登录或者绑定, 返回 406
-	if custID == "" && userMap.UserId == "" {
-		// 新增用户信息
-		cust, err := serv.SaveNewCustomer(wxDetail, userMap)
-		if err != nil {
-			c.ResponseError(err)
+			c.ResponseData(data, err, code)
 		}
-		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())
+	// 设置旧 token 过期
+	c.SetTokenExipre()
 
-			c.ResponseError(
-				errors.New("内部错误, 请重试"),
-				http.StatusInternalServerError,
-			)
-		}
-
-		// 设置 Session
-		c.SetSession(SNCustID, custID)
-	}
+	// 生成新 token
+	c.CreateNewToken()
 }
 
-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
+// SetTokenExipre 设置 token 过期
+func (c *BaseController) SetTokenExipre() {
+	token := c.Context.Get("token")
+	if token != nil {
+		serv := service.NewSysServ(c.Context)
+		serv.UpdateTokenExpire(token.(string))
 	}
 
-	return true
+	c.Context.Set("token", "")
 }
 
-// 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)
-	if err != nil {
-		c.ResponseError(
-			utils.LogError("获取微信个人信息失败: "+err.Error()),
-			http.StatusInternalServerError,
-		)
-	}
-
-	return usr
+// CreateNewToken 新 token
+func (c *BaseController) CreateNewToken() {
+	serv := service.NewSysServ(c.Context)
+	c.Context.Set("token", serv.NewToken())
 }

controllers/base.go

 	}
 
 	c.Data["json"] = JSONMessage{status, sendMessage, data}
-	c.Ctx.Output.Header("Access-Control-Expose-Headers", "X-Token")
+	c.Ctx.Output.Header("Access-Control-Expose-Headers", utils.TokenHeader)
+
+	token := c.Context.Get("token")
+	if token != nil {
+		tk := token.(string)
+		if tk != "" {
+			c.Ctx.Output.Header(utils.TokenHeader, utils.TokenSchema+" "+tk)
+		}
+	}
 
 	c.crosPolicy()
 	c.ServeJSON()

controllers/context.go

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

controllers/file.go

 package controllers
 
 import (
+	"bytes"
 	"errors"
 	"spaceofcheng/services/utils"
 	"strconv"
 	"time"
 
 	"net/http"
+	"net/url"
 )
 
 // FileUpload 文件上传
 
 	return fileURL, nil
 }
+
+// SaveToExcel 保存文件到 excel
+func (c *BaseController) SaveToExcel(fn string, data interface{}, f func(interface{}) []interface{}) {
+	var buf bytes.Buffer
+	if err := utils.NewTinyXLSXEngine().SetTransFunc(f).SetData(data).Write(&buf); err != nil {
+		utils.LogError("写 xlsx buffer 失败: " + err.Error())
+		c.ResponseError(errors.New("生成 excel 异常, 请重试"))
+	}
+
+	c.Ctx.Output.Header("Content-Disposition", "attachment; filename="+url.QueryEscape(fn))
+	c.Ctx.Output.Header("Content-Description", "File Transfer")
+	c.Ctx.Output.ContentType(".xlsx")
+	c.Ctx.Output.Header("Content-Transfer-Encoding", "binary")
+	c.Ctx.Output.Header("Expires", "0")
+	c.Ctx.Output.Header("Cache-Control", "must-revalidate")
+	c.Ctx.Output.Header("Pragma", "public")
+
+	r := bytes.NewReader(buf.Bytes())
+	http.ServeContent(c.Ctx.ResponseWriter, c.Ctx.Request, fn, time.Now().Local(), r)
+	c.StopRun()
+}

controllers/user/user.go

 		)
 	}
 
-	// 成功之后, 设置 session
-	c.SetSession(controllers.SNUserID, user.UserId)
+	// 成功之后, 生成新 token
+	c.Context.Set("user", *user)
+	c.CreateNewToken()
 
 	if token == "" && doRemember != 0 {
 		var err error
 
 // SignOut 用户登出
 func (c *UserController) SignOut() {
-	c.DestroySession()
+	c.SetTokenExipre()
 	c.ResponseJSON("ok")
 }
 

models/model/sys_token_log.go

+package model
+
+import "time"
+
+type SysTokenLog struct {
+	TokenId    int       `xorm:"not null pk autoincr INT(11)"`
+	Token      string    `xorm:"TEXT"`
+	Status     int       `xorm:"SMALLINT(6)"`
+	CreateDate time.Time `xorm:"DATETIME"`
+}

models/sys.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+	"time"
 
 	"github.com/yl10/kit/guid"
 
 
 	return conf, nil
 }
+
+// InsertToken 插入 token 生成记录
+func (m *SysDAO) InsertToken(token string) error {
+	tk := model.SysTokenLog{
+		Token:      token,
+		Status:     STATUS_NORMAL,
+		CreateDate: time.Now().Local(),
+	}
+
+	if _, err := m.db.Insert(&tk); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateTokenExpire 设置 token 过期
+func (m *SysDAO) UpdateTokenExpire(token string) error {
+	tk := model.SysTokenLog{
+		Status: STATUS_DEL,
+	}
+
+	if _, err := m.db.Cols("status").Where("token=?", token).Update(&tk); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetToken 获取 token
+func (m *SysDAO) GetToken(token string) (*model.SysTokenLog, error) {
+	tk := model.SysTokenLog{}
+
+	if _, err := m.db.Where("token=?", token).Get(&tk); err != nil {
+		return nil, err
+	}
+
+	return &tk, nil
+}

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"
+	"time"
 
 	"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 {
+		// token 报错一律视为需要重新登录
+		return map[string]interface{}{
+			"code":  http.StatusUnauthorized,
+			"error": err,
+		}
+	}
+
+	// 客户端类型
+	// 通过 UA 判断
+	clientType := utils.GetClientType(gctx.Request)
+
+	// pc 管理端
+	if clientType == utils.ClientAdmin {
+		return s.authPCAdmin(gctx, token)
+	}
+
+	// wechat 端
+	if clientType == utils.ClientWechat {
+		return s.authWechat(gctx, token)
+	}
+
+	return map[string]interface{}{
+		"code":  http.StatusBadRequest,
+		"error": errors.New("暂无该客户端的 API"),
+	}
+}
+
+// NewToken 设置 TOKEN
+// 15 分钟后过期
+func (s *SysServ) NewToken() string {
+	var token *utils.JWTToken
+	exp := time.Now().Local().Add(15 * time.Second)
+
+	if s.ctx.Get("userMap") != nil {
+		userMap := s.ctx.Get("userMap").(model.TaUserMapping)
+
+		token = &utils.JWTToken{
+			Guest:  false,
+			ID:     userMap.Openid,
+			Expire: exp,
+		}
+	} else if s.ctx.Get("user") != nil {
+		user := s.ctx.Get("user").(model.SysUser)
+
+		token = &utils.JWTToken{
+			Guest:  false,
+			ID:     user.UserId,
+			Expire: exp,
+		}
+	} else {
+		token = &utils.JWTToken{
+			Guest:  true,
+			Expire: exp,
+		}
+	}
+
+	tokenEncodeStr, err := utils.CreateToken(token.ToMap())
+	if err != nil {
+		utils.LogError("系统生成 Token 失败: " + err.Error())
+		return ""
+	}
+
+	// 入库
+	if !token.Guest {
+		if err := s.dao.InsertToken(tokenEncodeStr); err != nil {
+			utils.LogError("入库 Token 失败: " + err.Error())
+			return tokenEncodeStr
+		}
+	}
+
+	return tokenEncodeStr
+}
+
+// authPCAdmin
+// 管理端 API 校验
+func (s *SysServ) authPCAdmin(gctx *context.Context, token *utils.JWTToken) map[string]interface{} {
+	if !s.needAuth(gctx) {
+		return nil
+	}
+
+	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, token *utils.JWTToken) map[string]interface{} {
+	// 微信 code
+	code := gctx.Input.Query("code")
+
+	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), " ")
+	s.ctx.Set("token", tokenEnStr)
+
+	token, err := utils.PareseToken(tokenEnStr)
+	if err != nil {
+		utils.LogError("解析 Token 失败: " + err.Error())
+		return nil, errors.New("解析Token失败或已过期")
+	}
+
+	// 校验 token
+	tk, err := s.dao.GetToken(tokenEnStr)
+	if err != nil {
+		utils.LogError("查询 Token 失败: " + err.Error())
+		return nil, errors.New("校验Token失败或已过期")
+	}
+
+	if tk.Status == models.STATUS_DEL {
+		return nil, errors.New("超时 或者 Token 已过期")
+	}
+
+	return utils.MapToJWTToken(token), nil
+}
+
+// UpdateTokenExpire 更新 token 为过期
+// 如果发生错误, 此处选择忽略
+func (s *SysServ) UpdateTokenExpire(token string) {
+	if err := s.dao.UpdateTokenExpire(token); err != nil {
+		utils.LogError("更新 Token 过期失败: " + err.Error())
+	}
+}
+
+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/excel.go

+package utils
+
+import (
+	"io"
+	"reflect"
+
+	"github.com/tealeg/xlsx"
+)
+
+// TinyXLSXEngine 简版 xlsx 处理器
+type TinyXLSXEngine struct {
+	xlsxFile *xlsx.File
+	toSlice  func(interface{}) []interface{}
+}
+
+// NewTinyXLSXEngine init
+func NewTinyXLSXEngine() *TinyXLSXEngine {
+	return &TinyXLSXEngine{}
+}
+
+// SetTransFunc 设置转换函数
+func (t *TinyXLSXEngine) SetTransFunc(f func(interface{}) []interface{}) *TinyXLSXEngine {
+	t.toSlice = f
+	return t
+}
+
+// SetData 设置数据
+func (t *TinyXLSXEngine) SetData(data interface{}) *TinyXLSXEngine {
+	file := xlsx.NewFile()
+	t.xlsxFile = file
+
+	sheet, err := file.AddSheet("sheet1")
+	if err != nil {
+		LogError("创建 xlsx sheet 失败: " + err.Error())
+		return t
+	}
+
+	if t.toSlice == nil {
+		t.toSlice = func(dt interface{}) []interface{} {
+			return nil
+		}
+	}
+
+	v := reflect.ValueOf(data)
+	if v.Kind() == reflect.Ptr {
+		v.Elem()
+	}
+
+	if v.Kind() == reflect.Slice && v.IsValid() {
+		l := v.Len()
+		for i := 0; i < l; i++ {
+			rowData := v.Index(i).Interface()
+			cols := t.toSlice(rowData)
+
+			row := sheet.AddRow()
+			for _, col := range cols {
+				row.AddCell().SetValue(col)
+			}
+		}
+	}
+
+	return t
+}
+
+// Write 写数据
+func (t *TinyXLSXEngine) Write(w io.Writer) error {
+	return t.xlsxFile.Write(w)
+}

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.Format("2006-01-02 15:04:05"),
+	}
+}
+
+// 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 {
+		exp, _ := time.Parse("2006-01-02 15:04:05", data["exp"].(string))
+		token.Expire = exp
+	}
+
+	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
+}