conflict

controllers/auth.go

@@ -3,7 +3,7 @@ package controllers
 import (
 	"errors"
 	"net/http"
-	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/models"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strings"
@@ -19,14 +19,70 @@ func (c *BaseController) authenticate() {
 	// 客户端类型
 	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(
+			errors.New("内部错误, 请重试"),
+			http.StatusInternalServerError,
+		)
+	}
+
+	// 设置 Session
+	c.SetSession(SNUserID, userID)
+	// c.SetSession(SNUserType, userType)
+}
+
+func (c *BaseController) authWechat(serv *service.SysServ) {
 	// 用户类型, 此处与数据库定义的不是一个概念
 	// 此处主要用来区分是 系统用户, 还是 系统客户
-	userType := UserGuest
+	userType := ""
 	userTypeRaw := c.GetSession(SNUserType)
 	if userTypeRaw != nil {
 		userType = userTypeRaw.(string)
 	}
 
+	if userType == "" {
+		userType = models.USERMAP_CUSTOMER
+		identify := c.GetString("identify_type")
+		if identify == "admin" {
+			userType = models.USERMAP_USER
+		}
+	}
+
 	// 用户类型不同, 此处ID代表的内容也是不一样的
 	userID := ""
 	userIDRaw := c.GetSession(SNUserID)
@@ -34,52 +90,45 @@ func (c *BaseController) authenticate() {
 		userID = userIDRaw.(string)
 	}
 
-	// 用户映射表
-	var userMap *model.TaUserMapping
-
-	if clientType == utils.ClientWechat && userID == "" {
-		var err error
-		userMap, err = c.checkWechat(serv)
-		if err != nil {
-			utils.LogError("获取并校验微信信息失败: " + err.Error())
-		}
-
-		c.SetSession("openid", userMap.Openid)
+	// 用户微信信息
+	var wxDetail map[string]interface{}
+	detailRaw := c.GetSession("wechat_user")
+	if detailRaw != nil {
+		wxDetail = detailRaw.(map[string]interface{})
 	}
 
-	if !c.needAuth() {
-		return
+	if userID == "" && wxDetail == nil {
+		wxDetail = c.getWechatDetail()
+		c.SetSession("wechat_user", wxDetail)
 	}
 
-	// 如果是普通游客, 暂时没有任何设置
-	if userType == UserGuest {
-		return
+	// 用户映射
+	// 如果映射不存在, 则新建映射
+	userMap, err := serv.CheckWechatUserMapping(wxDetail, userType)
+	if err != nil {
+		c.ResponseError(
+			utils.LogError("获取人员映射账户失败: "+err.Error()),
+			http.StatusInternalServerError,
+		)
+
+		c.Context.Set("userMap", *userMap)
 	}
 
-	// 如果存在用户映射
-	mapUserID := c.getUserIDByUserMap(userMap, userID, userType)
-	if mapUserID != "" {
-		userID = mapUserID
+	if !c.needAuth() {
+		return
 	}
 
-	// 未登录状态
-	if userID == "" {
-		if clientType == utils.ClientWechat {
-			wxConf, ok := c.Configer[WeChatConf]
-			if ok {
-				c.ResponseData(
-					map[string]interface{}{
-						"appid": wxConf.String("appid"),
-					},
-					errors.New("用户未登录"),
-					http.StatusUnauthorized,
-				)
-			} else {
-				c.ResponseError(
-					errors.New("用户未登录"),
-					http.StatusUnauthorized,
-				)
-			}
+	// 未登录或者绑定, 返回 401
+	if userID == "" && userMap.UserId == "" {
+		wxConf, ok := c.Configer[WeChatConf]
+		if ok {
+			c.ResponseData(
+				map[string]interface{}{
+					"appid": wxConf.String("appid"),
+				},
+				errors.New("用户未登录"),
+				http.StatusUnauthorized,
+			)
 		} else {
 			c.ResponseError(
 				errors.New("用户未登录"),
@@ -88,26 +137,42 @@ func (c *BaseController) authenticate() {
 		}
 	}
 
-	// 设置 Session
-	c.SetSession(SNUserID, userID)
-	c.SetSession(SNUserType, userType)
+	// 人员微信账号绑定错误
+	if userID != "" && userMap.UserId != "" &&
+		(userID != userMap.UserId || userType != userMap.UserType) {
+		c.ResponseError(
+			errors.New("系统内部数据错误, 人员绑定不正确"),
+			http.StatusInternalServerError,
+		)
+	}
 
-	var err error
+	if userID == "" {
+		userID = userMap.UserId
+	}
 
-	// 设置 Context
-	// 放到 serv 的方法里面了
-	if userType == UserAdmin {
-		// 普通管理人员
-		err = serv.SetUserProfile(userID)
+	if userType == models.USERMAP_USER {
+		if err := serv.SetUserProfile(userID); err != nil {
+			utils.LogError(err.Error())
 
+			c.ResponseError(
+				errors.New("内部错误, 请重试"),
+				http.StatusInternalServerError,
+			)
+		}
 	} else {
-		// 系统客户
-		err = serv.SetCustomer(userID)
-	}
+		if err := serv.SetCustomer(userID); err != nil {
+			utils.LogError(err.Error())
 
-	if err != nil {
-		// 暂不处理
+			c.ResponseError(
+				errors.New("内部错误, 请重试"),
+				http.StatusInternalServerError,
+			)
+		}
 	}
+
+	// 设置 Session
+	c.SetSession(SNUserID, userID)
+	c.SetSession(SNUserType, userType)
 }
 
 func (c *BaseController) needAuth() bool {
@@ -122,63 +187,24 @@ func (c *BaseController) needAuth() bool {
 	return true
 }
 
-func (c *BaseController) checkWechat(serv *service.SysServ) (*model.TaUserMapping, error) {
-	// 确定客户端类型
-	adminClient := c.GetString("admin")
-	userType := service.USERTYPE_CUSTOMER
-	if adminClient != "" {
-		userType = service.USERTYPE_USER
-	}
-
-	openIDRaw := c.GetSession("openid")
-	if openIDRaw != nil {
-		openID := openIDRaw.(string)
-		wxUser := map[string]interface{}{
-			"openid": openID,
-		}
-		return serv.CheckWechatUserMapping(wxUser, userType)
-	}
-
+// getWechatDetail 获取微信个人信息详情
+func (c *BaseController) getWechatDetail() map[string]interface{} {
 	// 微信 code
 	code := c.GetString("code")
 	if code == "" {
-		return nil, errors.New("没有微信 code")
+		c.ResponseError(
+			errors.New("没有接收到微信 code"),
+			http.StatusBadRequest,
+		)
 	}
 
-	// 获取微信信息
-	wxUser, err := utils.GetWxUserInfo(code)
+	usr, err := utils.GetWxUserInfo(code)
 	if err != nil {
-		return nil, err
-	}
-
-	return serv.CheckWechatUserMapping(wxUser, userType)
-}
-
-// getUserIDByUserMap 校验用户映射是否与 Session 一致
-func (c *BaseController) getUserIDByUserMap(user *model.TaUserMapping, userID, userType string) string {
-	// 如果映射信息不存在
-	if user == nil {
-		return ""
-	}
-
-	// 如果 session 数据存在, 以 session 为准
-	if userID != "" {
-		return ""
-	}
-
-	// 如果是系统内置用户
-	if user.UserType == service.USERTYPE_USER {
-		if userType != UserAdmin {
-			return ""
-		}
-	}
-
-	// 如果是普通客户
-	if user.UserType == service.USERTYPE_CUSTOMER {
-		if userType != UserCustomer {
-			return ""
-		}
+		c.ResponseError(
+			utils.LogError("获取微信个人信息失败: "+err.Error()),
+			http.StatusInternalServerError,
+		)
 	}
 
-	return user.UserId
+	return usr
 }

controllers/context.go

@@ -11,6 +11,7 @@ import (
 * - 包含内容如下
 * user					用户基本信息
 * customer			会员基本信息
+* userMap				用户/会员 映射第三方账户
 * cases					用户所有案场信息
 * currentCase 	当前案场
 * org						用户当前组织

controllers/customer/customer.go

@@ -0,0 +1,82 @@
+package customer
+
+import (
+	"errors"
+	"net/http"
+	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service/customer"
+	"spaceofcheng/services/utils"
+)
+
+// CustomerController 用户
+type CustomerController struct {
+	serv *customer.CustomerServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *CustomerController) Constructor() {
+	c.serv = customer.NewCustomerServ(c.Context)
+}
+
+// CustWXList 获取客户列表
+func (c *CustomerController) CustWXList() {
+	phone := c.GetString("phone")
+	page, _ := c.GetInt("page")
+
+	custList, total, err := c.serv.GetCustWithWXList(phone, page)
+	if err != nil {
+		utils.LogError("获取客户列表失败: " + err.Error())
+		c.ResponseError(
+			errors.New("获取客户列表失败"),
+			http.StatusInternalServerError,
+		)
+	}
+
+	c.ResponseJSON(map[string]interface{}{
+		"list":  custList,
+		"total": total,
+	})
+}
+
+// GetCustOrUserByID 获取用户信息
+func (c *CustomerController) GetCustOrUserByID() {
+	userMapRaw := c.Context.Get("userMap")
+	if userMapRaw == nil {
+		c.ResponseError(errors.New("获取用户信息失败, 请确认使用微信浏览"))
+	}
+
+	userMap := userMapRaw.(model.TaUserMapping)
+
+	if userMap.UserType == models.USERMAP_USER {
+		// 如果是用户
+		userID := userMap.UserId
+		user, err := c.serv.GetCustUserByID(userID)
+		if err != nil {
+			utils.LogError(err)
+			c.ResponseError(errors.New("获取用户信息失败, 请重试"))
+		}
+
+		c.ResponseJSON(map[string]interface{}{
+			"user":     user,
+			"userType": userMap.UserType,
+		})
+	} else {
+		// 如果是客户
+		custID := userMap.UserId
+		cust, err := c.serv.GetCustWithWXByID(custID)
+		if err != nil {
+			utils.LogError(err)
+			c.ResponseError(errors.New("获取用户信息失败, 请重试"))
+		}
+
+		c.ResponseJSON(map[string]interface{}{
+			"customer": cust,
+			"userType": userMap.UserType,
+		})
+	}
+}

controllers/message.go

@@ -0,0 +1,42 @@
+package controllers
+
+import (
+	"errors"
+	"spaceofcheng/services/utils"
+)
+
+// SendCaptcha 发送验证码
+func (c *BaseController) SendCaptcha() {
+	phone := c.GetString("phone")
+
+	if phone == "" {
+		c.ResponseError(errors.New("请确定手机号码"))
+	}
+
+	if err := utils.SendCaptcha(phone); err != nil {
+		utils.LogError(err)
+		c.ResponseError(errors.New("验证码发送失败, 请重试"))
+	}
+
+	c.ResponseJSON("ok")
+}
+
+// ValidCaptcha 发送验证码
+func (c *BaseController) ValidCaptcha() {
+	phone := c.GetString("phone")
+
+	if phone == "" {
+		c.ResponseError(errors.New("请确定手机号码"))
+	}
+
+	captcha := c.GetString("captcha")
+	if captcha == "" {
+		c.ResponseError(errors.New("验证码不能为空"))
+	}
+
+	if err := utils.ValidCaptcha(phone, captcha); err != nil {
+		c.ResponseError(err)
+	}
+
+	c.ResponseJSON("ok")
+}

controllers/session.go

@@ -7,6 +7,6 @@ const (
 	// 用户类型
 	SNUserType = "userType"
 
-	// 内置 openid
-	// 请勿使用 openid 作为 session 的key
+	// 内置 wechat_user
+	// 请勿使用 wechat_user 作为 session 的key
 )

controllers/types.go

@@ -1,12 +1,5 @@
 package controllers
 
-// 用户类型列表
-const (
-	UserGuest    = "guest"
-	UserAdmin    = "admin"
-	UserCustomer = "customer"
-)
-
 // JSONMessage 主要用于 Response 返回
 type JSONMessage struct {
 	Code    int         `json:"code"`

controllers/user/user.go

@@ -1,10 +1,15 @@
 package user
 
 import (
+	"errors"
+	"net/http"
 	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
+	"time"
 )
 
 // UserController 用户
@@ -127,3 +132,84 @@ func (c *UserController) GetUserCustomer() {
 	}
 	c.ResponseJSON(customers)
 }
+
+// SignIn 用户登录
+func (c *UserController) SignIn() {
+	userName := c.GetString("username")
+	userPassword := c.GetString("userpassword")
+	token := c.GetString("token")
+	doRemember, _ := c.GetInt("doremember")
+
+	if token != "" {
+		tokenMap, err := utils.PareseToken(token)
+		if err != nil {
+			utils.LogError("解析用户 token 失败: " + err.Error())
+
+			c.ResponseError(
+				errors.New("登录失败, 用户名或者密码不正确"),
+				http.StatusBadRequest,
+			)
+		}
+
+		userName = tokenMap["user"].(string)
+		userPassword = tokenMap["password"].(string)
+	}
+
+	user, err := c.dao.CheckUserSignIn(userName, userPassword)
+	if err != nil {
+		utils.LogError("用户登录失败: " + err.Error())
+		c.ResponseError(
+			errors.New("登录失败, 用户名或者密码不正确"),
+			http.StatusBadRequest,
+		)
+	}
+
+	// 成功之后, 设置 session
+	c.SetSession(controllers.SNUserID, user.UserId)
+	c.SetSession(controllers.SNUserType, models.USERMAP_USER)
+
+	if token == "" && doRemember != 0 {
+		var err error
+		token, err = utils.CreateToken(map[string]interface{}{
+			"user":     userName,
+			"password": userPassword,
+			"exp":      time.Now().Local().Add(7 * 24 * time.Hour), // 有效期是 7 天
+		})
+
+		if err != nil {
+			utils.LogError("生成 用户登录 token 失败: " + err.Error())
+		}
+	}
+
+	c.ResponseJSON(map[string]interface{}{
+		token: token,
+	})
+}
+
+// SignOut 用户登出
+func (c *UserController) SignOut() {
+	c.DestroySession()
+	c.ResponseJSON("ok")
+}
+
+// WechatSignIn 微信登录
+func (c *UserController) WechatSignIn() {
+	phone := c.GetString("phone")
+	captcha := c.GetString("captcha")
+
+	if err := utils.ValidCaptcha(phone, captcha); err != nil {
+		c.ResponseError(err)
+	}
+
+	userMapping := c.Context.Get("userMap").(model.TaUserMapping)
+
+	user, err := c.dao.BindWechatUser(&userMapping, phone)
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	c.SetSession(controllers.SNUserID, user.UserId)
+	c.SetSession(controllers.SNUserType, models.USERMAP_USER)
+
+	c.ResponseJSON("ok")
+}

models/constant.go

@@ -22,3 +22,9 @@ const (
 	IMAGETYPE_COVER  = "cover"
 	IMAGETYPE_DETAIL = "detail"
 )
+
+// 映射表用户类型
+const (
+	USERMAP_USER     = "user"
+	USERMAP_CUSTOMER = "customer"
+)

models/customer/customer.go

@@ -0,0 +1,177 @@
+package customer
+
+import (
+	"errors"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"time"
+
+	"github.com/yl10/kit/guid"
+
+	"github.com/go-xorm/xorm"
+)
+
+// CustomerDAO 当前数据库操作对象
+type CustomerDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewCustomerDAO New Inst
+func NewCustomerDAO(ctx *utils.Context) *CustomerDAO {
+	return &CustomerDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+// CustWithWXList 客户列表
+func (m *CustomerDAO) CustWithWXList(phone string, page ...int) ([]CustWithWX, int64, error) {
+	if phone == "" {
+		phone = "%"
+	} else {
+		phone = "%" + phone + "%"
+	}
+
+	pageNum := 10
+	if m.ctx.Get("pageNum") != nil {
+		pageNum = m.ctx.Get("pageNum").(int)
+	}
+
+	pg := 1
+	if len(page) > 0 {
+		pg = page[0]
+	}
+	offset := (pg - 1) * pageNum
+	if offset < 0 {
+		offset = 0
+	}
+
+	query := `
+		SELECT *
+		FROM
+			ta_customer t
+		LEFT JOIN ta_user_mapping s ON t.customer_id = s.user_id
+			AND s.user_type = '` + models.USERMAP_CUSTOMER + `'
+			AND s.account_type = '` + models.ACCMAP_WECHAT + `'
+		WHERE
+			t.phone like ?
+		AND t.status > ?
+		ORDER BY
+			t.create_date DESC
+	`
+
+	var cust []CustWithWX
+
+	cnt, err := utils.GetPageList(m.db, &cust, []int{pageNum, offset}, query, phone, models.STATUS_DEL)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return cust, cnt, nil
+}
+
+// GetCustWithWXByID 获取客户(微信)信息
+func (m *CustomerDAO) GetCustWithWXByID(custID string) (*CustWithWX, error) {
+	if custID == "" {
+		return nil, errors.New("获取客户信息失败")
+	}
+
+	cust := CustWithWX{}
+	query := `
+		SELECT *
+		FROM
+			ta_customer t
+		LEFT JOIN ta_user_mapping s ON t.customer_id = s.user_id
+			AND s.user_type = '` + models.USERMAP_CUSTOMER + `'
+			AND s.account_type = '` + models.ACCMAP_WECHAT + `'
+		WHERE
+			t.customer_id = ?
+	`
+
+	if _, err := m.db.SQL(query, custID).Get(&cust); err != nil {
+		return nil, err
+	}
+
+	return &cust, nil
+}
+
+// GetCustomerByPhone 依据手机号获取客户信息
+func (m *CustomerDAO) GetCustomerByPhone(phone string) (*model.TaCustomer, error) {
+	custs := []model.TaCustomer{}
+
+	if err := m.db.Where("phone=?", phone).Find(&custs); err != nil {
+		return nil, err
+	}
+
+	if len(custs) == 0 {
+		return nil, nil
+	}
+
+	if len(custs) > 0 {
+		return nil, errors.New("数据异常, 一个手机绑定了多个用户")
+	}
+
+	cust := custs[0]
+
+	return &cust, nil
+}
+
+// UpdateUserMapping 更新用户映射
+func (m *CustomerDAO) UpdateUserMapping(userMap *model.TaUserMapping, cols []string) error {
+	if userMap.MappingId == "" {
+		return errors.New("用户映射信息不存在")
+	}
+
+	_, err := m.db.Where("mapping_id=?", userMap.MappingId).Cols(cols...).Update(&userMap)
+	return err
+}
+
+// GetCaseByID 获取案场
+func (m *CustomerDAO) GetCaseByID(caseID string) (*model.SysCase, error) {
+	if caseID == "" {
+		return nil, errors.New("获取案场信息失败")
+	}
+
+	cs := model.SysCase{}
+	has, err := m.db.Where("case_id=?", caseID).Get(&cs)
+	if err != nil {
+		return nil, err
+	}
+
+	if !has {
+		return nil, nil
+	}
+
+	return &cs, nil
+}
+
+// GetUserByID 获取系统用户
+func (m *CustomerDAO) GetUserByID(userID string) (*model.SysUser, error) {
+	if userID == "" {
+		return nil, errors.New("获取相关人员信息失败")
+	}
+
+	user := model.SysUser{}
+	has, err := m.db.Where("user_id=?", userID).Get(&user)
+	if err != nil {
+		return nil, err
+	}
+
+	if !has {
+		return nil, nil
+	}
+
+	return &user, nil
+}
+
+// SaveCustomer 新增客户
+func (m *CustomerDAO) SaveCustomer(cust *model.TaCustomer) error {
+	cust.CustomerId = guid.NewGUIDString()
+	cust.CreateDate = time.Now().Local()
+	cust.Status = models.STATUS_NORMAL
+
+	_, err := m.db.Insert(&cust)
+	return err
+}

models/customer/types.go

@@ -0,0 +1,12 @@
+package customer
+
+import (
+	"spaceofcheng/services/models/model"
+)
+
+// CustWithWX 客户及微信相关信息
+type CustWithWX struct {
+	model.TaCustomer    `xorm:"extends"`
+	model.TaUserMapping `xorm:"extends"`
+	Points              int
+}

models/system/user.go

@@ -1,6 +1,7 @@
 package system
 
 import (
+	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
@@ -328,3 +329,45 @@ func (m *UserDAO) GetUserCustomer(userid string, page int, pageSize int) ([]mode
 	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("recommend_id=?", userid).Limit(pageSize, page*pageSize).Desc("create_date").Find(&customers)
 	return customers, err
 }
+
+// GetUserByName 依据账户获取人员信息
+func (m *UserDAO) GetUserByName(userName string) (*model.SysUser, error) {
+	user := model.SysUser{}
+
+	has, err := m.db.Where("user_name=?", userName).Get(&user)
+	if err != nil {
+		return nil, err
+	}
+
+	if !has {
+		return nil, nil
+	}
+
+	return &user, nil
+}
+
+// GetUserByPhone 依据手机号获取人员信息
+func (m *UserDAO) GetUserByPhone(phone string) (*model.SysUser, error) {
+	user := model.SysUser{}
+
+	has, err := m.db.Where("phone=?", phone).Get(&user)
+	if err != nil {
+		return nil, err
+	}
+
+	if !has {
+		return nil, nil
+	}
+
+	return &user, nil
+}
+
+// UpdateUserMapping 更新用户映射
+func (m *UserDAO) UpdateUserMapping(userMap *model.TaUserMapping, cols []string) error {
+	if userMap.MappingId == "" {
+		return errors.New("用户映射信息不存在")
+	}
+
+	_, err := m.db.Where("mapping_id=?", userMap.MappingId).Cols(cols...).Update(&userMap)
+	return err
+}

service/customer/customer.go

@@ -0,0 +1,169 @@
+package customer
+
+import (
+	"encoding/json"
+	"errors"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/customer"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service/events"
+	"spaceofcheng/services/utils"
+	"strconv"
+)
+
+// CustomerServ 系统处理
+type CustomerServ struct {
+	ctx *utils.Context
+	dao *customer.CustomerDAO
+}
+
+// NewCustomerServ 初始化
+func NewCustomerServ(ctx *utils.Context) *CustomerServ {
+	return &CustomerServ{
+		ctx: ctx,
+		dao: customer.NewCustomerDAO(ctx),
+	}
+}
+
+// GetCustWithWXList 获取客户列表
+func (s *CustomerServ) GetCustWithWXList(phone string, page ...int) ([]customer.CustWithWX, int64, error) {
+	return s.dao.CustWithWXList(phone, page...)
+}
+
+// GetCustWithWXByID 获取客户列表
+func (s *CustomerServ) GetCustWithWXByID(custID string) (*customer.CustWithWX, error) {
+	cust, err := s.dao.GetCustWithWXByID(custID)
+	if err != nil {
+		return nil, err
+	}
+
+	if cust.Status != models.STATUS_NORMAL {
+		return nil, errors.New("用户状态异常")
+	}
+
+	return cust, nil
+}
+
+// GetCustUserByID 获取用户信息(自定义内容)
+func (s *CustomerServ) GetCustUserByID(userID string) (*UserProfile, error) {
+	user, err := s.dao.GetUserByID(userID)
+	if err != nil {
+		return nil, err
+	}
+
+	if user.Status != models.STATUS_NORMAL {
+		return nil, errors.New("用户状态异常")
+	}
+
+	userProfile := UserProfile{
+		UserId:     user.UserId,
+		UserName:   user.UserName,
+		RealName:   user.RealName,
+		Sex:        user.Sex,
+		WorkNo:     user.WorkNo,
+		Email:      user.Email,
+		Phone:      user.Phone,
+		Headimgurl: user.Headimgurl,
+	}
+
+	return &userProfile, nil
+}
+
+// BindWechat 绑定微信用户
+func (s *CustomerServ) BindWechat(userMap *model.TaUserMapping, phone, caseID, userID string) (*model.TaCustomer, error) {
+	cust, err := s.dao.GetCustomerByPhone(phone)
+	if err != nil {
+		return nil, err
+	}
+
+	// 用户不存在, 则新增
+	if cust == nil {
+		newCust, err := s.SaveNewCustomer(phone, caseID, userID)
+		if err != nil {
+			return nil, err
+		}
+
+		cust = newCust
+	}
+
+	if cust.Status != models.STATUS_NORMAL {
+		return nil, errors.New("用户状态不正确")
+	}
+
+	if cust.CustomerId == userMap.UserId {
+		return cust, nil
+	}
+
+	if userMap.UserId != "" {
+		return nil, errors.New("内部错误, 用户映射信息有误")
+	}
+
+	userMap.UserId = cust.CustomerId
+	if err := s.dao.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
+		utils.LogError("更新用户映射信息失败:" + err.Error())
+		return nil, errors.New("映射用户信息失败")
+	}
+
+	// triggerRegiteEvent 触发注册事件
+	utils.EmitEvent(events.EvtRegiste, *userMap)
+
+	return cust, nil
+}
+
+// SaveNewCustomer 新增客户
+func (s *CustomerServ) SaveNewCustomer(phone, caseID, userID string) (*model.TaCustomer, error) {
+	// 校验案场信息
+	cs, err := s.dao.GetCaseByID(caseID)
+	if err != nil {
+		return nil, err
+	}
+
+	if cs == nil || cs.Status == models.STATUS_DEL {
+		return nil, errors.New("系统无该推荐案场")
+	}
+
+	// 校验推荐人
+	user, err := s.dao.GetUserByID(userID)
+	if err != nil {
+		return nil, err
+	}
+
+	if user == nil || user.Status == models.STATUS_DEL {
+		return nil, errors.New("系统无该推荐人")
+	}
+
+	// 微信信息
+	userMap := s.ctx.Get("userMap").(model.TaUserMapping)
+	wxInfo := make(map[string]interface{})
+	if err := json.Unmarshal([]byte(userMap.AccountInfo), &wxInfo); err != nil {
+		utils.LogError(err.Error())
+		return nil, errors.New("校验用户微信信息失败")
+	}
+
+	nickyName := wxInfo["nickname"].(string)
+	sex := wxInfo["sex"].(string)
+	headimgurl := wxInfo["headimgurl"].(string)
+
+	sexInt, _ := strconv.Atoi(sex)
+	if sexInt == 0 {
+		sexInt = 1 // 默认男性
+	}
+
+	cust := model.TaCustomer{
+		OrgId:         cs.OrgId,
+		CustomerName:  nickyName,
+		Name:          nickyName,
+		Sex:           sexInt,
+		Headimgurl:    headimgurl,
+		RecommendId:   user.UserId,
+		RecommendName: user.RealName,
+		RecommendCase: cs.CaseId,
+	}
+
+	if err := s.dao.SaveCustomer(&cust); err != nil {
+		utils.LogError("更新客户信息失败: " + err.Error())
+		return nil, errors.New("更新客户信息失败")
+	}
+
+	return &cust, nil
+}

service/customer/types.go

@@ -0,0 +1,16 @@
+package customer
+
+type UserProfile struct {
+	UserId     string
+	UserName   string
+	RealName   string
+	Sex        int
+	WorkNo     string
+	Email      string
+	Phone      string
+	Headimgurl string
+}
+
+func (t *UserProfile) TableName() string {
+	return "sys_user"
+}

service/events/events.go

@@ -54,7 +54,7 @@ func getAllEvents() (map[string][]string, error) {
 }
 
 var tsAction = func(e tinyevent.Event) error {
-	str := string(e.Payload)
+	str := e.Payload.(string)
 	fmt.Println(str)
 	return nil
 }

service/user.go

@@ -2,18 +2,15 @@ package service
 
 import (
 	"errors"
+	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/models/system"
+	"spaceofcheng/services/service/events"
 	"spaceofcheng/services/utils"
 
 	"github.com/yl10/kit/encrypt"
 )
 
-const (
-	USERTYPE_USER     = "user"
-	USERTYPE_CUSTOMER = "customer"
-)
-
 // UserServ 系统处理
 type UserServ struct {
 	ctx     *utils.Context
@@ -244,3 +241,60 @@ func (s *UserServ) GetUserCustomer(userid string, page int, pageSize int) ([]mod
 	customers, err := s.dao.GetUserCustomer(userid, page, pageSize)
 	return customers, err
 }
+
+// CheckUserSignIn 校验用户登录
+func (s *UserServ) CheckUserSignIn(userName, userPassword string) (*model.SysUser, error) {
+	user, err := s.dao.GetUserByName(userName)
+	if err != nil {
+		return nil, err
+	}
+
+	if user == nil {
+		return nil, errors.New("账户不存在")
+	}
+
+	if user.Status != models.STATUS_NORMAL {
+		return nil, errors.New("用户账户异常")
+	}
+
+	if !s.dao.ValidatePassword(user, userPassword) {
+		return nil, errors.New("用户密码不正确")
+	}
+
+	return user, nil
+}
+
+// BindWechatUser 绑定微信用户
+func (s *UserServ) BindWechatUser(userMap *model.TaUserMapping, phone string) (*model.SysUser, error) {
+	user, err := s.dao.GetUserByPhone(phone)
+	if err != nil {
+		return nil, err
+	}
+
+	if user == nil {
+		return nil, errors.New("手机号对应用户不存在")
+	}
+
+	if user.Status != models.STATUS_NORMAL {
+		return nil, errors.New("用户状态不正确")
+	}
+
+	if user.UserId == userMap.UserId {
+		return user, nil
+	}
+
+	if userMap.UserId != "" {
+		return nil, errors.New("内部错误, 用户映射信息有误")
+	}
+
+	userMap.UserId = user.UserId
+	if err := s.dao.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
+		utils.LogError("更新用户映射信息失败:" + err.Error())
+		return nil, errors.New("映射用户信息失败")
+	}
+
+	// triggerRegiteEvent 触发注册事件
+	utils.EmitEvent(events.EvtRegiste, *userMap)
+
+	return user, nil
+}

utils/captcha.go

@@ -0,0 +1,99 @@
+package utils
+
+import (
+	"errors"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type cap struct {
+	Phone   string
+	Captcha string
+	Expire  time.Time
+}
+
+// CaptchaEngine 验证码引擎
+type CaptchaEngine struct {
+	capList map[string]cap
+}
+
+var capEngine *CaptchaEngine
+
+// NewCaptchaEngine 创建验证码引擎
+func NewCaptchaEngine() *CaptchaEngine {
+	return &CaptchaEngine{
+		capList: make(map[string]cap),
+	}
+}
+
+// SendCaptcha 发送验证码
+func SendCaptcha(phone string) error {
+	if phone == "" {
+		return errors.New("验证码发送错误: 没有手机号")
+	}
+
+	capEngine.SendCaptcha(phone)
+	return nil
+}
+
+// ValidCaptcha 校验 验证码
+func ValidCaptcha(phone, cap string) error {
+	if phone == "" {
+		return errors.New("验证码校验失败: 没有手机号")
+	}
+
+	return capEngine.ValidCaptcha(phone, cap)
+}
+
+// Random 获取随机数
+// 连续调用会有随机数不随机问题
+func (c *CaptchaEngine) Random(length int, phone string) string {
+	phoneInt, _ := strconv.ParseInt(phone, 10, 64)
+
+	r := rand.New(rand.NewSource(time.Now().UnixNano() + phoneInt))
+	dict := strings.Split("0123456789", "")
+
+	res := ""
+	for i := 0; i < length; i++ {
+		res = res + dict[r.Intn(10)]
+	}
+
+	return res
+}
+
+// SendCaptcha 发送验证码
+func (c *CaptchaEngine) SendCaptcha(phone string) {
+	theCap := cap{
+		Phone:   phone,
+		Captcha: capEngine.Random(6, phone),
+		Expire:  time.Now().Local().Add(1 * time.Minute),
+	}
+
+	c.capList[phone] = theCap
+
+	SendSMS(theCap.Captcha, theCap.Phone)
+}
+
+// ValidCaptcha 验证 验证码
+func (c *CaptchaEngine) ValidCaptcha(phone, cap string) error {
+	theCap, ok := c.capList[phone]
+	if !ok {
+		return errors.New("未发送过该号码的验证码")
+	}
+
+	if time.Now().Local().Before(theCap.Expire) {
+		return errors.New("验证码已过期")
+	}
+
+	if theCap.Captcha != cap {
+		return errors.New("验证码不正确")
+	}
+
+	return nil
+}
+
+func init() {
+	capEngine = NewCaptchaEngine()
+}

utils/captcha_test.go

@@ -0,0 +1,18 @@
+package utils_test
+
+import (
+	"spaceofcheng/services/utils"
+	"testing"
+	"time"
+)
+
+func TestRandom(t *testing.T) {
+	capEngine := utils.NewCaptchaEngine()
+	r1 := capEngine.Random(6, "13823838438")
+	time.Sleep(1 * time.Microsecond)
+	r2 := capEngine.Random(6, "13823838438")
+
+	if r1 == r2 {
+		t.Fatalf("Test CaptchaEngine Random fail, %s", r2)
+	}
+}

utils/event.go

@@ -7,7 +7,7 @@ import (
 var evtBus = &tinyevent.DefaultBus{}
 
 // EmitEvent 执行事件
-func EmitEvent(evt string, payload []byte) {
+func EmitEvent(evt string, payload interface{}) {
 	e := tinyevent.Event{
 		Name:    evt,
 		Payload: payload,

utils/jwt.go

@@ -0,0 +1,34 @@
+package utils
+
+import (
+	"errors"
+
+	jwt "github.com/dgrijalva/jwt-go"
+)
+
+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 解析 未知错误")
+}

utils/message.go

@@ -33,3 +33,8 @@ func SendMessage(message Message, msgType string) {
 	default:
 	}
 }
+
+// SendSMS 发送短信
+func SendSMS(message interface{}, to string) {
+
+}

utils/pagenavi.go

@@ -0,0 +1,61 @@
+package utils
+
+import (
+	"errors"
+	"regexp"
+	"strconv"
+
+	"github.com/go-xorm/xorm"
+)
+
+// GetPageList 获取列表
+func GetPageList(db *xorm.Session, target interface{}, limit []int, sqlorArgs ...interface{}) (int64, error) {
+	if sqlorArgs == nil || len(sqlorArgs) == 0 {
+		return 0, errors.New("SQL 语句不存在")
+	}
+
+	countSQLorArgs := GetCountSQL(sqlorArgs...)
+	cntRes, err := db.Query(countSQLorArgs...)
+	if err != nil {
+		return 0, err
+	}
+
+	cntStr := string(cntRes[0]["cnt"])
+	cnt, _ := strconv.ParseInt(cntStr, 10, 64)
+
+	sql, args := PackLimitToSQL(limit, sqlorArgs...)
+
+	err = db.SQL(sql, args...).Find(target)
+	if err != nil {
+		return 0, err
+	}
+
+	return cnt, nil
+}
+
+// GetCountSQL 获取计算 Count 的相关 SQL 脚本
+func GetCountSQL(sqlorArgs ...interface{}) []interface{} {
+	sql := sqlorArgs[0].(string)
+
+	re := regexp.MustCompile("(?ims)(select .* from)")
+	cntSQL := re.ReplaceAllString(sql, "select count(*) as cnt from")
+
+	newSQLorArgs := []interface{}{cntSQL}
+	newSQLorArgs = append(newSQLorArgs, sqlorArgs[1:])
+	return newSQLorArgs
+}
+
+// PackLimitToSQL 添加 limit 语句到 sql 最后
+func PackLimitToSQL(limit []int, sqlorArgs ...interface{}) (string, []interface{}) {
+	sql := sqlorArgs[0].(string)
+	args := sqlorArgs[1:]
+
+	switch len(limit) {
+	case 1:
+		return sql + " LIMIT " + strconv.Itoa(limit[0]), args
+	case 2:
+		return sql + " LIMIT " + strconv.Itoa(limit[0]) + " OFFSET " + strconv.Itoa(limit[1]), args
+	default:
+		return sql, args
+	}
+}

utils/pagenavi_test.go

@@ -0,0 +1,71 @@
+package utils_test
+
+import (
+	"spaceofcheng/services/utils"
+	"testing"
+)
+
+func TestGetCountSQL(t *testing.T) {
+	testCases := []map[string]string{
+		map[string]string{
+			"sql":      "Select field1, field2 From table",
+			"expected": "select count(*) as cnt from table",
+		},
+		map[string]string{
+			"sql": `Select 
+								field1, field2 From table where status = ?`,
+			"expected": "select count(*) as cnt from table where status = ?",
+		},
+	}
+
+	for inx, cs := range testCases {
+		sql := cs["sql"]
+		expected := cs["expected"]
+
+		var res []interface{}
+		if inx < 1 {
+			res = utils.GetCountSQL(sql)
+		} else {
+			res = utils.GetCountSQL(sql, inx)
+		}
+
+		if res == nil || len(res) == 0 {
+			t.Fatalf("Test GetCountSQL fail --1")
+		}
+
+		newSQL := res[0].(string)
+		if newSQL != expected {
+			t.Fatalf("Test GetCountSQL fail: %s", newSQL)
+		}
+	}
+}
+
+func TestPackLimitToSQL(t *testing.T) {
+	testCases := []map[string]string{
+		map[string]string{
+			"sql":      "Select * From table",
+			"expected": "Select * From table LIMIT 1 OFFSET 0",
+		},
+		map[string]string{
+			"sql":      "Select * From table",
+			"expected": "Select * From table LIMIT 1",
+		},
+	}
+
+	for inx, cs := range testCases {
+		sql := cs["sql"]
+		expected := cs["expected"]
+
+		var sqlRes string
+		if inx < 1 {
+			sqlRes, _ = utils.PackLimitToSQL([]int{inx + 1, inx}, sql)
+		} else {
+			sqlRes, _ = utils.PackLimitToSQL([]int{inx}, sql, inx)
+		}
+
+		if sqlRes != expected {
+			t.Fatalf("\n%v: Test PackLimitToSQL fail: %s", inx+1, sqlRes)
+		}
+	}
+
+}