hongze_api/controllers/user_pc.go

package controllers

import (
	"encoding/json"
	"fmt"
	"github.com/mojocn/base64Captcha"
	"hongze/hongze_api/services"
	"hongze/hongze_api/utils"
	"strconv"

	"hongze/hongze_api/models"
	"image/color"
	"time"
)

// @Title 获取图形验证码
// @Description 获取图形验证码
// @Success 200 {object} models.GraphicVerifyCodeResp
// @router /pc/getGraphicVerifyCode [get]
func (this *UserCommonController) GetGraphicVerifyCode() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var configC = base64Captcha.ConfigCharacter{
		Height:             26,
		Width:              67,
		Mode:               base64Captcha.CaptchaModeNumber,
		ComplexOfNoiseText: base64Captcha.CaptchaComplexLower,
		ComplexOfNoiseDot:  base64Captcha.CaptchaComplexLower,
		IsUseSimpleFont:    true,
		IsShowHollowLine:   false,
		IsShowNoiseDot:     true,
		IsShowNoiseText:    true,
		IsShowSlimeLine:    false,
		IsShowSineLine:     false,
		CaptchaLen:         4,
		BgColor:            &color.RGBA{255, 255, 255, 1},
	}
	char := base64Captcha.EngineCharCreate(configC)

	base64stringC := base64Captcha.CaptchaWriteToBase64Encoding(char)
	verifyId := fmt.Sprintf("%d", time.Now().UnixNano())
	item := new(models.GraphicVerifyCode)
	item.VerifyId = verifyId
	item.VerifyCode = char.CaptchaItem.VerifyValue
	item.CreateTime = time.Now()
	err := models.AddGraphicVerifyCode(item)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	resp := new(models.GraphicVerifyCodeResp)
	resp.VerifyId = verifyId
	resp.VerifyCode = base64stringC
	br.Ret = 200
	br.Data = resp
	br.Msg = "获取成功"
	br.Success = true
}

// @Title pc端获取短信验证码
// @Description pc端获取短信验证码接口
// @Param   Mobile   query   string  true       "手机号码"
// @Param   AreaNum   query   string  true       "地区编码"
// @Param   VerifyId   query   string  true       "图形验证码id"
// @Param   VerifyCode   query   string  true       "图形验证码code"
// @Success Ret=200 获取成功
// @router /pc/getSmsCode [get]
func (this *UserCommonController) PcGetSmsCode() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	mobile := this.GetString("Mobile")
	if mobile == "" {
		br.Msg = "请输入手机号"
		return
	}
	areaNum := this.GetString("AreaNum")
	msgCode := utils.GetRandDigit(4)
	verifyId := this.GetString("VerifyId")
	verifyCode := this.GetString("VerifyCode")

	item, err := models.GetGraphicVerifyById(verifyId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "验证码不存在，请刷新页面！"
			return
		}
		br.Msg = "校验验证码失败！"
		return
	}
	if item.VerifyCode != verifyCode {
		br.Msg = "验证码错误，请重新输入！"
		return
	}
	checkoutTime := time.Now().Add(15 * time.Minute)
	if item.CreateTime.After(checkoutTime) {
		br.Msg = "验证码过期，请重新输入！"
		return
	}

	var result bool
	if areaNum == "86" || areaNum == "" || areaNum == "0" {
		result = services.SendSmsCode(mobile, msgCode)
	} else {
		result = services.SendSmsCodeGj(mobile, msgCode, areaNum)
	}
	//发送成功
	if result {
		item := new(models.MsgCode)
		item.OpenId = ""
		item.Code = msgCode
		item.Mobile = mobile
		item.ExpiredIn = time.Now().Add(15 * time.Minute).Unix()
		item.Enabled = 1
		item.CreatedTime = time.Now()
		err := models.AddMsgCode(item)
		if err != nil {
			br.Msg = "发送失败"
			br.ErrMsg = "发送失败，Err:" + err.Error()
			return
		}
		br.Msg = "发送成功"
	} else {
		br.Msg = "发送失败"
	}
	br.Ret = 200
	br.Success = true
}

// @Title 登录
// @Description 登录接口
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} models.LoginResp
// @router /pc/login [post]
func (this *UserCommonController) PcLogin() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.PcLoginReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	userId := 0
	var isAdd bool
	if req.LoginType == 1 {
		if req.Mobile == "" {
			br.Msg = "请输入手机号"
			br.ErrMsg = "请输入手机号"
			return
		}
		if req.SmsCode == "" {
			br.Msg = "请输入有效手机验证码"
			br.ErrMsg = "请输入有效手机验证码"
			return
		}
		item, err := models.GetMsgCode(req.Mobile, req.SmsCode)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			} else {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			}
		}
		if item == nil {
			br.Msg = "手机验证码错误,请重新输入"
			return
		}
		wxUser, err := models.GetWxUserItemByMobile(req.Mobile)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				isAdd = true
			} else {
				br.Msg = "登陆失败"
				br.ErrMsg = "根据邮箱获取用户信息失败,Err:" + err.Error()
				return
			}
		}
		if wxUser == nil {
			isAdd = true
		} else {
			userId = wxUser.UserId
		}
		//BindMobile(openId, mobile string, userId, loginType int) (err error) {
		//newUserId, err = models.BindMobile(openId, req.Mobile, userId, req.LoginType)
	} else if req.LoginType == 2 {
		if req.Email == "" {
			br.ErrMsg = "邮箱不能为空,请输入邮箱"
			br.Msg = "邮箱不能为空,请输入邮箱"
			return
		}
		if !utils.ValidateEmailFormatat(req.Email) {
			br.ErrMsg = "邮箱格式错误，请重新输入"
			br.Msg = "邮箱格式错误，请重新输入"
			return
		}
		if req.SmsCode == "" {
			br.Msg = "请输入有效验证码"
			br.ErrMsg = "请输入有效验证码"
			return
		}
		item, err := models.GetMsgCode(req.Email, req.SmsCode)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			} else {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			}
		}
		if item == nil {
			br.Msg = "邮箱证码错误,请重新输入"
			return
		}
		wxUser, err := models.GetWxUserItemByEmail(req.Email)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				isAdd = true
			} else {
				br.Msg = "登陆失败"
				br.ErrMsg = "根据邮箱获取用户信息失败,Err:" + err.Error()
				return
			}
		}
		if wxUser == nil {
			isAdd = true
		} else {
			userId = wxUser.UserId
		}
	} else {
		br.Msg = "无效的登录方式"
		br.ErrMsg = "无效的登录方式,loginType:" + strconv.Itoa(req.LoginType)
	}
	if isAdd {
		user := new(models.WxUser)
		user.CompanyId = 1
		user.CreatedTime = time.Now()
		user.FirstLogin = 1
		user.Enabled = 1
		user.RegisterTime = time.Now()
		user.LoginTime = time.Now()
		user.IsFreeLogin = req.IsFreeLogin
		lastId, err := models.AddWxUser(user)
		if err != nil {
			br.Msg = "登录失败"
			br.ErrMsg = "登录失败,Err:" + err.Error()
			return
		}
		userId = int(lastId)
	} else {
		err = models.ModifyLoginTime(userId, req.IsFreeLogin)
		if err != nil {
			br.Msg = "登录失败"
			br.ErrMsg = "登录失败,修改登录信息失败,Err:" + err.Error()
			return
		}
	}
	if userId == 0 {
		br.Msg = "登录失败"
		br.ErrMsg = "登录失败,id为 0"
		return
	}
	timeUnix := time.Now().Unix()
	timeUnixStr := strconv.FormatInt(timeUnix, 10)
	token := utils.MD5(strconv.Itoa(userId)) + utils.MD5(timeUnixStr)
	//新增session
	{
		session := new(models.Session)
		session.UserId = userId
		session.CreatedTime = time.Now()
		session.LastUpdatedTime = time.Now()
		session.ExpireTime = time.Now().AddDate(1, 0, 0)
		session.AccessToken = token
		err = models.AddSession(session)
		if err != nil {
			br.Msg = "登录失败"
			br.ErrMsg = "登录失败，新增用户session信息失败:" + err.Error()
			return
		}
	}

	userPermission, err := services.CheckUserPermission(userId)
	if err != nil {
		br.Msg = "登录失败"
		br.ErrMsg = "登录失败，判断权限失败:" + err.Error()
		return
	}
	err = models.ModifyFirstLogin(userId)
	if err != nil {
		br.Msg = "登录失败"
		br.ErrMsg = "登录失败，判断权限失败:" + err.Error()
		return
	}
	newUser, _ := models.GetWxUserItemByUserId(userId)
	checkPermissionCount, err := models.GetCustomPermission(newUser.CompanyId)
	if err != nil {
		br.Msg = "登录失败"
		br.ErrMsg = "校验提示权限信息失败 Err:" + err.Error()
		return
	}

	resp := new(models.LoginResp)
	resp.UserId = newUser.UserId
	resp.UserPermission = userPermission
	resp.Authorization = token
	resp.Headimgurl = newUser.Headimgurl
	resp.Mobile = newUser.Mobile
	resp.Email = newUser.Email

	if checkPermissionCount <= 0 {
		resp.IsTips = true
	}

	br.Ret = 200
	br.Success = true
	br.Data = resp
	br.Msg = "登录成功"
}

// @Title 绑定手机号或邮箱
// @Description 绑定手机号或邮箱
// @Param	request	body models.BindReq true "type json string"
// @Success Ret=200 绑定成功
// @router /pc/bind [post]
func (this *UserController) PcBind() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.BindReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	openId := this.User.OpenId
	userId := this.User.UserId
	var newUserId int
	if req.BindType == 1 { //手机号
		if req.Mobile == "" {
			br.Msg = "请输入手机号"
			br.ErrMsg = "请输入手机号"
			return
		}
		if req.VerifyCode == "" {
			br.Msg = "请输入有效手机验证码"
			br.ErrMsg = "请输入有效手机验证码"
			return
		}
		item, err := models.GetMsgCode(req.Mobile, req.VerifyCode)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			} else {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			}
		}
		if item == nil {
			br.Msg = "手机验证码错误,请重新输入"
			return
		}
		newUserId, err = models.BindMobile(openId, req.Mobile, userId, req.BindType)
		if err != nil {
			br.ErrMsg = "绑定失败"
			br.Msg = "绑定失败,Err:" + err.Error()
			return
		}
	} else if req.BindType == 2 {
		if req.Email == "" {
			br.ErrMsg = "邮箱不能为空,请输入邮箱"
			br.Msg = "邮箱不能为空,请输入邮箱"
			return
		}
		if req.VerifyCode == "" {
			br.Msg = "请填写有效的邮箱验证码"
			br.ErrMsg = "请填写有效的邮箱验证码"
			return
		}
		if !utils.ValidateEmailFormatat(req.Email) {
			br.ErrMsg = "邮箱格式错误，请重新输入"
			br.Msg = "邮箱格式错误，请重新输入"
			return
		}
		item, err := models.GetMsgCode(req.Email, req.VerifyCode)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			} else {
				br.Msg = "验证码错误,请重新输入"
				br.ErrMsg = "校验验证码失败，Err:" + err.Error()
				return
			}
		}
		if item == nil {
			br.Msg = "邮箱证码错误,请重新输入"
			return
		}
		newUserId, err = models.BindMobile(openId, req.Mobile, userId, req.BindType)
		if err != nil {
			br.ErrMsg = "绑定失败"
			br.Msg = "绑定失败,Err:" + err.Error()
			return
		}
	} else {
		br.Msg = "无效的绑定方式"
		br.ErrMsg = "无效的绑定方式,bindType:" + strconv.Itoa(req.BindType)
		return
	}
	timeUnix := time.Now().Unix()
	timeUnixStr := strconv.FormatInt(timeUnix, 10)
	token := utils.MD5(strconv.Itoa(userId)) + utils.MD5(timeUnixStr)
	//新增session
	{
		session := new(models.Session)
		session.UserId = userId
		session.CreatedTime = time.Now()
		session.LastUpdatedTime = time.Now()
		session.ExpireTime = time.Now().AddDate(1, 0, 0)
		session.AccessToken = token
		err = models.AddSession(session)
		if err != nil {
			br.Msg = "绑定失败"
			br.ErrMsg = "绑定失败，新增用户session信息失败:" + err.Error()
			return
		}
	}
	userPermission, err := services.CheckUserPermission(newUserId)
	if err != nil {
		br.Msg = "绑定失败"
		br.ErrMsg = "绑定失败，判断权限失败:" + err.Error()
		return
	}
	err = models.ModifyFirstLogin(newUserId)
	if err != nil {
		br.Msg = "绑定失败"
		br.ErrMsg = "绑定失败，判断权限失败:" + err.Error()
		return
	}
	resp := new(models.LoginResp)
	resp.UserId = newUserId
	resp.UserPermission = userPermission
	resp.Authorization = token
	br.Ret = 200
	br.Success = true
	br.Data = resp
	br.Msg = "绑定成功"
}

// @Title 校验免登陆
// @Description 校验免登陆
// @Success Ret=200 绑定成功
// @router /pc/check/login [get]
func (this *UserController) CheckLogin() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	if this.User.IsFreeLogin == 1 {
		if this.User.LoginTime.AddDate(0, 0, 30).After(time.Now()) {
			br.Ret = 600
		} else {
			br.Ret = 408
		}
	} else {
		if this.User.LoginTime.AddDate(0, 0, 1).After(time.Now()) {
			br.Ret = 600 //正常状态，不需要登录
		} else {
			br.Ret = 408
		}
	}
	br.IsSendEmail = false
	br.Success = true
	br.Msg = "获取成功"
}

/*
var (
	searcher = riot.New("zh")
)

func init() {
	fmt.Sprintf("start")
	data := types.DocData{Content: `I wonder how, I wonder why
		, I wonder where they are`}
	data1 := types.DocData{Content: "所以, 你好, 再见"}
	data2 := types.DocData{Content: "没有理由"}
	data3 := types.DocData{Content: "你好，中国"}
	data4 := types.DocData{Content: "晚上好"}

	searcher.Index("1", data)
	searcher.Index("2", data1)
	searcher.IndexDoc("3", data2)
	searcher.IndexDoc("4", data3)
	searcher.IndexDoc("5", data4)
	searcher.Flush()

	req := types.SearchReq{Text: "你好"}
	search := searcher.Search(req)
	jsonStr,_:=json.Marshal(search)
	fmt.Println(string(jsonStr))
	utils.FileLog.Info("%s",string(jsonStr))
	fmt.Sprintf("end")
}
*/