commit

.gitignore

@@ -0,0 +1,5 @@
+*.exe
+*.exe~
+*.test
+*.log
+log

bootstrap/bootstrap.go

@@ -0,0 +1,22 @@
+package bootstrap
+
+import (
+	"wechat-conf/models"
+	"wechat-conf/routers"
+	"wechat-conf/utils"
+)
+
+// SystemInit 系统初始化
+func SystemInit() {
+	// 数据库连接
+	models.InitDB()
+
+	// 系统日志
+	utils.LogInit()
+
+	// 微信系统
+	utils.WechatInit()
+
+	// 路由系统
+	routers.RouteInit()
+}

conf/aliyun.conf

@@ -0,0 +1,5 @@
+[oss]
+Endpoint=oss-cn-shanghai.aliyuncs.com
+AccessKeyId=LTAIkc75dpkJw8Lb
+AccessKeySecret=v4bvXCaix6vSDTCFfwSAdqV53iFEQw
+Bucket=jingcheng-h5temp

conf/app.conf

@@ -0,0 +1,17 @@
+appname = wechat-conf
+httpport = 8080
+runmode = prod
+autorender = false
+copyrequestbody = true
+EnableDocs = true
+excelpath = ./
+
+[cros]
+allowMode = dev
+allowCredentials = true
+allowOrigin = http://localhost:9528
+
+# GET, POST etc
+allowMethods = *
+
+

conf/db.conf

@@ -0,0 +1,33 @@
+; 数据库类型，目前只支持mysql
+db_type      = mysql
+
+; 连接协议
+con_protocol = tcp
+
+; 数据库地址，可以使用IP
+db_addr      = 47.101.36.130
+# db_addr        = 192.168.0.122
+; db_addr = localhost
+# db_addr      = rm-uf6z3z6jq11x653d77o.mysql.rds.aliyuncs.com
+
+; 端口
+db_port      = 3306
+
+; 用户名
+username     = spaceofcheng
+
+; 密码
+password     = spaceofcheng
+# password     = c;a|vK)Xv/=L@c[6Fx,v[ITD5;WpR}+Y
+
+; 数据库名或者schema
+database     = spaceofcheng
+
+; 前缀，目前尚未使用
+dbprefix     = 
+
+; 模式，目前尚未使用
+db_debug     = false
+
+; 字符集
+char_set     = utf8mb4

conf/log.conf

@@ -0,0 +1,4 @@
+[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

@@ -0,0 +1,54 @@
+package controllers
+
+// Authenticate 权限验证
+// 其中 token 的处理方式是
+// 1、获取 request 中 token
+// 2、放入 Context 中
+// 3、校验 token
+// 4、结束后，设置过期并从 Context 中删除
+// 5、生成新的 token， 并放入 Context 中
+// func (c *BaseController) authenticate() {
+// 	c.serv = service.NewSysServ(c.Context)
+
+// 	// 鉴权 - 并初始化上下文
+// 	res := c.serv.AuthAndInitCtx(c.Ctx)
+
+// 	if res != nil {
+// 		code := http.StatusOK
+// 		if res["code"] != nil {
+// 			code = res["code"].(int)
+// 		}
+
+// 		if code != http.StatusOK {
+// 			err := res["error"].(error)
+// 			data := map[string]interface{}{}
+
+// 			if res["message"] != nil {
+// 				data = res["message"].(map[string]interface{})
+// 			}
+
+// 			c.ResponseData(data, err, code)
+// 		}
+// 	}
+// }
+
+// // SetTokenExipre 设置 token 过期
+// func (c *BaseController) SetTokenExipre(uid string) {
+// 	token := c.Context.Get("token")
+// 	if token != nil {
+// 		c.serv.UpdateTokenExpire(token.(string), uid)
+// 	}
+
+// 	c.Context.Set("token", "")
+// }
+
+// // CreateNewToken 新 token
+// func (c *BaseController) CreateNewToken() {
+
+// 	batchNo := ""
+// 	if c.Context.Get("token-batch") != nil {
+// 		batchNo = c.Context.Get("token-batch").(string)
+// 	}
+
+// 	c.Context.Set("token", c.serv.NewToken(batchNo))
+// }

controllers/base.go

@@ -0,0 +1,120 @@
+package controllers
+
+import (
+	"encoding/json"
+	"net/http"
+	"wechat-conf/service"
+	"wechat-conf/utils"
+
+	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/config"
+)
+
+//BaseController 基础controller
+type BaseController struct {
+	beego.Controller
+	Context  *utils.Context
+	Configer map[string]config.Configer
+	RunMode  string
+	serv     *service.SysServ
+}
+
+//Prepare 继承beego的
+func (c *BaseController) Prepare() {
+	// 读取配置文件
+	c.initConfig()
+
+	// 初始化上下文
+	c.initContext()
+
+	// 鉴权
+	// c.authenticate()
+
+	// 路由对应的实际 Controller 初始化
+	c.initController()
+}
+
+// ResponseJSON 返回JSON数据
+func (c *BaseController) ResponseJSON(data interface{}) {
+	c.ResponseData(data, "", http.StatusOK)
+}
+
+// ResponseError 返回错误
+func (c *BaseController) ResponseError(err error, code ...int) {
+	if len(code) > 0 {
+		c.ResponseData(nil, err, code[0])
+	}
+
+	c.ResponseData(nil, err, http.StatusBadRequest)
+}
+
+// ResponseRaw 返回
+func (c *BaseController) ResponseRaw(msg []byte, stop ...bool) {
+	c.Ctx.ResponseWriter.Write(msg)
+
+	if stop != nil && len(stop) > 0 {
+		if !stop[0] {
+			return
+		}
+	}
+
+	c.destroyContext(true)
+	c.StopRun()
+}
+
+// ResponseData 自定义的JSON返回
+func (c *BaseController) ResponseData(data interface{}, msg interface{}, code int) {
+	status := code
+
+	sendMessage := ""
+	switch msgVal := msg.(type) {
+	case error:
+		sendMessage = msgVal.Error()
+	case string:
+		sendMessage = msgVal
+	default:
+		sendMessage = ""
+	}
+
+	c.Data["json"] = JSONMessage{status, sendMessage, data}
+	c.Ctx.Output.Header("Access-Control-Expose-Headers", utils.TokenHeader)
+
+	if status == http.StatusOK {
+		// 设置旧 token 过期
+		// c.SetTokenExipre()
+
+		// 生成新 token
+		// c.CreateNewToken()
+
+		token := c.Context.Get("token").(string)
+		c.Ctx.Output.Header(utils.TokenHeader, utils.TokenSchema+" "+token)
+	}
+
+	c.destroyContext(status < http.StatusMultipleChoices)
+	c.crosPolicy()
+	c.ServeJSON()
+	c.StopRun()
+}
+
+// initAppController 执行当前路由请求对应的 Controller 初始化
+func (c *BaseController) initController() {
+	if ctrl, ok := c.AppController.(ControllerInterface); ok {
+		ctrl.Constructor()
+	}
+}
+
+func (c *BaseController) GetBodyData() (map[string]interface{}, error) {
+	var data map[string]interface{}
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &data)
+	return data, err
+}
+
+func (c *BaseController) ResponseOtherEndPoint(msg map[string]interface{}) {
+	c.destroyContext(true)
+	c.Context.Destroy()
+
+	c.Data["json"] = msg
+
+	c.ServeJSON()
+	c.StopRun()
+}

controllers/config.go

@@ -0,0 +1,43 @@
+package controllers
+
+import (
+	"wechat-conf/utils"
+
+	"github.com/astaxie/beego/config"
+)
+
+// 配置文件列表
+const (
+	AppConf    = "app"
+	AliYunConf = "aliyun"
+	WeChatConf = "wechat"
+	SMSConf    = "sms"
+)
+
+func (c *BaseController) initConfig() {
+	// c.RunMode = beego.AppConfig.String("runmode")
+
+	if c.Configer == nil {
+		c.Configer = make(map[string]config.Configer)
+	}
+
+	// 系统
+	appConf, _ := utils.GetConfiger("conf/app.conf")
+	if appConf != nil {
+		c.Configer[AppConf] = appConf
+	}
+
+	c.RunMode = appConf.String("runmode")
+
+	// 阿里云
+	aliConf, _ := utils.GetConfiger("conf/aliyun.conf")
+	if aliConf != nil {
+		c.Configer[AliYunConf] = aliConf
+	}
+
+	// 微信
+	wechatConf, _ := utils.GetConfiger("conf/wechat.conf")
+	if wechatConf != nil {
+		c.Configer[WeChatConf] = wechatConf
+	}
+}

controllers/context.go

@@ -0,0 +1,39 @@
+package controllers
+
+import (
+	"wechat-conf/models"
+	"wechat-conf/utils"
+)
+
+/**
+* Context 说明
+* - 所有 stuct 类型均不是指针
+* - 包含内容如下
+* user					SysUser 									用户基本信息
+* customer			TaCustomer 								会员基本信息
+* userMap				TaUserMapping 						用户/会员 映射第三方账户
+* cases					[]SysUserCase 						用户所有案场信息
+* currentCase		SysUserCase 							当前案场
+* org						SysOrg 										用户当前组织
+**/
+
+// initContext 初始化 Context
+func (c *BaseController) initContext() {
+	c.Context = utils.NewContext(models.DBEngine, nil)
+	c.Context.Ready()
+}
+
+// initContext 销毁 Context
+func (c *BaseController) destroyContext(ok ...bool) {
+	if len(ok) == 0 || ok[0] {
+		c.Context.DB.Commit()
+	} else {
+		c.Context.DB.Rollback()
+	}
+
+	c.Context.Destroy()
+}
+
+func (c *BaseController) DestroyContext() {
+	c.destroyContext()
+}

controllers/cros.go

@@ -0,0 +1,25 @@
+package controllers
+
+// Options 解决跨域先发送 options
+func (c *BaseController) Options() {
+	c.ResponseJSON("")
+}
+
+// crosPolicy 跨域策略
+func (c *BaseController) crosPolicy() {
+	appConf, ok := c.Configer[AppConf]
+	if ok {
+		runMode := appConf.String("runmode")
+		allowMode := appConf.String("cros::allowMode")
+		allowMethods := appConf.String("cros::allowMethods")
+		allowOrigin := appConf.String("cros::allowOrigin")
+		allowCredentials := appConf.String("cros::allowCredentials")
+
+		if runMode == allowMode {
+			c.Ctx.Output.Header("Access-Control-Allow-Origin", allowOrigin)
+			c.Ctx.Output.Header("Access-Control-Allow-Methods", allowMethods)
+			c.Ctx.Output.Header("Access-Control-Allow-Credentials", allowCredentials)
+			c.Ctx.Output.Header("Access-Control-Allow-Headers", "X-Token,Authorization")
+		}
+	}
+}

controllers/file.go

@@ -0,0 +1,98 @@
+package controllers
+
+import (
+	"errors"
+	"strconv"
+	"time"
+	"wechat-conf/utils"
+
+	"net/http"
+	"net/url"
+)
+
+// FileUpload 文件上传
+func (c *BaseController) FileUpload() {
+	file, err := c.uploadFileToOSS("file")
+	if err != nil {
+		c.ResponseError(err, http.StatusInternalServerError)
+	}
+
+	c.ResponseJSON(map[string]interface{}{
+		"url": file,
+	})
+}
+
+func (c *BaseController) uploadFileToOSS(field string) (string, error) {
+	aliConf, ok := c.Configer[AliYunConf]
+	if !ok {
+		return "", errors.New("没有找到阿里云相关配置")
+	}
+
+	endpoint := aliConf.String("oss::Endpoint")
+	accessKeyID := aliConf.String("oss::AccessKeyId")
+	accessKeySecret := aliConf.String("oss::AccessKeySecret")
+	bucket := aliConf.String("oss::Bucket")
+
+	aliCli, err := utils.GetOssClient(endpoint, accessKeyID, accessKeySecret)
+	if err != nil {
+		return "", err
+	}
+
+	fNameExtra := strconv.FormatInt(time.Now().Unix(), 10)
+
+	fileURL, err := utils.UploadFileToBucket(aliCli, c.Ctx.Request, bucket, field, fNameExtra)
+	if err != nil {
+		return "", err
+	}
+
+	return fileURL, nil
+}
+
+// UploadBase64Image Upload base64-image to ali-oss
+// @Title Upload image to ali-oss
+// @Description 上传base64图片到阿里云
+// @Param   UpImgStr     form    string  true        "图片控件name"
+// @Success 200 { Url } 图片URL
+// @Failure >300 error message
+func (c *BaseController) UploadBase64Image() {
+	base64Str, err := url.QueryUnescape(c.GetString("base64str"))
+	if err != nil {
+		c.ResponseError(utils.LogError("上传 Base64 图片失败", err))
+	}
+
+	imgURL, err := c.uploadStringToAliOSS(base64Str)
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	resp := map[string]interface{}{
+		"url": imgURL,
+	}
+
+	c.ResponseJSON(resp)
+}
+
+// uploadStringToAliOSS 上传文件到阿里云
+func (c *BaseController) uploadStringToAliOSS(fStr string) (string, error) {
+	aliConf, ok := c.Configer[AliYunConf]
+	if !ok {
+		return "", errors.New("没有找到阿里云相关配置")
+	}
+
+	endpoint := aliConf.String("oss::Endpoint")
+	accessKeyID := aliConf.String("oss::AccessKeyId")
+	accessKeySecret := aliConf.String("oss::AccessKeySecret")
+	bucket := aliConf.String("oss::Bucket")
+
+	aliCli, err := utils.GetOssClient(endpoint, accessKeyID, accessKeySecret)
+	if err != nil {
+		return "", utils.LogError("配置阿里云客户端失败", err)
+	}
+
+	fileURL, err := utils.UploadStringToBucket(aliCli, bucket, fStr)
+	if err != nil {
+		return "", utils.LogError("上传文件到阿里云失败", err)
+	}
+
+	return fileURL, nil
+}

controllers/types.go

@@ -0,0 +1,13 @@
+package controllers
+
+// JSONMessage 主要用于 Response 返回
+type JSONMessage struct {
+	Code    int         `json:"code"`
+	Message string      `json:"message"`
+	Result  interface{} `json:"result"`
+}
+
+// ControllerInterface 项目约定的 Controller 须满足的接口
+type ControllerInterface interface {
+	Constructor()
+}

main.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"wechat-conf/bootstrap"
+
+	"github.com/astaxie/beego"
+)
+
+func main() {
+	if beego.BConfig.RunMode == "dev" {
+		beego.BConfig.WebConfig.DirectoryIndex = true
+		beego.BConfig.WebConfig.StaticDir["/swagger"] = "swagger"
+	}
+
+	bootstrap.SystemInit()
+
+	beego.Run()
+}

models/constant.go

@@ -0,0 +1,16 @@
+package models
+
+// 状态列表
+const (
+	// 删除
+	STATUS_DEL = iota - 1
+
+	// 新录入
+	STATUS_READY
+
+	// 正常
+	STATUS_NORMAL
+
+	// 已使用
+	STATUS_USED
+)

models/models.go

@@ -0,0 +1,55 @@
+package models
+
+import (
+	"wechat-conf/utils"
+
+	"github.com/astaxie/beego/config"
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/go-xorm/xorm"
+)
+
+var (
+	DBEngine *xorm.Engine
+)
+
+func InitDB() {
+	DBEngine = NewDBEngine()
+}
+
+// NewDBEngine 初始化数据库连接
+func NewDBEngine() *xorm.Engine {
+	dbType := "mysql"
+	dns := getMySQLDNS()
+
+	engine, err := xorm.NewEngine(dbType, dns)
+	// engine.ShowSQL()
+
+	if err != nil {
+		panic(err)
+	}
+
+	return engine
+}
+
+func getMySQLDNS() (dns string) {
+	appRoot := utils.GetAppRoot()
+	dbconf, _ := config.NewConfig("ini", appRoot+"/conf/db.conf")
+
+	conProt := dbconf.DefaultString("con_protocol", "tcp")
+	dbAddr := dbconf.DefaultString("db_addr", "localhost")
+	dbPort := dbconf.DefaultString("db_port", "3306")
+	userName := dbconf.DefaultString("username", "root")
+	password := dbconf.String("password")
+	database := dbconf.String("database")
+	charSet := dbconf.DefaultString("char_set", "utf8")
+
+	dns = userName
+
+	if len(password) > 0 {
+		dns += ":" + password
+	}
+
+	dns += "@" + conProt + "(" + dbAddr + ":" + dbPort + ")" + "/" + database + "?charset=" + charSet
+
+	return
+}

routers/router.go

@@ -0,0 +1,24 @@
+// @APIVersion 1.0.0
+// @Title beego Test API
+// @Description beego has a very cool tools to autogenerate documents for your API
+// @Contact astaxie@gmail.com
+// @TermsOfServiceUrl http://beego.me/
+// @License Apache 2.0
+// @LicenseUrl http://www.apache.org/licenses/LICENSE-2.0.html
+package routers
+
+import (
+	"wechat-conf/controllers"
+
+	"github.com/astaxie/beego"
+)
+
+func RouteInit() {
+
+	ns := beego.NewNamespace("/api",
+		// 解决跨域时 先发送 options 问题
+		beego.NSRouter("*", &controllers.BaseController{}, "options:Options"),
+	)
+
+	beego.AddNamespace(ns)
+}

service/service.go

@@ -0,0 +1 @@
+package service

service/sys.go

@@ -0,0 +1,508 @@
+package service
+
+import (
+	"wechat-conf/utils"
+)
+
+const (
+	PAGENUM = 10
+)
+
+// SysServ 系统处理
+type SysServ struct {
+	ctx *utils.Context
+}
+
+// NewSysServ 初始化
+func NewSysServ(ctx *utils.Context) *SysServ {
+	return &SysServ{
+		ctx: ctx,
+	}
+}
+
+// // 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,
+// 		}
+// 	}
+
+// 	// 客户端类型
+// 	// 通过 UA 判断
+// 	clientType := utils.GetClientType(gctx.Request)
+
+// 	// pc 管理端
+// 	if clientType == utils.ClientAdmin {
+// 		return s.authPCAdmin(gctx)
+// 	}
+
+// 	// 小程序 端
+// 	if strings.Index(gctx.Input.URI(), "/wechat/mini") > -1 {
+// 		return s.authMini(gctx)
+// 	}
+
+// 	// wechat 端
+// 	if clientType == utils.ClientWechat {
+// 		return s.authWechat(gctx)
+// 	}
+
+// 	// if clientType == utils.ClientMini {
+// 	// 	return s.authMini(gctx)
+// 	// }
+
+// 	return map[string]interface{}{
+// 		"code":  http.StatusBadRequest,
+// 		"error": errors.New("暂无该客户端的 API"),
+// 	}
+// }
+
+// // NewToken 设置 TOKEN
+// // 15 分钟后过期
+// func (s *SysServ) NewToken(batch string) 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,
+// 			BatchNo: batch,
+// 		}
+// 	} else if s.ctx.Get("user") != nil {
+// 		user := s.ctx.Get("user").(model.SysUser)
+
+// 		token = &utils.JWTToken{
+// 			Guest:   false,
+// 			ID:      user.UserId,
+// 			Expire:  exp,
+// 			BatchNo: batch,
+// 		}
+// 	} 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 := models.InsertToken(tokenEncodeStr, token.ID, batch, exp); err != nil {
+// 			utils.LogError("入库 Token 失败: " + err.Error())
+// 			return tokenEncodeStr
+// 		}
+// 	}
+
+// 	return tokenEncodeStr
+// }
+
+// // authPCAdmin
+// // 管理端 API 校验
+// func (s *SysServ) authPCAdmin(gctx *context.Context) map[string]interface{} {
+// 	if !s.needAuth(gctx) {
+// 		return nil
+// 	}
+
+// 	// 获取 token
+// 	token, err := s.getToken(gctx)
+// 	if err != nil {
+// 		// token 报错一律视为需要重新登录
+// 		return map[string]interface{}{
+// 			"code":  http.StatusUnauthorized,
+// 			"error": err,
+// 		}
+// 	}
+
+// 	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{} {
+// 	var wxUser *utils.WechatUser
+// 	var openID string
+
+// 	if beego.BConfig.RunMode == "dev" {
+// 		openID = "OPENID"
+// 	} else {
+// 		// 初始化微信配置
+// 		if err := s.initWechatClient(s.org.OrgId); err != nil {
+// 			utils.LogError("初始化微信服务失败: " + err.Error())
+
+// 			return map[string]interface{}{
+// 				"code":  http.StatusInternalServerError,
+// 				"error": errors.New("初始化微信服务失败"),
+// 			}
+// 		}
+
+// 		// 微信 code
+// 		code := gctx.Input.Query("code")
+
+// 		// 获取 token
+// 		token, err := s.getToken(gctx)
+// 		if err != nil {
+// 			tokenStr := s.ctx.Get("token").(string)
+// 			if tokenStr != "" {
+// 				// token 报错一律视为需要重新登录
+// 				return map[string]interface{}{
+// 					"code":  http.StatusUnauthorized,
+// 					"error": err,
+// 					"message": map[string]interface{}{
+// 						"appid": utils.GetWxAppID(s.org.OrgId),
+// 					},
+// 				}
+// 			}
+// 		}
+
+// 		// 未登录 或 未验证
+// 		if token == nil || 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("请先关注公众号"),
+// 				}
+// 			}
+
+// 			utils.LogError("获取到微信人员: ", wxUser)
+
+// 			openID = wxUser.OpenID
+// 		} else {
+// 			openID = token.ID
+// 		}
+// 	}
+
+// 	// 查询数据库是否存在已有映射
+// 	userMapList, err := models.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.OpenID == "" {
+// 			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),
+// 		}
+// 	}
+
+// 	// 防止JSON解析失败
+// 	if userMapping.AccountInfo == "" {
+// 		userMapping.AccountInfo = "{}"
+// 	}
+
+// 	// 更新映射信息, 没有的话则插入
+// 	err = models.EditUserMapping(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 = models.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
+// }
+
+// // 小程序端暂时无人员或者其他业务要求
+// 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) {
+// 	// 获取 微信信息
+// 	// 可能出现的情况是 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) {
+// 	tokenEnStr := gctx.Input.Query("token")
+// 	if tokenEnStr == "" {
+// 		tokenRaw := gctx.Input.Header(utils.TokenHeader)
+// 		if tokenRaw == "" {
+// 			return new(utils.JWTToken), nil
+// 		}
+
+// 		tokenEnStr = strings.Trim(strings.TrimLeft(tokenRaw, utils.TokenSchema), " ")
+// 	} else {
+// 		tokenEnStr = strings.Trim(strings.TrimLeft(tokenEnStr, 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 := models.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 已过期")
+// 	}
+
+// 	s.ctx.Set("token-batch", tk.BatchNo)
+// 	return utils.MapToJWTToken(token), nil
+// }
+
+// // UpdateTokenExpire 更新 token 为过期
+// // 如果发生错误, 此处选择忽略
+// func (s *SysServ) UpdateTokenExpire(token, uid string) {
+// 	if err := models.UpdateTokenExpire(token, uid); 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 := models.GetPureUserInfo(id)
+// 	if err != nil {
+// 		return utils.LogError("获取用户基本信息失败: " + err.Error())
+// 	}
+// 	s.ctx.Set("user", *user)
+
+// 	cases, err := models.GetUserCase(id)
+// 	if err != nil {
+// 		return utils.LogError("获取用户案场信息失败: " + err.Error())
+// 	}
+// 	s.ctx.Set("cases", cases)
+
+// 	found := false
+// 	for _, cs := range cases {
+// 		if cs.IsBelong == models.BOOL_TRUE {
+// 			found = true
+// 			s.ctx.Set("currentCase", cs)
+// 		}
+// 	}
+
+// 	if !found {
+// 		utils.LogError("用户没有设置默认案场")
+// 	}
+
+// 	return nil
+// }
+
+// // saveNewCustomer 新增用户
+// func (s *SysServ) saveNewCustomer(wxUser *utils.WechatUser, userMap *model.TaUserMapping) (*model.TaCustomer, error) {
+// 	cust := model.TaCustomer{
+// 		CustomerName: wxUser.NickName,
+// 		Name:         wxUser.NickName,
+// 		Sex:          int(wxUser.Sex),
+// 		Headimgurl:   wxUser.HeadImgURL,
+// 		OrgId:        s.org.OrgId,
+// 	}
+
+// 	if err := models.SaveCustomer(&cust); err != nil {
+// 		utils.LogError("更新客户信息失败: " + err.Error())
+// 		return nil, errors.New("更新客户信息失败")
+// 	}
+
+// 	account := new(model.TaCustomerAccount)
+// 	account.CustomerId = cust.CustomerId
+// 	account.CustomerName = cust.CustomerName
+// 	account.OrgId = cust.OrgId
+// 	account.Amount = "0"
+// 	account.Points = "0"
+// 	account.PayedAmount = "0"
+// 	account.PayedPoints = "0"
+
+// 	if err := models.SaveAccount(account); err != nil {
+// 		utils.LogError("插入账户信息失败: " + err.Error())
+// 		return nil, errors.New("更新客户信息失败")
+// 	}
+
+// 	// 更新映射表信息
+// 	userMap.UserId = cust.CustomerId
+// 	if err := models.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
+// 		utils.LogError("更新用户映射信息失败:" + err.Error())
+// 		return nil, errors.New("映射用户信息失败")
+// 	}
+
+// 	return &cust, nil
+// }
+
+// // initWechatClient 初始化微信客户端
+// func (s *SysServ) initWechatClient(orgID string) error {
+// 	cert, err := models.GetWeChatConfig(orgID, models.WECHAT_WX)
+// 	if err != nil {
+// 		utils.LogError("获取微信配置失败: " + err.Error())
+// 		return errors.New("获取微信配置失败")
+// 	}
+
+// 	if cert == nil {
+// 		return errors.New("未找到微信配置")
+// 	}
+
+// 	utils.WxClientSingleton(orgID, cert)
+// 	return nil
+// }
+
+// func (s *SysServ) initMiniClient(orgID string) error {
+// 	cert, err := models.GetWeChatConfig(orgID, models.WECHAT_MINI)
+// 	if err != nil {
+// 		utils.LogError("获取小程序配置失败: " + err.Error())
+// 		return errors.New("获取小程序配置失败")
+// 	}
+
+// 	if cert == nil {
+// 		return errors.New("未找到小程序配置")
+// 	}
+
+// 	utils.MiniClientSingleton(orgID, cert)
+// 	return nil
+// }

test.http

@@ -0,0 +1,19 @@
+@domain = localhost:8080
+@guestAPI = api/guest
+@phone = 17714208769
+
+@contentForm = application/x-www-form-urlencoded
+@contentJSON = application/json
+# 验证码
+
+GET http://{{domain}}/{{guestAPI}}/captcha?phone={{phone}}
+
+
+###
+POST http://dev.ycjcjy.com/api-v2/api/guest/wxsignup
+content-type: {{contentForm}}
+
+phone={{phone}}
+&captcha=648633
+&case=1
+&sales=0

tests/cases_test.go

@@ -0,0 +1,46 @@
+package tests
+
+import (
+	"net/http"
+	"net/url"
+	"wechat-conf/controllers"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestGetCmsCaseList(t *testing.T) {
+
+	Convey("获取案场列表", t, func() {
+		Convey("正常业务", func() {
+			params := url.Values{}
+			params.Add("orgid", "1")
+
+			result := &controllers.JSONMessage{}
+
+			code, _, err := NewRequestMock().Request(http.MethodGet, "/api/guest/MQ/cms/case", params, result)
+
+			// http 常规判断, 可以省略
+			So(code, ShouldEqual, http.StatusOK)
+			So(err, ShouldBeNil)
+
+			// 业务返回判断
+			So(result.Code, ShouldEqual, http.StatusOK)
+			So(result.Result, ShouldNotBeEmpty)
+		})
+
+		Convey("机构不传报错", func() {
+			result := &controllers.JSONMessage{}
+
+			code, _, err := NewRequestMock().Request(http.MethodGet, "/api/guest/MQ/cms/case", nil, result)
+
+			// http 常规判断, 可以省略
+			So(code, ShouldEqual, http.StatusOK)
+			So(err, ShouldBeNil)
+
+			// 业务返回判断
+			So(result.Code, ShouldNotEqual, http.StatusOK)
+		})
+
+	})
+}

tests/courseorder_test.go

@@ -0,0 +1,74 @@
+package tests
+
+import (
+	"net/http"
+	"net/url"
+	"wechat-conf/controllers"
+	"wechat-conf/utils"
+	"testing"
+	"time"
+
+	"github.com/astaxie/beego"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestPreCourseOrder(t *testing.T) {
+	Convey("课程下单", t, func() {
+
+		Convey("正常下单", func() {
+			params := url.Values{}
+			params.Add("info", `{"CourseId":"ecc55f91-52b4-4e9b-89a8-b9b3362730f9","CaseId":"10","Price":"2.00"}`)
+			result := &controllers.JSONMessage{}
+			api := "/api/wechat/MQ/order/course"
+
+			token := &utils.JWTToken{
+				Guest:   false,
+				ID:      "oMOpz0kgTrasoAA3G70R7phomn1g", // openid
+				Expire:  time.Now().Local().Add(24 * 30 * time.Hour),
+				BatchNo: "",
+			}
+
+			code, _, err := NewRequestMock().
+				AddToken(token.ToMap()).
+				AddWechatUA().
+				Request(http.MethodPost, api, params, result)
+
+			beego.Trace(result)
+
+			So(code, ShouldEqual, http.StatusOK)
+			So(err, ShouldBeNil)
+
+			// 业务返回判断
+			So(result.Code, ShouldEqual, http.StatusOK)
+			So(result.Result, ShouldNotBeEmpty)
+
+			orderID := result.Result.(map[string]interface{})["OrdersId"].(string)
+
+			Convey("下单确认", func() {
+				result := &controllers.JSONMessage{}
+				api := "/api/wechat/MQ/order/course/" + orderID
+
+				token := &utils.JWTToken{
+					Guest:   false,
+					ID:      "oMOpz0kgTrasoAA3G70R7phomn1g", // openid
+					Expire:  time.Now().Local().Add(24 * 30 * time.Hour),
+					BatchNo: "",
+				}
+
+				code, _, err := NewRequestMock().
+					AddToken(token.ToMap()).
+					AddWechatUA().
+					Request(http.MethodPut, api, nil, result)
+
+				beego.Trace(result)
+
+				So(code, ShouldEqual, http.StatusOK)
+				So(err, ShouldBeNil)
+
+				// 业务返回判断
+				So(result.Code, ShouldEqual, http.StatusOK)
+			})
+		})
+	})
+}

tests/goodsorder_test.go

@@ -0,0 +1,70 @@
+package tests
+
+import (
+	"net/http"
+	"net/url"
+	"wechat-conf/controllers"
+	"wechat-conf/utils"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestPreGoodsOrder(t *testing.T) {
+	Convey("商品下单", t, func() {
+
+		Convey("正常下单", func() {
+			params := url.Values{}
+			params.Add("info", `{"CaseId":"1","AreaId":"12","AreaName":"吧台","TableId":"28","TableNo":"城咖啡水吧台","Amount":"23","OrdersNum":1,"Remark":"","OrgId":"1","UserName":"奥利奥","PayType":"coupon"}`)
+			params.Add("detail", `[{"GoodsId":"61","GoodsName":"美式","SpecId":"40","SpecName":"去冰","Number":1,"Price":"23"}]`)
+
+			result := &controllers.JSONMessage{}
+			api := "/api/wechat/MQ/order/goods"
+
+			token := &utils.JWTToken{
+				Guest:   false,
+				ID:      "oMOpz0kgTrasoAA3G70R7phomn1g", // openid
+				Expire:  time.Now().Local().Add(24 * 30 * time.Hour),
+				BatchNo: "",
+			}
+
+			code, _, err := NewRequestMock().
+				AddToken(token.ToMap()).
+				AddWechatUA().
+				Request(http.MethodPost, api, params, result)
+
+			So(code, ShouldEqual, http.StatusOK)
+			So(err, ShouldBeNil)
+
+			// 业务返回判断
+			So(result.Code, ShouldEqual, http.StatusOK)
+			So(result.Result, ShouldNotBeEmpty)
+
+			orderID := result.Result.(map[string]interface{})["OrdersId"].(string)
+
+			Convey("下单确认", func() {
+				result := &controllers.JSONMessage{}
+				api := "/api/wechat/MQ/order/goods/" + orderID
+
+				token := &utils.JWTToken{
+					Guest:   false,
+					ID:      "oMOpz0kgTrasoAA3G70R7phomn1g", // openid
+					Expire:  time.Now().Local().Add(24 * 30 * time.Hour),
+					BatchNo: "",
+				}
+
+				code, _, err := NewRequestMock().
+					AddToken(token.ToMap()).
+					AddWechatUA().
+					Request(http.MethodPut, api, nil, result)
+
+				So(code, ShouldEqual, http.StatusOK)
+				So(err, ShouldBeNil)
+
+				// 业务返回判断
+				So(result.Code, ShouldEqual, http.StatusOK)
+			})
+		})
+	})
+}

tests/tests.go

@@ -0,0 +1,27 @@
+package tests
+
+/**
+*
+* 使用的测试框架为  http://labix.org/gocheck
+*
+**/
+
+import (
+	"wechat-conf/bootstrap"
+	"wechat-conf/utils"
+	"testing"
+
+	"github.com/astaxie/beego"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestHelloWorld(t *testing.T) {
+	Convey("Hello go tester !", t, func() {
+		So(2, ShouldEqual, 2)
+	})
+}
+
+func init() {
+	bootstrap.SystemInit()
+	beego.TestBeegoInit(utils.GetAppRoot())
+}

tests/utils.go

@@ -0,0 +1,231 @@
+package tests
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"wechat-conf/utils"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/astaxie/beego"
+)
+
+// RequestMock 模拟请求
+type RequestMock struct {
+	Headers map[string]string
+	Host    string
+}
+
+// NewRequestMock new inst
+func NewRequestMock() *RequestMock {
+	return &RequestMock{
+		Headers: make(map[string]string),
+	}
+}
+
+// SetHeaders 设置自定义请求头
+func (t *RequestMock) SetHeaders(headers map[string]string) *RequestMock {
+	if headers != nil {
+		for k, v := range headers {
+			t.Headers[k] = v
+		}
+	}
+
+	return t
+}
+
+// AddWechatUA 添加微信UA
+func (t *RequestMock) AddWechatUA() *RequestMock {
+	t.Headers["User-Agent"] = "Mozilla/5.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Mobile/12A365 MicroMessenger/5.4.1 NetType/WIFI"
+	return t
+}
+
+// AddToken 添加Token
+func (t *RequestMock) AddToken(dt map[string]interface{}) *RequestMock {
+	token, _ := utils.CreateToken(dt)
+	t.Headers[utils.TokenHeader] = utils.TokenSchema + " " + token
+	return t
+}
+
+// SetHost 设置 host 包含 port
+func (t *RequestMock) SetHost(host string) *RequestMock {
+	t.Host = host
+	return t
+}
+
+// Request 请求
+// 暂时只支持 params 是 url.Values 及 map[string]interface{} 两种类型
+// url.Values 将被理解为 content-type="application/x-www-form-urlencoded"
+// map[string]interface{} 将被理解为 content-type="multipart/form-data"
+func (t *RequestMock) Request(meth, addr string, params interface{}, result interface{}) (code int, body []byte, err error) {
+	var r *http.Request
+	defer t.SetHeaders(nil)
+
+	code = 0
+	body = nil
+	err = nil
+
+	if t.Host != "" {
+		addr = t.Host + addr
+	} else {
+		addr = "http://127.0.0.1:8080" + addr
+	}
+
+	switch meth {
+
+	// get 请求, 只支持 params 为 url.Values 的参数
+	case http.MethodGet:
+		if params != nil {
+			if dt, ok := params.(url.Values); ok {
+				searchStr := dt.Encode()
+				if strings.Index(addr, "?") > -1 {
+					searchStr = "&" + searchStr
+				} else {
+					searchStr = "?" + searchStr
+				}
+				r, _ = http.NewRequest(meth, addr+searchStr, nil)
+			}
+		} else {
+			r, _ = http.NewRequest(meth, addr, nil)
+		}
+
+	// post, put, delete
+	case http.MethodPost, http.MethodPut, http.MethodDelete:
+		rb, ct, e := GetBody(params)
+		if e != nil {
+			err = e
+			return
+		}
+
+		r, _ = http.NewRequest(meth, addr, rb)
+		if ct != "" {
+			r.Header.Set("Content-Type", ct)
+		}
+
+	// 其他的本系统没有使用
+	default:
+		err = errors.New("不支持的请求类型")
+		return
+	}
+
+	// 自定义的 header 头
+	if t.Headers != nil {
+		for k, v := range t.Headers {
+			r.Header.Set(k, v)
+		}
+	}
+
+	w := httptest.NewRecorder()
+	beego.BeeApp.Handlers.ServeHTTP(w, r)
+
+	code = w.Code
+	body, _ = ioutil.ReadAll(w.Result().Body)
+
+	beego.Trace("testing", meth+" - "+addr)
+
+	if result != nil {
+		err = json.Unmarshal(body, result)
+		return
+	}
+
+	return
+}
+
+func GetBody(params interface{}) (body io.Reader, contentType string, err error) {
+	body = nil
+	contentType = ""
+	err = nil
+
+	if params == nil {
+		return
+	}
+
+	t := fmt.Sprintf("%T", params)
+	switch t {
+
+	// 被会解析为 application/x-www-form-urlencoded
+	case "url.Values":
+		data, _ := params.(url.Values)
+		body = strings.NewReader(data.Encode())
+		contentType = "application/x-www-form-urlencoded"
+		return
+
+	// 被会解析为 multipart/form-data
+	case "map[string]interface {}":
+		var b bytes.Buffer
+		var fw io.Writer
+
+		w := multipart.NewWriter(&b)
+		data, _ := params.(map[string]interface{})
+
+		// 遍历字段
+		for k, v := range data {
+			switch x := v.(type) {
+
+			// 文件
+			case *os.File:
+				if fw, err = w.CreateFormFile(k, x.Name()); err != nil {
+					return
+				}
+
+				if _, err = io.Copy(fw, x); err != nil {
+					return
+				}
+
+			// 字符串
+			case string:
+				err = w.WriteField(k, x)
+				if err != nil {
+					return
+				}
+
+			// 整数, 暂不支持 int 各种原始类型, 比如 int32, int64 等
+			case int:
+				dt := strconv.Itoa(x)
+				err = w.WriteField(k, dt)
+				if err != nil {
+					return
+				}
+
+			// 小数, 暂时不支持其他类型的浮点数
+			case float64:
+				dt := strconv.FormatFloat(x, 'f', -1, 64)
+				err = w.WriteField(k, dt)
+				if err != nil {
+					return
+				}
+
+			// 时间
+			case time.Time:
+				dt := x.Format("2006-01-02 15:04:05")
+				err = w.WriteField(k, dt)
+				if err != nil {
+					return
+				}
+
+			// 其他
+			default:
+				err = fmt.Errorf("暂时不支持 key "+k+" 对应的数据类型 %T", x)
+				return
+			}
+		}
+
+		body = bytes.NewReader(b.Bytes())
+		contentType = w.FormDataContentType()
+		return
+
+	default:
+		err = fmt.Errorf("暂时不支持的参数类型 " + t)
+		return
+	}
+}

utils/aliyun.go

@@ -0,0 +1,104 @@
+package utils
+
+import (
+	"bytes"
+	"encoding/base64"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/yl10/kit/guid"
+
+	"github.com/aliyun/aliyun-oss-go-sdk/oss"
+)
+
+// GetOssClient 获取 OSS 客户端
+func GetOssClient(endpoint, accessKeyID, accessKeySecret string) (*oss.Client, error) {
+	return oss.New(endpoint, accessKeyID, accessKeySecret)
+}
+
+// UploadFileToBucket 简单上传文件
+func UploadFileToBucket(cli *oss.Client, req *http.Request, bucket, fromFront string, nameSuffix ...string) (string, error) {
+	bkt, err := cli.Bucket(bucket)
+	if err != nil {
+		return "", err
+	}
+
+	file, fh, err := req.FormFile(fromFront)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	fname := fh.Filename
+	if len(nameSuffix) > 0 && nameSuffix[0] != "" {
+		fArr := strings.Split(fname, ".")
+		fArr[0] = fArr[0] + nameSuffix[0]
+		fname = strings.Join(fArr, ".")
+	}
+
+	err = bkt.PutObject(fname, file)
+	if err != nil {
+		return "", err
+	}
+
+	return strings.Join([]string{
+		"http://",
+		bucket + ".",
+		cli.Config.Endpoint + "/",
+		fname,
+	}, ""), nil
+}
+
+// UploadStringToBucket 上传base64图片
+func UploadStringToBucket(cli *oss.Client, bucket, fromStr string) (string, error) {
+	bkt, err := cli.Bucket(bucket)
+	if err != nil {
+		return "", err
+	}
+
+	imgName := guid.NewGUIDString() + "-" + time.Now().Local().Format("20060102150405")
+	imgExt := ".jpg"
+	switch getMIMEFromBase64(fromStr) {
+	case "image/gif":
+		imgExt = ".gif"
+	case "image/bmp":
+		imgExt = ".bmp"
+	case "image/png", "image/x-png":
+		imgExt = ".png"
+	case "image/pipeg":
+		imgExt = ".jfif"
+	case "image/webp":
+		imgExt = ".webp"
+	}
+
+	fName := imgName + imgExt
+
+	imgData, err := base64.StdEncoding.DecodeString(strings.Split(fromStr, "base64,")[1])
+	if err != nil {
+		return "", err
+	}
+
+	err = bkt.PutObject(fName, bytes.NewBuffer(imgData))
+	if err != nil {
+		return "", err
+	}
+
+	return strings.Join([]string{
+		"http://",
+		bucket + ".",
+		cli.Config.Endpoint + "/",
+		fName,
+	}, ""), nil
+}
+
+// utils
+// getMIMEFromBase64 获取 base64 字串中的 mime
+func getMIMEFromBase64(str string) string {
+	g := strings.Split(str, ";")
+	if len(g) < 2 {
+		return ""
+	}
+
+	return strings.ToLower(strings.TrimLeft(g[0], "data:"))
+}

utils/configer.go

@@ -0,0 +1,15 @@
+package utils
+
+import (
+	"github.com/astaxie/beego/config"
+)
+
+// GetConfiger 获取配置
+func GetConfiger(file string) (config.Configer, error) {
+	conf, err := config.NewConfig("ini", file)
+	if err != nil {
+		return nil, LogError("读取配置文件失败", err.Error())
+	}
+
+	return conf, nil
+}

utils/context.go

@@ -0,0 +1,59 @@
+package utils
+
+import (
+	"github.com/go-xorm/xorm"
+)
+
+// Context 上下文
+// 只限制在每次 Request 内
+type Context struct {
+	DB  *xorm.Session
+	box map[string]interface{}
+}
+
+// NewContext 初始化上下文
+func NewContext(engine *xorm.Engine, opt map[string]interface{}) *Context {
+	return &Context{
+		DB:  engine.NewSession(),
+		box: opt,
+	}
+}
+
+// Get 获取
+func (c *Context) Get(key string, def ...interface{}) interface{} {
+	if c.box != nil {
+		if opt, has := c.box[key]; has {
+			return opt
+		}
+	}
+
+	if len(def) > 0 {
+		return def[0]
+	}
+
+	return nil
+}
+
+// Set 设置
+func (c *Context) Set(key string, val interface{}) {
+	if c.box == nil {
+		c.box = make(map[string]interface{})
+	}
+
+	c.box[key] = val
+}
+
+// Ready Request 级别初始化
+func (c *Context) Ready() error {
+	// 开启事务
+	if err := c.DB.Begin(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Destroy 析构函数
+func (c *Context) Destroy() {
+	c.DB.Close()
+}

utils/guid.go

@@ -0,0 +1,10 @@
+package utils
+
+import (
+	"github.com/pborman/uuid"
+)
+
+// GetGUID 获取GUID
+func GetGUID() string {
+	return uuid.New()
+}

utils/jwt.go

@@ -0,0 +1,88 @@
+package utils
+
+import (
+	"errors"
+	"time"
+
+	jwt "github.com/dgrijalva/jwt-go"
+)
+
+const (
+	TokenHeader = "Authorization"
+	TokenSchema = "Bearer"
+)
+
+var tokenSignedKey = []byte(`Yansen is so handsome!`)
+
+// CreateToken 获取token
+func CreateToken(info map[string]interface{}) (string, error) {
+	claims := jwt.MapClaims(info)
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(tokenSignedKey)
+}
+
+// PareseToken 解析 token
+func PareseToken(token string) (map[string]interface{}, error) {
+	tk, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
+		return tokenSignedKey, nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if claims, ok := tk.Claims.(jwt.MapClaims); ok && tk.Valid {
+		info := map[string]interface{}(claims)
+		return info, nil
+	}
+
+	return nil, errors.New("Token 解析 未知错误")
+}
+
+// JWTToken token 内容
+type JWTToken struct {
+	Guest    bool
+	ID       string
+	Password string
+	BatchNo  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,
+		"batchno":  t.BatchNo,
+		"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["batchno"] != nil {
+		token.BatchNo = data["batchno"].(string)
+	}
+
+	if data["exp"] != nil {
+		exp, _ := time.Parse("2006-01-02 15:04:05", data["exp"].(string))
+		token.Expire = exp
+	}
+
+	return &token
+}

utils/log.go

@@ -0,0 +1,105 @@
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+
+	"github.com/astaxie/beego/config"
+	"github.com/astaxie/beego/logs"
+)
+
+var instances = make(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", GetAppRoot()+"/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 {
+	log := instances["common"]
+
+	preMsg := ""
+	_, file, line, ok := runtime.Caller(1)
+	if ok {
+		preMsg = fmt.Sprintf("file: %s    line=%d : ", file, line)
+	}
+
+	log.Error(preMsg, v...)
+
+	if len(v) > 0 {
+		firstV := v[0]
+
+		switch err := firstV.(type) {
+		case string:
+			return errors.New(err)
+		case error:
+			return err
+		default:
+			msg := "Unknown error type"
+			return errors.New(msg)
+		}
+	}
+
+	return nil
+}
+
+// LogInfo Info 日志
+func LogInfo(v ...interface{}) {
+	log := instances["common"]
+
+	preMsg := ""
+	_, file, line, ok := runtime.Caller(1)
+	if ok {
+		preMsg = fmt.Sprintf("file: %s    line=%d : ", file, line)
+	}
+
+	log.Error(preMsg, v...)
+}
+
+// GetDefaultLogger 获取默认 logger
+func GetDefaultLogger() *logs.BeeLogger {
+	log := instances["common"]
+	log.SetLogFuncCallDepth(4)
+	return log
+}
+
+func LogInit() {
+	NewLog()
+}

utils/pagenavi.go

@@ -0,0 +1,51 @@
+package utils
+
+import (
+	"strconv"
+)
+
+type PageNaviEngine struct {
+	ctx *Context
+}
+
+func NewPageNaviEngine(ctx *Context) *PageNaviEngine {
+	return &PageNaviEngine{ctx: ctx}
+}
+
+// GetPageList 获取列表
+func (t *PageNaviEngine) GetPageList(target interface{}, sql string, limit []int, sqlArgs ...interface{}) (int64, error) {
+	countSQL := "select count(*) as cnt from (" + sql + ") as virtualTable"
+	countSQLorArgs := []interface{}{countSQL}
+	for _, arg := range sqlArgs {
+		countSQLorArgs = append(countSQLorArgs, arg)
+	}
+
+	cntRes, err := t.ctx.DB.Query(countSQLorArgs...)
+	if err != nil {
+		return 0, err
+	}
+
+	cntStr := string(cntRes[0]["cnt"])
+	cnt, _ := strconv.ParseInt(cntStr, 10, 64)
+
+	newSQL := t.PackLimitToSQL(sql, limit)
+
+	err = t.ctx.DB.SQL(newSQL, sqlArgs...).Find(target)
+	if err != nil {
+		return 0, err
+	}
+
+	return cnt, nil
+}
+
+// PackLimitToSQL 添加 limit 语句到 sql 最后
+func (t *PageNaviEngine) PackLimitToSQL(sql string, limit []int) string {
+	switch len(limit) {
+	case 1:
+		return sql + " LIMIT " + strconv.Itoa(limit[0])
+	case 2:
+		return sql + " LIMIT " + strconv.Itoa(limit[0]) + " OFFSET " + strconv.Itoa(limit[1])
+	default:
+		return sql
+	}
+}

utils/utils.go

@@ -0,0 +1,194 @@
+package utils
+
+import (
+	"encoding/base64"
+	"math/rand"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// 客户端类型
+const (
+	ClientAdmin  = "client-admin"
+	ClientWechat = "client-wechat"
+	ClientMini   = "client-mini"
+)
+
+// 一些 UA 列表
+const (
+	UAWechat      = "micromessenger"
+	UAMiniProgram = "miniprogram"
+)
+
+// GetClientType 获取客户端类型
+// 默认返回是 管理端
+func GetClientType(r *http.Request) string {
+	ua := strings.ToLower(r.Header.Get("User-Agent"))
+
+	if strings.Index(ua, UAWechat) > -1 {
+		// if strings.Index(ua, UAMiniProgram) > -1 {
+		// 	return ClientMini
+		// }
+
+		return ClientWechat
+	}
+
+	return ClientAdmin
+}
+
+// StrSliceIndexOf slice indexof
+func StrSliceIndexOf(s []string, t string) int64 {
+	if s == nil || len(s) == 0 {
+		return -1
+	}
+
+	for k, v := range s {
+		if v == t {
+			return int64(k)
+		}
+	}
+
+	return -1
+}
+
+// GUIID2IntString guid 转 int 字符串
+func GUIID2IntString(id string) []string {
+	if id == "" {
+		return nil
+	}
+
+	res := make([]string, 0)
+	for _, part := range strings.Split(id, "-") {
+		sum := 0
+		for _, r := range []rune(part) {
+			sum += int(r)
+		}
+
+		res = append(res, strconv.Itoa(sum))
+	}
+
+	return res
+}
+
+// EncodeBase64TrimTail base64 加密, 去除末尾 =
+func EncodeBase64TrimTail(src string) string {
+	if src == "" {
+		return ""
+	}
+
+	enStr := base64.StdEncoding.EncodeToString([]byte(src))
+
+	return strings.TrimRight(enStr, "=")
+}
+
+// DecodeBase64NoTail base64解密, 位数不够的, 自动补全
+func DecodeBase64NoTail(src string) string {
+	if src == "" {
+		return ""
+	}
+
+	pd := 4 - len(src)%4
+	if pd > 0 && pd != 4 {
+		src += strings.Repeat("=", pd)
+	}
+
+	res, err := base64.StdEncoding.DecodeString(src)
+	if err != nil {
+		LogError("解密 Base64 字串失败: " + err.Error())
+		return ""
+	}
+
+	return string(res)
+}
+
+// GetPageNaviLimit 获取 mysql limit 限定
+func GetPageNaviLimit(params ...int) []int {
+	page := 1
+	pagesize := 10
+
+	if params != nil {
+		pl := len(params)
+
+		if pl > 0 {
+			page = params[0]
+			if page < 1 {
+				page = 1
+			}
+		}
+
+		if pl > 1 {
+			pagesize = params[1]
+		}
+	}
+
+	return []int{
+		pagesize,
+		(page - 1) * pagesize,
+	}
+}
+
+// GenerateQRCode 生成二维码数字
+func GenerateQRCode() string {
+	var temp1 int = rand.Intn(9)*87 + 11
+	var temp2 int = rand.Intn(9)*89 + 13
+	nano := time.Now().UnixNano()
+	var nanostr string = strconv.FormatInt(nano, 10)
+	var temp3 string = nanostr[11:]
+	var temp4 string = "6"
+	var temp5 int = rand.Intn(9)*7 + 17
+	var code string = "66" + strconv.Itoa(temp1) + temp4 + strconv.Itoa(temp2) + temp3 + strconv.Itoa(temp5)
+	return code
+}
+
+// GetFiveSeconds 获取 5 秒钟的时间
+func GetFiveSeconds(t time.Time) string {
+	str := t.Format("20060102150405")
+	strLen := len(str)
+
+	lastNum, _ := strconv.Atoi(str[strLen-1:])
+	if lastNum < 5 {
+		lastNum = 0
+	} else {
+		lastNum = 5
+	}
+
+	return str[:strLen-1] + strconv.Itoa(lastNum)
+}
+
+// 当前运行环境
+var processEnv string
+var appRoot string
+
+// GetAppRoot 获取系统根目录
+func GetAppRoot() string {
+	if appRoot != "" {
+		return appRoot
+	}
+
+	if processEnv == "" {
+		for _, arg := range os.Args {
+			if strings.Index(arg, "-test.run") > -1 {
+				processEnv = "test"
+				break
+			}
+		}
+
+		if processEnv == "" {
+			processEnv = "production"
+		}
+	}
+
+	if processEnv == "test" {
+		_, file, _, _ := runtime.Caller(1)
+		appRoot, _ = filepath.Abs(filepath.Dir(filepath.Join(file, ".."+string(filepath.Separator))))
+	} else {
+		appRoot, _ = filepath.Abs(filepath.Dir(os.Args[0]))
+	}
+
+	return appRoot
+}

utils/utils_test.go

@@ -0,0 +1,118 @@
+package utils_test
+
+import (
+	"wechat-conf/utils"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestStrSliceIndexOf(t *testing.T) {
+	cases := []map[string]interface{}{
+		map[string]interface{}{
+			"case":     []string{"a", "b", "c"},
+			"expected": int64(1),
+		},
+		map[string]interface{}{
+			"case":     []string{"aa", "bb", "cc"},
+			"expected": int64(-1),
+		},
+	}
+
+	for _, cs := range cases {
+		td := cs["case"].([]string)
+		ex := cs["expected"].(int64)
+
+		res := utils.StrSliceIndexOf(td, "b")
+
+		if ex != res {
+			t.Fatalf("TestStrSliceIndexOf case fail : %v", res)
+		}
+	}
+}
+
+func TestGUIID2IntString(t *testing.T) {
+	cases := []map[string]string{
+		map[string]string{
+			"case":     "3b2da085-8881-4029-9a3d-6d33caf870d0",
+			"expected": "553-217-207-305-861",
+		},
+	}
+
+	for _, cs := range cases {
+		res := utils.GUIID2IntString(cs["case"])
+		if strings.Join(res, "-") != cs["expected"] {
+			t.Fatalf("TestGUIID2IntString fail")
+		}
+	}
+
+}
+
+func TestEncodeBase64TrimTail(t *testing.T) {
+	cases := []map[string]string{
+		map[string]string{
+			"case":     "1",
+			"expected": "MQ",
+		},
+		map[string]string{
+			"case":     "111",
+			"expected": "MTEx",
+		},
+	}
+
+	for _, cs := range cases {
+		res := utils.EncodeBase64TrimTail(cs["case"])
+		if res != cs["expected"] {
+			t.Fatalf("TestEncodeBase64TrimTail fail")
+		}
+	}
+}
+
+func TestDecodeBase64NoTail(t *testing.T) {
+	cases := []map[string]string{
+		map[string]string{
+			"case":     "MQ",
+			"expected": "1",
+		},
+		map[string]string{
+			"case":     "MTEx",
+			"expected": "111",
+		},
+	}
+
+	for _, cs := range cases {
+		res := utils.DecodeBase64NoTail(cs["case"])
+		if res != cs["expected"] {
+			t.Fatalf("TestDecodeBase64NoTail fail : %s", cs["case"])
+		}
+	}
+}
+
+func TestGetFiveSeconds(t *testing.T) {
+	cases := []map[string]string{
+		map[string]string{
+			"case":     "2018-10-07 13:21:40",
+			"expected": "20181007132140",
+		},
+		map[string]string{
+			"case":     "2018-10-07 13:21:42",
+			"expected": "20181007132140",
+		},
+		map[string]string{
+			"case":     "2018-10-07 13:21:45",
+			"expected": "20181007132145",
+		},
+		map[string]string{
+			"case":     "2018-10-07 13:21:48",
+			"expected": "20181007132145",
+		},
+	}
+
+	for _, cs := range cases {
+		dt, _ := time.Parse("2006-01-02 15:04:05", cs["case"])
+		res := utils.GetFiveSeconds(dt)
+		if res != cs["expected"] {
+			t.Fatalf("TestGetFiveSeconds fail : %s", cs["case"])
+		}
+	}
+}

utils/wechat.go

@@ -0,0 +1,116 @@
+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"`
+	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 {
+		wxClients = map[string]*wx.Client{
+			org: wx.NewClient(cert),
+		}
+	} else {
+		if _, ok := wxClients[org]; !ok {
+			wxClients[org] = wx.NewClient(cert)
+		}
+	}
+}
+
+// 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 WechatInit() {
+	logger := GetDefaultLogger()
+	wx.SetLogInst(logger)
+	mini.SetLogInst(logger)
+}
+
+// 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["nickname"] != nil {
+		user.NickName = data["nickname"].(string)
+	}
+
+	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
+}