hongze_cygx/services/user.go

package services

import (
	"errors"
	"fmt"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/utils"
	"strconv"
	"time"
)

var ERR_NO_USER_RECORD = errors.New("用户关系没有入库")
var ERR_USER_NOT_BIND = errors.New("用户没有绑定")

//通过openid获取用户信息
func GetWxUserItemByOpenId(openid string) (item *models.WxUserItem, err error) {
	//通过openid获取用户关联信息
	userRecord, userRecordErr := models.GetUserRecordByOpenId(openid)
	fmt.Println("userRecordErr",userRecordErr)
	if userRecordErr != nil {
		if userRecordErr.Error() == utils.ErrNoRow() {
			err = ERR_NO_USER_RECORD
			return
		} else {
			err = userRecordErr
			return
		}
	}

	//该openid在系统中没有关联关系
	if userRecord == nil {
		err = ERR_NO_USER_RECORD
		return
	}

	//该openid没有绑定用户
	if userRecord.UserId <= 0 {
		err = ERR_USER_NOT_BIND
		item = new(models.WxUserItem)
		//格式化返回用户数据
		formatWxUserAndUserRecord(item, userRecord)
		return
	}

	//获取用户信息
	item, wxUserErr := models.GetWxUserItemByUserId(userRecord.UserId)
	fmt.Println("wxUserErr",wxUserErr)
	if wxUserErr != nil {
		err = wxUserErr
		return
	}
	//格式化返回用户数据
	formatWxUserAndUserRecord(item, userRecord)
	return
}

//根据用户id和平台id获取用户信息
func GetWxUserItemByUserId(userId, platform int) (wxUserItem *models.WxUserItem, err error) {
	//获取用户信息
	wxUserItem, wxUserErr := models.GetWxUserItemByUserId(userId)
	if wxUserErr != nil {
		err = wxUserErr
		return
	}
	//格式化返回用户数据
	formatWxUser(wxUserItem, platform)
	return
}

//根据用户邮箱和平台id获取用户信息
func GetWxUserItemByEmail(email string, platform int) (wxUserItem *models.WxUserItem, err error) {
	//获取用户信息
	wxUserItem, wxUserErr := models.GetWxUserItemByEmail(email)
	if wxUserErr != nil {
		err = wxUserErr
		return
	}

	//格式化返回用户数据
	formatWxUser(wxUserItem, platform)
	return
}

//根据用户手机号和平台id获取用户信息
func GetWxUserItemByMobile(mobile string, platform int) (wxUserItem *models.WxUserItem, err error) {
	//获取用户信息
	wxUserItem, wxUserErr := models.GetWxUserItemByMobile(mobile)
	if wxUserErr != nil {
		err = wxUserErr
		return
	}
	//格式化返回用户数据
	formatWxUser(wxUserItem, platform)
	return
}

//根据用户unionid和平台id获取用户信息
func GetWxUserItemByUnionId(unionId string, platform int) (wxUserItem *models.WxUserItem, err error) {
	//获取用户信息
	wxUserItem, wxUserErr := models.GetWxUserItemByUnionid(unionId)
	if wxUserErr != nil {
		err = wxUserErr
		return
	}
	//格式化返回用户数据
	formatWxUser(wxUserItem, platform)
	return
}

//通过用户 关系表记录  和  用户记录  格式化返回 用户数据
func formatWxUserAndUserRecord(wxUser *models.WxUserItem, userRecord *models.UserRecord) {
	wxUser.OpenId = userRecord.OpenId
	wxUser.UnionId = userRecord.UnionId
	wxUser.NickName = userRecord.NickName
	//wxUser.RealName = userRecord.RealName
	//wxUser.BindAccount = userRecord.BindAccount
	wxUser.Headimgurl = userRecord.Headimgurl
}

//通过用户 用户记录  和  来源平台  格式化返回 用户数据
func formatWxUser(wxUser *models.WxUserItem, platform int) {
	//根据用户id和平台id获取用户关系
	userRecord, userRecordErr := models.GetUserRecordByUserId(wxUser.UserId, platform)
	if userRecordErr != nil {
		if userRecordErr.Error() != utils.ErrNoRow() {
			return
		}
		if userRecordErr.Error() == utils.ErrNoRow() {
			return
		}
	}

	//该openid在系统中没有关联关系
	if userRecord == nil {
		return
	}

	wxUser.OpenId = userRecord.OpenId
	wxUser.UnionId = userRecord.UnionId
	wxUser.NickName = userRecord.NickName
	//wxUser.RealName = userRecord.RealName
	//wxUser.BindAccount = userRecord.BindAccount
	wxUser.Headimgurl = userRecord.Headimgurl
	return
}

//用户绑定
func BindWxUser(openid, mobile, email string) (wxUser *models.WxUserItem, err error) {
	if mobile == "" && email == "" {
		err = errors.New("手机号或邮箱必填一个")
		return
	}
	var bindAccount string
	//根据手机号获取用户信息
	if mobile != "" {
		tmpWxUser, wxUserErr := models.GetWxUserItemByMobile(mobile)
		if wxUserErr != nil && wxUserErr.Error() != utils.ErrNoRow() {
			err = wxUserErr
			return
		}
		wxUser = tmpWxUser
		bindAccount = mobile
	}
	//根据邮箱获取用户信息
	if wxUser == nil && email != "" {
		tmpWxUser, wxUserErr := models.GetWxUserItemByEmail(email)
		if wxUserErr != nil && wxUserErr.Error() != utils.ErrNoRow() {
			err = wxUserErr
			return
		}
		wxUser = tmpWxUser
		bindAccount = email
	}

	//查询openid的第三方（微信）信息
	userRecord, err := models.GetUserRecordByOpenId(openid)
	if err != nil {
		return
	}

	var userId int
	//如果查询出来的用户是nil，那么需要新增用户
	if wxUser == nil {
		user := &models.WxUser{
			CompanyId:        1,
			CreatedTime:      time.Now(),
			FirstLogin:       1,
			Enabled:          1,
			RegisterPlatform: 1,
			RegisterTime:     time.Now(),
			Mobile:           mobile,
			Email:            email,
		}
		tmpUserId, addUserErr := models.AddWxUser(user)
		if err != nil {
			err = addUserErr
			return
		}
		user.UserId = int(tmpUserId)
		userId = int(tmpUserId)
		wxUser, err = models.GetWxUserItemByUserId(userId)
	} else {
		userId = wxUser.UserId
	}
	//如果存在该手机号/邮箱，那么需要校验
	if userRecord.UserId > 0 && userRecord.UserId != userId {
		err = errors.New("用户已绑定，不允许重复绑定")
		return
	}

	err = models.BindUserRecordByOpenid(userId, openid, bindAccount)
	if err != nil {
		return
	}
	userRecord.UserId = userId
	//格式化用户数据
	formatWxUserAndUserRecord(wxUser, userRecord)
	return
}

//微信登录
func WxLogin(code, openId, unionId string, wxUserInfo *WxUserInfo) (token string, userId, firstLogin, permission int, err error) {
	if unionId == "" {
		unionId = wxUserInfo.Unionid
	}
	//firstLogin==1，强制绑定手机号或者邮箱
	firstLogin = 1
	fmt.Println("GetWxUserItemByOpenId ", openId)
	wxUser, wxUserErr := GetWxUserItemByOpenId(openId)
	fmt.Println("wxUserErr",wxUserErr)
	if wxUserErr == ERR_NO_USER_RECORD { //没有用户openid记录
		_, recordErr := AddUserRecord(openId, unionId, wxUserInfo.Nickname, "", wxUserInfo.Province, wxUserInfo.City, wxUserInfo.Country, wxUserInfo.Headimgurl, wxUserInfo.SessionKey, utils.WxPlatform, wxUserInfo.Sex, 0)
		err = recordErr
		return
	} else if wxUserErr == ERR_USER_NOT_BIND {
		//没有用户信息
		//wxUser.FirstLogin = 1
	} else if wxUserErr != nil {
		err = wxUserErr
		return
	}
	fmt.Println("line 239 ", openId)
	//如果已经登录注册绑定的情况下
	if wxUser != nil && wxUserErr == nil {
		//获取用户权限
		firstLogin = wxUser.FirstLogin
		userId = wxUser.UserId
		if wxUserInfo != nil && wxUserInfo.Nickname != "" {
			go models.ModifyUserRecordInfo(openId, wxUserInfo.Nickname, wxUserInfo.Headimgurl, wxUserInfo.City, wxUserInfo.Province, wxUserInfo.Country, wxUserInfo.Sex, userId)
		}

		{
			codeLog := new(models.WxUserCode)
			codeLog.WxCode = code
			codeLog.UserId = userId
			codeLog.Code = 0
			codeLog.FirstLogin = firstLogin
			codeLog.Authorization = token
			codeLog.UserPermission = permission
			codeLog.CreateTime = time.Now()
			go models.AddWxUserCode(codeLog)
		}
		if wxUser.Mobile == "" && wxUser.Email == "" {
			firstLogin = 1
		}
	}

	//获取登录token
	tokenItem, tokenErr := models.GetTokenByOpenId(openId)
	if tokenErr != nil && tokenErr.Error() != utils.ErrNoRow() {
		err = errors.New("登录失败，获取token失败:" + tokenErr.Error())
		return
	}
	fmt.Println("line 271 ", openId)
	if tokenItem == nil || (tokenErr != nil && tokenErr.Error() == utils.ErrNoRow()) {
		timeUnix := time.Now().Unix()
		timeUnixStr := strconv.FormatInt(timeUnix, 10)
		token = utils.MD5(openId) + utils.MD5(timeUnixStr)
		//新增session
		{
			session := new(models.CygxSession)
			session.OpenId = openId
			session.UserId = userId
			session.CreatedTime = time.Now()
			session.LastUpdatedTime = time.Now()
			session.ExpireTime = time.Now().AddDate(0, 3, 0)
			session.AccessToken = token
			sessionErr := models.AddSession(session)
			if err != nil {
				err = errors.New("登录失败，新增用户session信息失败:" + sessionErr.Error())
				return
			}
		}
	} else {
		token = tokenItem.AccessToken
	}
	fmt.Println("line 294 ", token)
	//新增登录日志
	{
		loginLog := new(models.WxUserLog)
		loginLog.UserId = userId
		loginLog.OpenId = openId
		loginLog.UnionId = unionId
		loginLog.CreateTime = time.Now()
		loginLog.Handle = "wechat_login_cygx"
		loginLog.Remark = token
		go models.AddWxUserLog(loginLog)
	}
	return
}

func UserLogin() {

}

//添加第三方用户（微信）记录
func AddUserRecord(openId, unionId, nickName, realName, province, city, country, headimgurl, sessionKey string, platform, sex, subscribe int) (userRecord *models.UserRecord, err error) {
	find, err := models.GetUserRecordByOpenId(openId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	if find != nil {
		userRecord = find
		return
	}
	userRecord = &models.UserRecord{
		OpenId:         openId,  //用户open_id
		UnionId:        unionId, //用户union_id
		Subscribe:      subscribe,
		NickName:       nickName,   //用户昵称，最大长度：32
		RealName:       realName,   //用户实际名称，最大长度：32
		Sex:            sex,        //普通用户性别，1为男性，2为女性
		Province:       province,   //普通用户个人资料填写的省份,最大长度：30
		City:           city,       //普通用户个人资料填写的城市,最大长度：30
		Country:        country,    //国家，如中国为CN,最大长度：30
		Headimgurl:     headimgurl, //用户第三方（微信）头像,最大长度：512
		CreateTime:     time.Now(), //创建时间，关系添加时间、用户授权时间
		CreatePlatform: platform,   //注册平台,1:日度点评公众号,2:管理后台，3：pc端网站,4:查研观向小程序；默认：1
		SessionKey:     sessionKey, //微信小程序会话密钥，最大长度：255
	}
	recordId, err := models.AddUserRecord(userRecord)
	if err != nil {
		return
	}
	userRecord.UserRecordId = int(recordId)
	return
}