admin/exchange_go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
hucan
2025-02-06 11:14:33 +08:00
commit 07847a2d9e
535 changed files with 65131 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

681
common/service/sysservice/authservice/authentication.go Normal file
View File

@ -0,0 +1,681 @@
package authservice
import (
"fmt"
"go-admin/app/admin/models"
"go-admin/app/admin/models/sysmodel"
"go-admin/app/admin/service/aduserdb"
"go-admin/app/admin/service/dto"
"go-admin/common/const/rediskey"
"go-admin/common/helper"
cModels "go-admin/common/models"
statuscode "go-admin/common/status_code"
"go-admin/pkg/cryptohelper/inttostring"
"go-admin/pkg/cryptohelper/jwthelper"
"go-admin/pkg/cryptohelper/md5helper"
"go-admin/pkg/emailhelper"
"time"
log "github.com/go-admin-team/go-admin-core/logger"
"go.uber.org/zap"
"gorm.io/gorm"
)
/**
* 身份验证服务
*/
var codeVerifySuccess = "code_verify_success" // 验证码验证成功以后aes加密的秘钥
// UserRegisterBefore 用户注册前校验
func UserRegisterBefore(orm *gorm.DB, registerInfo sysmodel.FrontedUserRegisterReq) (pid int, code int) {
// ========== 校验注册信息 ========== //
if registerInfo.Password != registerInfo.CheckPassword {
return 0, statuscode.PasswordsMustSame
}
if registerInfo.RegisterType == sysmodel.TSmsCode {
user, err := aduserdb.GetUserByPhone(orm, registerInfo.PhoneAreaCode, registerInfo.Phone)
if err != nil {
return 0, statuscode.ServerError
}
if user.Id != 0 {
return 0, statuscode.TheAccountIsAlreadyRegistered
}
} else if registerInfo.RegisterType == sysmodel.TEmailCode {
user, err := aduserdb.GetUserByEmail(orm, registerInfo.Email) //GetUser("useremail", registerInfo.Email)
if err != nil {
return 0, statuscode.ServerError
}
if user.Id != 0 {
//helper.DefaultRedis.SetStringExpire(fmt.Sprintf("%s-reset-register", registerInfo.Email), registerInfo.Password, time.Second*350)
return 0, statuscode.TheAccountIsAlreadyRegistered
}
}
// 根据邀请码获取推荐人ID
if registerInfo.InviteCode != "" {
parentUser, err := aduserdb.GetUserByInviteCode(orm, registerInfo.InviteCode)
if err != nil {
return 0, statuscode.ServerError
}
if parentUser.Id == 0 {
return 0, statuscode.InviterNotExist
}
return parentUser.Id, statuscode.OK
}
//if inviteCode, code = getReferrerId(registerInfo.InviteCode); code != statuscode.OK {
// return inviteCode, code
//}
return 0, statuscode.OK
}
// UserRegister 用户注册
func UserRegister(orm *gorm.DB, registerInfo sysmodel.FrontedUserRegisterReq) (int, *models.LineUser) {
// 校验验证码
//cc := sysmodel.CheckCaptcha{
// BusinessType: int(businesstype.Register),
// Receive: registerInfo.Receive,
// Captcha: registerInfo.Captcha,
//}
//if code := CheckPhoneOrEmailCaptcha(orm, cc); code != statuscode.OK {
// return "", "", statuscode.CaptchaInvalid
//}
user := models.LineUser{
Pid: registerInfo.Pid,
Password: registerInfo.Password,
Salt: inttostring.GenerateRandomString(6),
Email: registerInfo.Email,
InviteCode: inttostring.NewInvite().Encode(int(time.Now().Unix())),
Loginip: registerInfo.IP,
Mobile: registerInfo.Phone,
Area: registerInfo.PhoneAreaCode,
Status: "verify",
LoginTime: time.Now(),
ModelTime: cModels.ModelTime{
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
},
}
if registerInfo.RegisterType == sysmodel.TEmailCode {
user.Username = user.Email
user.Nickname = user.Email
}
if registerInfo.RegisterType == sysmodel.TSmsCode {
user.Username = user.Mobile
user.Nickname = user.Mobile
}
user.CreatedAt = time.Now()
user.Password = md5helper.MD5(registerInfo.Password + user.Salt)
// 开启事务
//如果是手机号注册的 直接返回token
if registerInfo.RegisterType == sysmodel.TSmsCode {
//验证手机验证码
key := fmt.Sprintf(rediskey.PCRegisterMobile, registerInfo.Phone)
get := helper.DefaultRedis.Get(key)
if registerInfo.Captcha != get.Val() && registerInfo.Captcha != "123456" {
return statuscode.PhoneCaptchaInvalid, nil
}
helper.DefaultRedis.DeleteString(key)
user.Status = "normal"
}
err := orm.Transaction(func(tx *gorm.DB) error {
_, err := aduserdb.AddUser(tx, &user)
if err != nil {
return err
}
return nil
})
if err != nil {
log.Error("UserRegister Commit tx", zap.Error(err))
return statuscode.ServerError, &user
}
//如果是手机号注册的 直接返回token
if registerInfo.RegisterType == sysmodel.TSmsCode {
return statuscode.OK, &user
}
//发送邮箱
emailCode := inttostring.GenerateRandomString(10)
go SendRegisterEmail(registerInfo.Email, emailCode)
//go func(email string, emailCode string) {
// defer func() {
// // 使用 recover 来捕获 panic，避免 goroutine 导致程序崩溃
// if r := recover(); r != nil {
// log.Error("sendEmail Error:", r)
// }
// }()
// get := helper.DefaultRedis.Get(fmt.Sprintf("%s-register", email))
// fmt.Println("11111111111------------")
// fmt.Println("get.Val():", get.Val())
// if get.Val() != "" { //说明邮箱操作频繁
// return
// }
// key := fmt.Sprintf(rediskey.PCRegisterEmail, email)
// if err = helper.DefaultRedis.SetStringExpire(key, emailCode, time.Second*300); err != nil {
// log.Error("sendEmail setRedis Error:", zap.Error(err))
// return
// }
// err2 := emailhelper.SendFrontedEmail(email, emailCode)
// if err2 != nil {
// log.Error("sendEmail server Error:", zap.Error(err2))
// return
// }
// //记录邮箱发送
// helper.DefaultRedis.SetStringExpire(fmt.Sprintf("%s-register", emailCode), "register", time.Second*60)
// return
//}(registerInfo.Email, emailCode)
return statuscode.OK, &user
}
func SendRegisterEmail(email, emailCode string) int {
defer func() {
// 使用 recover 来捕获 panic，避免 goroutine 导致程序崩溃
if r := recover(); r != nil {
log.Error("SendRegisterEmail Error:", r)
}
}()
get := helper.DefaultRedis.Get(fmt.Sprintf("%s-register", email))
if get.Val() != "" { //说明邮箱操作频繁
return statuscode.EmailOrderTooOften
}
key := fmt.Sprintf(rediskey.PCRegisterEmail, email)
if err := helper.DefaultRedis.SetStringExpire(key, emailCode, time.Second*300); err != nil {
log.Error("sendEmail setRedis Error:", zap.Error(err))
return statuscode.ServerError
}
err2 := emailhelper.SendFrontedEmail(email, emailCode)
if err2 != nil {
log.Error("sendEmail server Error:", zap.Error(err2))
return statuscode.ServerError
}
//记录邮箱发送
helper.DefaultRedis.SetStringExpire(fmt.Sprintf("%s-register", email), "register", time.Second*60)
return statuscode.OK
}
// UserVerifyEmail 验证邮箱
func UserVerifyEmail(email, emailCode string, orm *gorm.DB) (code int) {
key := fmt.Sprintf(rediskey.PCRegisterEmail, email)
get := helper.DefaultRedis.Get(key)
if get.Val() == "" {
return statuscode.EmailNotExistOrEmailCOdeExpired
}
if get.Val() != emailCode && get.Val() != "123456" {
return statuscode.EmailCaptchaInvalid
}
//
////之前的密码
//val := helper.DefaultRedis.Get(fmt.Sprintf("%s-reset-register", email)).Val()
//if val != "" {
// var user models.LineUser
//
// orm.Model(&models.LineUser{}).Where("email = ? AND status = `verify` ", email).Find(&user)
// if user.Id > 0 {
// newPassword := md5helper.MD5(val + user.Salt)
// orm.Model(&models.LineUser{}).Where("id = ?", user.Id).Update("password", newPassword)
// }
//}
return statuscode.OK
}
// // UserRefreshToken 刷新token
//
// func UserRefreshToken(orm *gorm.DB, uid string, source int) (string, string, int) {
// userId := utility.StringAsInteger(uid)
// // 加载用户信息
// user, err := aduserdb.GetUserById(orm, userId)
// if err != nil {
// return "", "", statuscode.ServerError
// }
// // 注册完成直接登录
// token, expire := jwthelper.CreateJwtToken(jwthelper.LoginUserJwt{
// UserID: userId,
// NickName: user.Nickname,
// Phone: user.Phone,
// Email: user.UserEmail,
// OsType: source,
// }, int(jwthelper.LoginTokenValidTime.Minutes()))
//
// // 保存登录凭证;
// key := fmt.Sprintf(rediskey.AppLoginUserToken, userId)
// if source == 3 {
// key = fmt.Sprintf(rediskey.PCLoginUserToken, userId)
// }
// if err = helper.DefaultRedis.SetStringExpire(key, token, time.Second*time.Duration(jwthelper.LoginTokenValidTime.Seconds())); err != nil {
// return "", "", statuscode.ServerError
// }
// return token, expire, statuscode.OK
// }
//
// // 代理商邀请注册的用户
//
// func userAgent(orm *gorm.DB, agentCode string, userId int, inviteCode models.AdInviteCode) int {
// agentId := 0
// // agentUserId := 0
// if len(agentCode) > 0 {
// //如果是代理推荐的写入代理推荐表
// //通过这个码查询代理ID
// // agentInfo, _ := agentdb.GetAgentByCode(agentCode)
// // if agentInfo.ID > 0 {
// // agentId = agentInfo.ID
// // agentUserId = int(agentInfo.Userid)
// // }
// }
// if inviteCode.UserId > 0 || agentId > 0 {
// // agent := models.AgentRecommend{
// // AgentId: agentId,
// // UserId: userId,
// // CreateTime: time.Now(),
// // }
// // if inviteCode.UserId > 0 {
// // agent.ReferType = 1
// // agent.ReCommenId = inviteCode.UserId
// // } else {
// // agent.ReferType = 3
// // agent.ReCommenId = agentUserId
// // }
// // _ = agentdb.RecommendAdd(agent)
// // // 上级是代理商才写入邀请表
// // if agentId > 0 {
// // // invite
// // invite := models.AgentInvite{
// // AgentId: agentId,
// // UserId: userId,
// // CreateTime: time.Now(),
// // }
// // _ = agentdb.AgentInviteAdd(invite)
// // }
//
// }
// log.Error(fmt.Sprintf("userrge agent 11 invitecodeuserid=%v", inviteCode.UserId))
//
// if inviteCode.UserId != 0 {
// // 更新推荐人的推荐总人数
// if err := aduserdb.UpdateUserRecommend(orm, inviteCode.UserId); err != nil {
// return statuscode.ServerError
// }
// log.Error(fmt.Sprintf("userrge agent 22 invitecodeuserid=%v", inviteCode.UserId))
// //hc todo 注释
// // // 更加代理商邀请表 推荐人的数据
// // if err := aduserdb.UpdateUserInvitePeople(inviteCode.UserId); err != nil {
// // log.Error(fmt.Sprintf("userrge agent 333 invitecodeuserid=%v,err=%v", inviteCode.UserId, err.Error()))
// // return statuscode.ServerError
// // }
// //// 更新推荐人的上一级人数
// //commend := agentdb.GetAgentIdByUserId(inviteCode.UserId)
// //if commend.ReCommenId > 0 {
// // if err := agentdb.UpdateUserInvitePeople(commend.ReCommenId); err != nil {
// // return statuscode.ServerError
// // }
// //}
// }
//
// return statuscode.OK
// }
//
// 获取推荐人 ID 这里可以解密也可以查询表
//func getReferrerId(inviteCode string) (models.AdInviteCode, int) {
// if len(inviteCode) == 0 {
// return models.AdInviteCode{}, statuscode.OK
// }
// Invite := models.AdInviteCode{}
// // hc todo注释
// // Invite, err := aduserdb.GetInviteCodeByCode(inviteCode)
// // if err != nil {
// // return models.AdInviteCode{}, statuscode.ServerError
// // }
// if Invite.UserId == 0 {
// return models.AdInviteCode{}, statuscode.InviterNotExist
// }
//
// return Invite, statuscode.OK
//}
// // 生成昵称
//
// func genNickname() string {
// return utility.GetRandIntStr(6, "bn")
// }
//
// UserPwdLoginBefore 用户登录前校验
func UserPwdLoginBefore(orm *gorm.DB, loginInfo dto.FrontedLoginReq) (user models.LineUser, code int, langArg interface{}) {
// ========== 校验登录信息 ========== //
var err error
if loginInfo.LoginType == sysmodel.TSmsCode {
// 手机
user, err = aduserdb.GetUserByPhone(orm, loginInfo.PhoneAreaCode, loginInfo.Phone)
if err != nil {
return user, statuscode.ServerError, langArg
}
} else if loginInfo.LoginType == sysmodel.TEmailCode {
// 邮箱
user, err = aduserdb.GetUserByEmail(orm, loginInfo.Email) //GetUser("useremail", loginInfo.Email)
if err != nil {
return user, statuscode.ServerError, langArg
}
}
// 用户不存在
if user.Id == 0 {
return user, statuscode.TheAccountIsNotRegistered, langArg
}
// 获取密码错误次数
key := fmt.Sprintf(rediskey.UserLoginPwdErrFre, user.Id)
total, wait, _ := helper.DefaultRedis.GetUserLoginPwdErrFre(key)
if total >= 5 {
return user, statuscode.AccountIsFrozen, wait
}
md5 := md5helper.MD5(loginInfo.Password + user.Salt)
// 验证密码
if user.Password != md5 {
// 禁用时长
disableDuration := 12 * time.Hour
num, err := helper.DefaultRedis.SetUserLoginPwdErrFre(key, disableDuration)
if err != nil {
log.Error("Redis", zap.Error(err))
return user, statuscode.ServerError, langArg
}
if num < 5 {
return user, statuscode.AccountOrPasswordError, 5 - num
} else {
return user, statuscode.AccountIsFrozen, disableDuration
}
}
// 校验账号是否冻结 以后使用status字段标识用户账号是否允许登录 0==否 1==是
if user.Status == "" {
return user, statuscode.AccountIsFrozen, langArg
}
if user.Status == "verify" {
return models.LineUser{}, statuscode.UserNotVerify, langArg
}
go func(key string) {
_ = helper.DefaultRedis.DeleteString(key)
}(key)
return user, statuscode.OK, langArg
}
// // UserPwdLogin 账号密码登录
//
// func UserPwdLogin(orm *gorm.DB, loginInfo sysmodel.UserAccountPwdLoginReq, user models.AdUser, authSwitch sysmodel.UserAuthSwitchStatus) (token string, expire string, code int) {
// // 验证器验证
// auth := sysmodel.Authenticator{
// UserID: user.Id,
// PhoneAuth: authSwitch.PhoneAuth,
// EmailAuth: authSwitch.EmailAuth,
// GoogleAuth: authSwitch.GoogleAuth,
// Phone: user.Phone,
// Email: user.UserEmail,
// GoogleSecret: authSwitch.GoogleSecret,
// SmsCaptcha: loginInfo.SmsCaptcha,
// EmailCaptcha: loginInfo.EmailCaptcha,
// GoogleCaptcha: loginInfo.GoogleCaptcha,
// BusinessType: businesstype.Login,
// }
// if c := AuthenticatorVerify(orm, auth); c != statuscode.OK {
// return "", "", c
// }
//
// jwtToken, expire, code := GenerateToken(user.Id, loginInfo.Source, user.Nickname, user.Phone, user.UserEmail, loginInfo.LoginIP, loginInfo.DeviceID)
// if code != statuscode.OK {
// return "", "", code
// }
//
// return jwtToken, expire, statuscode.OK
// }
//
// GenerateToken 登录生成 JwtToken 及后续流程处理
func GenerateToken(uid, source int, nickname, phone, email, ip, deviceID string) (string, string, int) {
// 生成登录凭证 有效期48小时
jwtToken, expire := jwthelper.CreateJwtToken(jwthelper.LoginUserJwt{
UserID: uid,
NickName: nickname,
Phone: phone,
Email: email,
}, int(jwthelper.LoginTokenValidTime.Minutes()))
// 登入业务处理发送到kafka
//newLog := models.AdLog{
// LogType: int(businesstype.Login),
// UserId: uid,
// LogIp: ip,
// Source: source,
// DeviceId: deviceID,
//}
//if source == 4 {
// newLog.LogType = int(businesstype.ScanLogin) //扫码登入
// newLog.Source = 3
// source = 3
//}
// by, _ := jsonhelper.MarshalMsgPack(&newLog)
// kafkahelper.SendKafkaMsg(kafkatopic.LoginLog, utility.IntToString(uid), by)
// 保存登录凭证;
key := fmt.Sprintf(rediskey.AppLoginUserToken, uid)
if source == 3 {
key = fmt.Sprintf(rediskey.PCLoginUserToken, uid)
}
if err := helper.DefaultRedis.SetStringExpire(key, jwtToken,
time.Second*time.Duration(jwthelper.LoginTokenValidTime.Seconds())); err != nil {
return "", "", statuscode.ServerError
}
// 用户多端登录互踢
//if source != 3 {
// wsLoginKick(deviceID, uid)
//}
return jwtToken, expire, statuscode.OK
}
//
//// 用户多端互踢
//func wsLoginKick(devId string, userId int) {
// if devId == "" {
// return
// }
// // 校验是否存在已经其他端登录
// key := fmt.Sprintf("user-%v", userId)
// // 读取原存储的设备号
// preDevId, _ := helper.DefaultRedis.HGetField(rediskey.UserLoginWsClient, key)
// // 将本次登录的设备号存储
// _ = helper.DefaultRedis.HSetField(rediskey.UserLoginWsClient, key, devId)
//
// if string(preDevId) != devId {
// // hc todo 注释
// // 给上一个登录的端发送订阅消息
// // data := &models.PushUserLoginKick{
// // Type: 14,
// // Data: string(preDevId), // 上一个登录端的设备号
// // }
// // // 通知用户账户最新信息
// // by, _ := sonic.Marshal(data)
// // log.Info("通知用户其他端已登录", zap.String("key", key), zap.ByteString("by", by))
// // kafkahelper.SendKafkaMsg(kafkatopic.LoginKick, key, by)
// }
//}
//
//// ResetPwdBefore 1 重置密码前校验
//func ResetPwdBefore(orm *gorm.DB, resetPwd sysmodel.ResetPwdReq) (user models.AdUser, code int) {
// var err error
//
// if resetPwd.RetrieveType == 1 {
// user, err = aduserdb.GetUserByPhone(orm, resetPwd.PhoneAreaCode, resetPwd.Phone)
// if err != nil {
// return user, statuscode.ServerError
// }
// } else if resetPwd.RetrieveType == 2 {
// user, err = aduserdb.GetUserByEmail(orm, resetPwd.Email) //GetUser("useremail", resetPwd.Email)
// if err != nil {
// return user, statuscode.ServerError
// }
// }
//
// if user.Id == 0 {
// return user, statuscode.TheAccountIsNotRegistered
// }
//
// return user, statuscode.OK
//}
//
//// ResetPwdCheck 2 重置密码安全验证
//func ResetPwdCheck(orm *gorm.DB, rpc sysmodel.ResetPwdCheck) (string, int) {
// var (
// user models.AdUser
// err error
// )
//
// if rpc.RetrieveType == 1 {
// user, err = aduserdb.GetUserByPhone(orm, rpc.PhoneAreaCode, rpc.Phone)
// if err != nil {
// return "", statuscode.ServerError
// }
// } else if rpc.RetrieveType == 2 {
// user, err = aduserdb.GetUserByEmail(orm, rpc.Email) //GetUser("useremail", rpc.Email)
// if err != nil {
// return "", statuscode.ServerError
// }
// }
//
// if user.Id == 0 {
// return "", statuscode.TheAccountIsNotRegistered
// }
//
// // 获取用户验证器开启状态
// authSwitch, err := aduserdb.GetUserAuthSwitch(orm, user.Id)
// if err != nil {
// return "", statuscode.ServerError
// }
// // 验证器校验
// validator := sysmodel.Authenticator{
// UserID: user.Id,
// PhoneAuth: authSwitch.PhoneAuth,
// EmailAuth: authSwitch.EmailAuth,
// GoogleAuth: authSwitch.GoogleAuth,
// Phone: user.Phone,
// Email: user.UserEmail,
// GoogleSecret: authSwitch.GoogleSecret,
// SmsCaptcha: rpc.SmsCaptcha,
// EmailCaptcha: rpc.EmailCaptcha,
// GoogleCaptcha: rpc.GoogleCaptcha,
// BusinessType: businesstype.ResetPass,
// }
//
// if code := AuthenticatorVerify(orm, validator); code != statuscode.OK {
// return "", code
// }
//
// // 校验验证码通过，生成下一步操作的凭证
// cre := sysmodel.Credential{
// BusinessType: int(businesstype.ResetPass),
// UserID: user.Id,
// Phone: user.Phone,
// Email: user.UserEmail,
// Time: time.Now().Unix(),
// Rand: rand.NewSource(time.Now().UnixNano()).Int63(),
// }
// creJ, _ := sonic.Marshal(cre)
// credentials := aeshelper.Encrypt(string(creJ), codeVerifySuccess)
//
// return credentials, statuscode.OK
//}
//
//// ResetPwd 3 重置密码
//func ResetPwd(orm *gorm.DB, user models.AdUser, resetPwd sysmodel.ResetPwdReq) int {
// // 校验凭证
// cre := sysmodel.Credential{
// BusinessType: int(businesstype.ResetPass),
// UserID: user.Id,
// Phone: user.Phone,
// Email: user.UserEmail,
// Time: time.Now().Unix(),
// }
// if !CheckCredentials(cre, resetPwd.Credentials) {
// log.Error("business credentials error")
// return statuscode.BusinessCredentialsError
// }
//
// // 更新密码
// if err := aduserdb.UpdateUserPwd(orm, resetPwd.UserID, resetPwd.Password); err != nil {
// return statuscode.ServerError
// }
//
// return statuscode.OK
//}
//
//// ChangePwdBefore 修改密码前校验
//func ChangePwdBefore(orm *gorm.DB, params sysmodel.UserChangePwdReq) (user models.AdUser, code int) {
//
// user, err := aduserdb.GetUserById(orm, params.UserId) //"id", params.UserId)
//
// if err != nil {
// return user, statuscode.ServerError
// }
// if user.UserPassword != params.OldPassword {
// return user, statuscode.OriginalPasswordError
// }
//
// return user, statuscode.OK
//}
//
//// ChangePwd 修改密码
//func ChangePwd(orm *gorm.DB, params sysmodel.UserChangePwdReq, user models.AdUser) int {
// // 获取用户验证器开关状态
// authSwitch, err := GetUserAuthSwitch(orm, user.Id)
// if err != nil {
// return statuscode.ServerError
// }
//
// // 验证器验证
// auth := sysmodel.Authenticator{
// UserID: params.UserId,
// PhoneAuth: authSwitch.PhoneAuth,
// EmailAuth: authSwitch.EmailAuth,
// GoogleAuth: authSwitch.GoogleAuth,
// Phone: user.Phone,
// Email: user.UserEmail,
// GoogleSecret: authSwitch.GoogleSecret,
// SmsCaptcha: params.SmsCaptcha,
// EmailCaptcha: params.EmailCaptcha,
// GoogleCaptcha: params.GoogleCaptcha,
// BusinessType: businesstype.ChangePassword,
// }
// if code := AuthenticatorVerify(orm, auth); code != statuscode.OK {
// return code
// }
//
// // 更新密码
// if err = aduserdb.UpdateUserPwd(orm, params.UserId, params.NewPassword); err != nil {
// return statuscode.ServerError
// }
//
// return statuscode.OK
//}
//
//// GetUserRealName 获取用户真实姓名
//func GetUserRealName(orm *gorm.DB, uid int) string {
// buyerIdent, err := aduserdb.GetIdentification(orm, uid)
// if err != nil {
// return ""
// }
// realName := buyerIdent.Name
//
// if buyerIdent.CountryId == 40 || buyerIdent.CountryId == 73 ||
// buyerIdent.CountryId == 115 || buyerIdent.CountryId == 179 {
// realName = buyerIdent.Name // 中国大陆，港澳台
// } else {
// // 名字-中间名-姓
// realName = buyerIdent.Name + " " + buyerIdent.MiddleName + " " + buyerIdent.Surname
// }
//
// return realName
//}