fonchain-artistinfo/cmd/internal/dao/artistInfo_user.go

package dao

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"

	_ "dubbo.apache.org/dubbo-go/v3/imports"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	"github.com/fonchain/fonchain-artistinfo/pb/account"
	"github.com/fonchain/fonchain-artistinfo/pb/artist"
	"github.com/fonchain/fonchain-artistinfo/pb/artistInfoUser"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"
	"github.com/fonchain/fonchain-artistinfo/pkg/m"
	"github.com/fonchain/fonchain-artistinfo/pkg/service"
	"github.com/fonchain/fonchain-artistinfo/pkg/util/stime"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

func RegisterUser(req *artistInfoUser.RegisterUserRequest) (rep *artistInfoUser.RegisterUserRespond, err error) {
	var user = model.User{
		MgmtAccId:     req.MgmtAccId,
		TelNum:        req.TelNum,
		MgmtArtistId:  req.MgmtArtistId,
		MgmtArtistUid: req.MgmtArtistUid,
		InviteCode:    req.UserInviteCode,
		Account:       req.Account,
	}
	zap.L().Debug(fmt.Sprintf("RegisterUser--user: %+v", user))
	if err = db.DB.Create(&user).Error; err != nil {
		zap.L().Error("register user err", zap.Error(err))
		err = errors.New(m.CREATE_ERROR)
		return nil, err
	}
	return
}

func CreateUserInfo(req *artistInfoUser.CreateUserInfoRequest) (rep *artistInfoUser.CreateUserInfoRespond, err error) {
	// var user model.User
	// //找到用户
	// fmt.Println("req.Id:", req.Id)
	// fmt.Println("第三处")
	// err = db.DB.Where("id = ?", req.Id).First(&user).Error
	// if err != nil {
	// 	fmt.Println("第四处")
	// 	fmt.Println(err.Error())
	// 	zap.L().Error("CreateUserInfo err", zap.Error(err))
	// 	err = errors.New(m.ERROR_SELECT)
	// 	return nil, err
	// }
	// fmt.Println(11)
	// var realNameFind model.RealName
	// err = db.DB.Where("id_num = ?", req.IdCard).First(&realNameFind).Error
	// if err == nil {
	// 	fmt.Println("第五处")
	// 	fmt.Println(12)
	// 	if realNameFind.ID != 0 {
	// 		fmt.Println("第六处")
	// 		zap.L().Error("register user err", zap.Error(err))
	// 		err = errors.New("此身份证已实名认证")
	// 		return nil, err
	// 	}
	// }
	// fmt.Println("第四处")
	// fmt.Println(12)
	// var realname = model.RealName{
	// 	Name:        req.RealName,
	// 	IdNum:       req.IdCard,
	// 	TelNum:      req.TelNum,
	// 	IdCardFront: req.IdCardFront,
	// 	IdCardBack:  req.IdCardBack,
	// }
	// err = db.DB.Save(&realname).Error
	// if err != nil {
	// 	fmt.Println("第九处")
	// 	zap.L().Error("CreateUserInfo err", zap.Error(err))
	// 	err = errors.New(m.ERROR_SELECT)
	// 	return nil, err
	// }

	// fmt.Println(13)
	// err = db.DB.Where("id_num=?", realname.IdNum).First(&realname).Error
	// if err != nil {
	// 	zap.L().Error("CreateUserInfo err", zap.Error(err))
	// 	err = errors.New(m.ERROR_SELECT)
	// 	return nil, err
	// }

	// fmt.Println(14)
	// user.ID = req.Id
	// user.TelNum = req.TelNum
	// user.InviteCode = req.InvitedCode
	// user.IsRealName = 1
	// var invite model.Invite

	// err = db.DB.Where("user_id = ?", user.ID).First(&invite).Error
	// if err != nil {
	// 	logging.Info(err.Error())
	// 	if err.Error() == "record not found" {

	// 	} else {
	// 		zap.L().Error("CreateUserInfo err", zap.Error(err))
	// 		err = errors.New(m.ERROR_SELECT)
	// 		return nil, err
	// 	}
	// }
	// if invite.ID == 0 {
	// 	InvitedAccId, err := CheckInvitedCodes(req.InvitedCode)
	// 	if err == nil {
	// 		var invite InviteService
	// 		invite.UserId = uint(req.Id)
	// 		invite.InvitedId = InvitedId
	// 		Createinvite(invite)
	// 	}
	// }

	// fmt.Printf("%+v\n", user)
	// user.ID = req.Id
	// err = db.DB.Save(&user).Error
	// if err != nil {
	// 	zap.L().Error("CreateUserInfo err", zap.Error(err))
	// 	err = errors.New(m.ERROR_SELECT)
	// 	return nil, err
	// }

	return

}

type InvitedCodeService struct {
	InvitedCode string `form:"invitedCode" json:"invitedCode"`
}
type InviteService struct {
	Id        uint `json:"id"`
	UserId    uint `form:"userId" json:"userId"`
	InvitedId uint `form:"invitedId" json:"invitedId"`
}

// func Createinvite(service InviteService) {
// 	var invite model.Invite
// 	invite.UserId = int32(service.UserId)
// 	invite.InvitedId = int32(service.InvitedId)
// 	db.DB.Create(&invite)
// }

func CheckInvitedCodes(invitedCode string) (uint, error) {
	// 变更为通过账号服务验证邀请码
	var user model.User
	//找到用户
	if err := db.DB.Where("BINARY invited_code =?", invitedCode).Find(&user).Error; err != nil {
		return 0, err
	}
	if user.ID == 0 {
		return 0, errors.New("邀请码无效")
	}
	return uint(user.ID), nil
	// todo 无法通过账号服务获取邀请码信息
	// if res, err := service.AccountProvider.ListByIDs(context.Background(), &account.ListByIDsRequest{
	// 	Page:           1,
	// 	PageSize:       1,
	// 	InvitationCode: []string{invitedCode},
	// }); err != nil && res != nil && len(res.Data) > 0 {
	// 	return uint(res.Data[0].ID), nil
	// }
	// return 0, errors.New("邀请码无效")
}

func GetUser(req *artistInfoUser.GetUserRequest) (rep *artistInfoUser.GetUserRespond, err error) {
	rep = &artistInfoUser.GetUserRespond{}
	// service := &artist.UserUpdateInfoService{}
	var user model.User
	if err = db.DB.Where("tel_num = ?", req.TelNum).First(&user).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		if err == gorm.ErrRecordNotFound {
			err = errors.New("没有找到数据")
		} else {
			err = errors.New(m.ERROR_SELECT)
		}
		return nil, err
	}
	// rep.
	fmt.Println(user)
	rep.Id = user.ID
	rep.MgmtAccId = user.MgmtAccId
	rep.MgmtArtistUid = user.MgmtArtistUid
	rep.MgmtArtistId = user.MgmtArtistId
	rep.TelNum = user.TelNum
	rep.FddState = user.FddState
	rep.IsRealName = user.IsRealName
	//rep.Ruler = user.Ruler
	// service.QrCodeImg = fmt.Sprintf("https://cdn.fontree.cn/artistmgmt/static/qrcode/%v.png", user.InvitedCode)

	// service.QrCodeImgDownload = fmt.Sprintf("https://cdn.fontree.cn/artistmgmt/static/qrcode/%v-2.png", user.InvitedCode)
	// rep.Data = service
	return rep, nil
}

func GetUserById(req *artistInfoUser.GetUserByIdRequest) (rep *artistInfoUser.GetUserByIdRespond, err error) {
	rep = &artistInfoUser.GetUserByIdRespond{}
	fmt.Println("id:", req.Id)
	fmt.Println("123")
	zap.L().Info("!!!!")
	fmt.Println("456")
	// service := &artist.UserUpdateInfoService{}
	var user model.User
	fmt.Println("666")
	if err = db.DB.Where("id = ?", req.Id).First(&user).Error; err != nil {
		zap.L().Info("!!!!3")
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	fmt.Printf("%+v\n", user)
	fmt.Println("6666")
	zap.L().Info("!!!!5")
	// rep.
	fmt.Println("777")
	rep.Id = user.ID
	rep.MgmtAccId = user.MgmtAccId
	rep.MgmtArtistUid = user.MgmtArtistUid
	rep.MgmtArtistId = user.MgmtArtistId
	rep.TelNum = user.TelNum
	rep.FddState = user.FddState
	rep.IsRealName = user.IsRealName
	//rep.Ruler = user.Ruler
	return rep, nil
}

func FinishVerify(req *artistInfoUser.FinishVerifyRequest) (rep *artistInfoUser.FinishVerifyRespond, err error) {
	var user model.User
	user.ID = req.Id
	if err = db.DB.Model(&user).Update("isfdd", 2).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	return rep, nil
}

func ArtistSupplyList(req *artistInfoUser.ArtistSupplyListRequest) (rep *artistInfoUser.ArtistSupplyListRespond, err error) {
	var artistList = make([]artistInfoUser.ArtistArtworkSupplyListResponseData, 0)
	var args []interface{}
	sql := `select cc.* from (SELECT a.id,a.name,a.pen_name,a.is_import,a.tel_num,a.sex,a.age,b.id_num,a.invited_code,a.certificate_num,a.con_address,b.idcard_front,b.idcard_back,a.photo,a.video,a.created_at,a.updated_at,a.is_lock,a.certificate_img,min(d.created_at) as dd  from user a inner join real_name b on a.real_name_id = b.id left join bank c on  a.id = c.user_id left join supply_info d on a.id = d.user_id where (d.types = 1 or d.types = 4 or d.types = 2 or d.types = 3 or d.types =6) and a.is_real_name = true   `
	sqlWhere := ` `
	sqlGroup := ` group by a.id order by min(d.created_at) desc ) cc inner join supply_info f where dd >0 and dd = f.created_at and cc.id = f.user_id group by cc.id,dd `
	var count int64
	tx := db.DB.Raw("select count(*) from (" + sql + sqlWhere + sqlGroup + ") cc").Scan(&count)
	if tx.Error != nil {
		zap.L().Error("get user info err", zap.Error(tx.Error))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.Count = count
	var sqlLimit = " limit ?,? "
	args = append(args, (req.Page-1)*req.PageSize)
	args = append(args, req.PageSize)
	err = db.DB.Raw(sql + sqlWhere + sqlGroup + sqlLimit).Scan(&artistList).Error
	if err != nil {
		zap.L().Error("get user info err", zap.Error(tx.Error))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	for _, v := range artistList {
		rep.Data = append(rep.Data, &v)
	}
	return rep, nil
}

func UserLock(req *artistInfoUser.UserLockRequest) (rep *artistInfoUser.UserLockRespond, err error) {
	rep = &artistInfoUser.UserLockRespond{}
	var tx = db.DB.Begin()
	tx_user := tx.Model(model.User{})
	switch {
	case req.Id != 0:
		tx_user = tx_user.Where("id = ?", req.Id)
	case req.AccId != 0:
		tx_user = tx_user.Where("mgmt_acc_id = ?", req.AccId)
	case req.ArtistUid != "":
		tx_user = tx_user.Where("mgmt_artist_uid = ?", req.ArtistUid)
	default:
		err = errors.New(m.ERROR_DATA_NOT_EXISTS)
		zap.L().Error("get user info err", zap.Error(err))
		return
	}
	var now string
	if req.IsLock {
		now = stime.TimeToString(time.Now(), stime.Format_Normal_YMDhms)
	}
	var thisUser model.User
	if err = tx_user.Find(&thisUser).Error; err != nil {
		return nil, err
	}
	if err = tx_user.Update("is_lock", req.IsLock).Error; err != nil {
		zap.L().Error("get user info err 11", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.LockTime = now
	if !req.IsLock {
		fmt.Println("进入解锁流程")
		// 如果当前锁定状态下没有任何数据变动，则报错
		if hasChanged, _ := WhetherAnyChangedAfterLocked(thisUser.MgmtArtistUid); !hasChanged {
			tx.Rollback()
			err = errors.New("此用户在锁定后未作任何修改，无法解锁")
			return
		}
		// 解锁时与另外4个模块联动
		if err = tx.Model(model.ArtworkLockRecord{}).Where("artist_uid = ? AND status =2", thisUser.MgmtArtistUid).Update("status", 3).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
		if err = tx.Model(model.ArtshowArtistSupplement{}).Where("artist_uid = ? AND status =2", thisUser.MgmtArtistUid).Update("status", 3).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
		if err = tx.Model(model.ArtshowArtistIndex{}).Where("artist_uid = ? AND status =2", thisUser.MgmtArtistUid).Update("status", 3).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
		if err = tx.Model(model.ArtshowVideoRecord{}).Where("artist_uid = ? AND status =2", thisUser.MgmtArtistUid).Update("status", 3).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
		// 与画家宝的合同表进行联动
		if err = tx.Model(model.Contract{}).Where("artist_uid = ? AND status =2", thisUser.MgmtArtistUid).Update("status", 3).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
	} else {
		fmt.Println("else 更新最新上锁时间")
		if err = tx.Model(model.User{}).Where("mgmt_artist_uid = ?", thisUser.MgmtArtistUid).Update("latest_lock_time", now).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
		fmt.Println("更新结束")
	}
	tx.Commit()

	return rep, nil
}

// 简单判断锁定后数据是否有新增
func WhetherAnyChangedAfterLocked(artistUid string) (changed bool, err error) {
	//查询锁定时间
	var lockTime string
	if err = db.DB.Model(model.User{}).Where("mgmt_artist_uid = ?", artistUid).Pluck("latest_lock_time", &lockTime).Error; err != nil {
		return
	}
	//如果画作更新时间大于锁定时间,直接返回true
	var artworks []model.ArtworkLockRecord
	db.DB.Where("artist_uid = ? AND lock_time = ? ", artistUid, lockTime).Find(&artworks)
	var lockTimeT, _ = stime.StringToTime(lockTime)
	for _, a := range artworks {
		if a.UpdatedAt.After(*lockTimeT) {
			changed = true
			return
		}
	}
	//如果补充信息有新增则直接返回true
	var sql = `
SELECT 
	u.mgmt_artist_uid
	,u.latest_lock_time
	,(SELECT COUNT(1) FROM artshow_artist_index WHERE artist_uid = '{{artistUid}}' AND lock_time = '{{lockTime}}'  AND deleted_at = 0) as artist_index_count
	,(SELECT COUNT(1) FROM artshow_artist_supplement WHERE artist_uid = '{{artistUid}}' AND lock_time = '{{lockTime}}'  AND deleted_at = 0) as artist_supplement_count
	,(SELECT COUNT(1) FROM artshow_video_record WHERE artist_uid = '{{artistUid}}' AND lock_time = '{{lockTime}}'  AND deleted_at = 0) as video_count
	,(SELECT COUNT(1) FROM contract WHERE artist_uid = '{{artistUid}}' AND lock_time = '{{lockTime}}' AND deleted_at = 0) as contract_count
FROM sys_user u
WHERE u.mgmt_artist_uid ='{{artistUid}}' AND u.deleted_at = 0
`
	sql = strings.Replace(sql, "{{artistUid}}", artistUid, -1)
	sql = strings.Replace(sql, "{{lockTime}}", lockTime, -1)
	var data struct {
		MgmtArtistUid         string `gorm:"column:mgmt_artist_uid"`
		LatestLockTime        string `gorm:"column:latest_lock_time"`
		ArtistIndexCount      int    `gorm:"column:artist_index_count"`
		ArtistSupplementCount int    `gorm:"column:artist_supplement_count"`
		VideoCount            int    `gorm:"column:video_count"`
		ContractCount         int    `gorm:"column:contract_count"`
	}
	if err = db.DB.Debug().Raw(sql).Find(&data).Error; err != nil {
		return
	}
	if data.ArtistIndexCount > 0 || data.ArtistSupplementCount > 0 || data.VideoCount > 0 || data.ContractCount > 0 {
		return true, nil
	}
	return false, nil
}

func CheckInvitedCode(req *artistInfoUser.CheckInvitedCodeRequest) (rep *artistInfoUser.GetUserRespond, err error) {
	rep = &artistInfoUser.GetUserRespond{}
	// service := &artist.UserUpdateInfoService{}
	var user model.User
	if err = db.DB.First(&user, "BINARY invited_code = ?", req.InvitedCode).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		return nil, err
	}
	// rep.
	rep.Id = user.ID
	rep.MgmtAccId = user.MgmtAccId
	rep.MgmtArtistUid = user.MgmtArtistUid
	rep.TelNum = user.TelNum
	rep.FddState = user.FddState
	rep.IsRealName = user.IsRealName
	//rep.Ruler = user.Ruler
	// service.QrCodeImg = fmt.Sprintf("https://cdn.fontree.cn/artistmgmt/static/qrcode/%v.png", user.InvitedCode)

	// service.QrCodeImgDownload = fmt.Sprintf("https://cdn.fontree.cn/artistmgmt/static/qrcode/%v-2.png", user.InvitedCode)
	// rep.Data = service
	return rep, nil
}

func UnFinishList(req *artistInfoUser.UnFinishListRequest) (rep *artistInfoUser.UnFinishListRespond, err error) {
	rep = &artistInfoUser.UnFinishListRespond{}
	var user model.User
	if err := db.DB.Where("mgmt_acc_id = ? ", req.AccId).First(&user).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	var accountStatusList int64
	if user.IsRealName == 0 {
		accountStatusList = 1
		return
	}
	if user.MgmtArtistUid == "" {
		accountStatusList = 2
		return
	}

	//艺术家补充信息完成度统计
	//var unfinishArtistSupplementCount int64
	//if err = db.DB.Model(model.ArtshowArtistSupplement{}).Where("status = 2 AND artist_uid = ? AND audit_status in (3,5)", user.MgmtArtistUid).Count(&unfinishArtistSupplementCount).Error; err != nil {
	//	zap.L().Error("艺术家补充信息统计错误")
	//	return nil, err
	//}
	var viewData = struct {
		UnfinishedArtworkBaseCount       int64 `gorm:"column:unfinished_artwork_base_count;comment:未完成的画作基本信息数量"`
		UnfinishedArtworkSupplementCount int64 `gorm:"column:unfinished_artwork_supplement_count;comment:未完成的画作补充信息数量"`
		UnfinishedArtistSupplementCount  int64 `gorm:"column:unfinished_artist_supplement_count;comment:未完成的画家补充信息数量"`
		UnfinishedArtistVideoRecordCount int64 `gorm:"column:unfinished_artist_video_record_count;comment:未完成的画展视频统计"`
		UnfinishedArtistIndexCount       int64 `gorm:"column:unfinished_artist_index_count;comment:未完成的画家指数"`
		// UnfinishedContractCount          int64 `gorm:"column:unfinished_contract_count;comment:未签署合同统计;"`
	}{}
	// 查询未完成的画展相关操作统计
	var sql = fmt.Sprintf(`
SELECT 
	COUNT(1) unfinished_artwork_base_count ,
	(SELECT COUNT(1) FROM artwork_lock_record WHERE artist_uid = ? AND deleted_at = 0 AND STATUS =2 AND supplement_audit_status IN (3,5) )unfinished_artwork_supplement_count,
	(SELECT COUNT(1) FROM artshow_artist_supplement WHERE artist_uid = ? AND  deleted_at = 0 AND STATUS =2 AND audit_status  IN (3,5) ) unfinished_artist_supplement_count,
	(SELECT COUNT(1) FROM artshow_video_record WHERE artist_uid = ? AND deleted_at = 0 AND STATUS =2 AND audit_status  IN (3,5)) unfinished_artist_video_record_count,
	(SELECT COUNT(1) FROM artshow_artist_index WHERE artist_uid = ? AND deleted_at = 0 AND STATUS =2  AND audit_status  IN (3,5)) unfinished_artist_index_count
FROM 
artwork_lock_record
WHERE artist_uid = ? AND STATUS = 2 AND base_audit_status IN (1,3,5)
`)
	err = db.DB.Raw(sql, user.MgmtArtistUid, user.MgmtArtistUid, user.MgmtArtistUid, user.MgmtArtistUid, user.MgmtArtistUid).Scan(&viewData).Error
	if err != nil {
		return nil, err
	}
	//未签署合同统计
	var UnfinishedContractCount int64
	err = db.DB.Model(model.Contract{}).Where("artist_uid = ? AND STATUS = 2 AND state =1", user.MgmtArtistUid).Count(&UnfinishedContractCount).Error
	if err != nil {
		return nil, err
	}
	rep = &artistInfoUser.UnFinishListRespond{
		ContractList:     UnfinishedContractCount,
		SupplyInfoList:   viewData.UnfinishedArtworkBaseCount + viewData.UnfinishedArtworkSupplementCount + viewData.UnfinishedArtistIndexCount + viewData.UnfinishedArtistSupplementCount,
		AccountStateList: accountStatusList,
	}
	return rep, nil
}

func GetUserMsg(req *artistInfoUser.GetUserMsgRequest) (rep *artistInfoUser.GetUserMsgRespond, err error) {
	var user model.User

	err = db.DB.Where("id = ?", req.Id).First(&user).Error
	if err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	userByte, err := json.Marshal(user)
	if err != nil {
		zap.L().Error("1get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	fmt.Println(string(userByte))
	var re = new(artistInfoUser.GetUserMsgRespond)
	err = json.Unmarshal(userByte, re)
	if err != nil {
		zap.L().Error("1get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep = re
	return rep, nil
}

func FindUser(req *artistInfoUser.FindUserRequest) (rep *artistInfoUser.UserInfo, err error) {
	fmt.Println("FindUser 11111111111")
	rep = &artistInfoUser.UserInfo{}
	var data = model.User{}
	var tx = db.DB.Model(model.User{}).Preload("RealNameInfo").Preload("InvitedBy.UserInfo.RealNameInfo")
	if req.MgmtAccId != 0 {
		tx = tx.Where("mgmt_acc_id = ?", req.MgmtAccId)
	}
	if req.MgmtArtistId != 0 {
		tx = tx.Where("mgmt_artist_id = ?", req.MgmtArtistId)
	}
	if req.InvitedCode != "" {
		tx = tx.Where("BINARY invited_code = ?", req.InvitedCode)
	}
	if req.MgmtArtistUid != "" {
		tx = tx.Where("mgmt_artist_uid = ?", req.MgmtArtistUid)
	}
	err = tx.First(&data).Error
	if err != nil {
		return
	}
	if data.RealNameInfo == nil {
		data.RealNameInfo = &model.RealName{}
	}
	// 邀请人的查询变更为通过账号服务查询
	if data.InvitedBy == nil {
		data.InvitedBy = &model.Invite{}
	}
	var inviterName string
	var inviterCode string
	if data.InvitedBy != nil {
		inviterCode = data.InvitedBy.InviteCode
	}
	if data.InvitedBy != nil && data.InvitedBy.UserInfo != nil && data.InvitedBy.UserInfo.RealNameInfo != nil {
		inviterName = data.InvitedBy.UserInfo.RealNameInfo.Name
	}
	//查询邀请人 无法通过账号服务进行查询，密码验证错误
	// var inviterCode = model.Invite{}
	// var inviterAccount = &account.ListResponse{Data: []*account.AccountInfo{}}
	// var inviterName string
	// db.DB.Model(model.Invite{}).Where("BINARY invited_code = ?", data.InviteCode).First(&inviterCode)
	// if inviterCode.InviteCode != "" {
	// 	inviterAccount, err = service.AccountProvider.ListByIDs(context.Background(), &account.ListByIDsRequest{
	// 		Page:           1,
	// 		PageSize:       1,
	// 		InvitationCode: []string{inviterCode.InviteCode},
	// 	})
	// 	if err != nil {
	// 		fmt.Println("AccountProvider.ListByID error", err.Error())
	// 		return nil, err
	// 	}
	// 	if len(inviterAccount.Data) > 0 {
	// 		inviterName = inviterAccount.Data[0].RealName
	// 	}
	// }
	service.AccountProvider.Info(context.Background(), &account.InfoRequest{})
	rep = &artistInfoUser.UserInfo{
		Id:            data.ID,
		DeletedAt:     int64(data.DeletedAt),
		UpdatedAt:     data.UpdatedAt.Unix(),
		CreatedAt:     data.CreatedAt.Unix(),
		MgmtAccId:     data.MgmtAccId,
		MgmtArtistId:  data.MgmtArtistId,
		MgmtArtistUid: data.MgmtArtistUid,
		TelNum:        data.TelNum,
		InviterCode:   inviterCode, //邀请人的邀请码，不是用户个人邀请码
		InviterName:   inviterName, //邀请人的姓名
		IsRealName:    data.IsRealName,
		RealNameId:    data.RealNameId,
		RealName: &artistInfoUser.RealNameInfo{
			Name:        data.RealNameInfo.Name,
			IdNum:       data.RealNameInfo.IdNum,
			IdCardFront: data.RealNameInfo.IdCardFront,
			IdCardBack:  data.RealNameInfo.IdCardBack,
			Age:         int32(data.RealNameInfo.Age),
			Sex:         string(data.RealNameInfo.Sex),
			Birthday:    data.RealNameInfo.Birthday,
			Address:     data.RealNameInfo.Address,
			Id:          data.RealNameInfo.ID,
		},
		FddState:       data.FddState,
		CustomerId:     data.CustomerId,
		OpenId:         data.OpenId,
		IsRead:         data.IsRead,
		IsLock:         data.IsLock,
		Account:        data.Account,
		CertificateNum: data.CertificateNum,
		CertificateImg: data.CertificateImg,
		JoinAssoTime:   data.JoinAssoTime,
		Photo:          data.Photo,
		HtmlType:       data.Htmltype,
		EnvType:        data.Envtype,
		InviteCode:     data.InviteCode,
		LatestLockTime: data.LatestLockTime,
	}

	return rep, nil
}

func FindUserList(req *artistInfoUser.FindUsersRequest) (rep []*artistInfoUser.UserInfo, total int64, err error) {
	//todo 待修改，邀请人的关联信息不显示
	var (
		datas = []model.User{}
		tx    = db.DB.Model(model.User{}).
			Joins("LEFT JOIN real_name rn ON rn.id  = sys_user.real_name_id").
			Preload("RealNameInfo") //.Where("sys_user.mgmt_artist_uid!=''")
	)
	if req.InvitedCode != "" {
		tx = tx.Where("BINARY invited_code = ?", req.InvitedCode)
	}
	if req.MgmtAccountId != 0 {
		tx = tx.Where("mgmt_acc_id = ?", req.MgmtAccountId)
	}
	if req.MgmtArtistUid != "" {
		tx = tx.Where("mgmt_artist_uid = ?", req.MgmtArtistUid)
	}
	if req.MgmtArtistUids != nil {
		tx = tx.Where("mgmt_artist_uid in ?", req.MgmtArtistUids)
	}
	if req.InviterName != "" {
		tx = tx.Clauses(clause.Like{
			Column: "rn.name",
			Value:  "%" + req.InviterName + "%",
		})
	}
	if req.IsArtist {
		tx = tx.Where("sys_user.mgmt_artist_uid !='' ")
	}
	if req.IsLock {
		tx = tx.Where("is_lock=true")
	}
	if req.ArtistRealName != "" {
		tx = tx.Clauses(clause.Like{
			Column: "rn.name",
			Value:  "%" + req.ArtistRealName + "%",
		})
	}

	err = tx.Count(&total).Scopes(db.Pagination(req.Page, req.PageSize)).Find(&datas).Error
	if err != nil {
		return
	}
	for _, v := range datas {
		if v.RealNameInfo == nil {
			v.RealNameInfo = &model.RealName{}
		}
		if v.InvitedBy == nil {
			v.InvitedBy = &model.Invite{}
		}
		var inviterName, inviterCode string
		if v.InvitedBy != nil && v.InvitedBy.UserInfo != nil && v.InvitedBy.UserInfo.RealNameInfo != nil {
			inviterName = v.InvitedBy.UserInfo.RealNameInfo.Name
		} else {
			inviterName = "无"
		}
		// 查询邀请人信息,调用账号服务接口报错 as/sk 错误，换原先的方法
		// inviterInfo := GetInviterInfo(v.InviteCode)
		// inviterName = inviterInfo.RealName
		inviterCode = v.InviteCode
		rep = append(rep, &artistInfoUser.UserInfo{
			Id:            v.ID,
			DeletedAt:     int64(v.DeletedAt),
			UpdatedAt:     v.UpdatedAt.Unix(),
			CreatedAt:     v.CreatedAt.Unix(),
			MgmtAccId:     v.MgmtAccId,
			MgmtArtistId:  v.MgmtArtistId,
			MgmtArtistUid: v.MgmtArtistUid,
			TelNum:        v.TelNum,
			InviterCode:   inviterCode, //邀请人的邀请码，不是用户个人邀请码
			InviterName:   inviterName, //邀请人没有实名则为空字符串
			IsRealName:    v.IsRealName,
			RealNameId:    v.RealNameId,
			RealName: &artistInfoUser.RealNameInfo{
				Name:        v.RealNameInfo.Name,
				IdNum:       v.RealNameInfo.IdNum,
				IdCardFront: v.RealNameInfo.IdCardFront,
				IdCardBack:  v.RealNameInfo.IdCardBack,
				Age:         int32(v.RealNameInfo.Age),
				Sex:         string(v.RealNameInfo.Sex),
				Birthday:    v.RealNameInfo.Birthday,
				Address:     v.RealNameInfo.Address,
				Id:          v.RealNameInfo.ID,
			},
			FddState:       v.FddState,
			CustomerId:     v.CustomerId,
			OpenId:         v.OpenId,
			IsRead:         v.IsRead,
			IsLock:         v.IsLock,
			Account:        v.Account,
			CertificateNum: v.CertificateNum,
			CertificateImg: v.CertificateImg,
			JoinAssoTime:   v.JoinAssoTime,
			Photo:          v.Photo,
			HtmlType:       v.Htmltype,
			EnvType:        v.Envtype,
			InviteCode:     v.InviteCode,
			LatestLockTime: v.LatestLockTime,
		})
	}
	return
}

func GetViewUserList(req *artistInfoUser.FindUsersRequest) (resp []model.UserView, total int64, err error) {
	resp = []model.UserView{}
	var (
		tx = db.DB.Model(model.UserView{}).Order("created_at desc")
	)
	if req.InvitedCode != "" {
		tx = tx.Where("BINARY invited_code = ?", req.InvitedCode)
	}
	if req.MgmtArtistUid != "" {
		tx = tx.Where("mgmt_artist_uid = ?", req.MgmtArtistUid)
	} else if req.MgmtArtistUids != nil {
		tx = tx.Where("mgmt_artist_uid in ?", req.MgmtArtistUids)
	}
	if req.InviterName != "" {
		tx = tx.Where("inviter_real_name LIKE ?", "%"+req.InviterName+"%")
	}
	if req.IsArtist {
		tx = tx.Where("mgmt_artist_uid !='' ")
	}
	if req.ArtistRealName != "" {
		tx = tx.Where(fmt.Sprintf("real_name LIKE '%%%s%%'", req.ArtistRealName))
	}
	if req.Keyword != "" {
		searchWords := "%" + req.Keyword + "%"
		tx = tx.Where("real_name LIKE ? OR invited_code LIKE ? OR tel_num LIKE ?", searchWords, searchWords, searchWords)
	}

	err = tx.Count(&total).Scopes(db.Pagination(req.Page, req.PageSize)).Find(&resp).Error
	return
}

func UpdateUserData(req *artistInfoUser.UserInfo) (rep *artistInfoUser.CommonNoParams, err error) {
	var (
		preUpdateData    model.User
		needUpdateMobile bool
	)
	dbfind := db.DB.Begin().Preload("RealNameInfo")
	if req.Id != 0 {
		dbfind = dbfind.Where("id = ?", req.Id)
	} else if req.MgmtAccId != 0 {
		dbfind = dbfind.Where("mgmt_acc_id = ?", req.MgmtAccId)
	} else {
		return nil, errors.New("Id或mgmt_acc_id不能为0")
	}
	if err = dbfind.Find(&preUpdateData).Error; err != nil {
		return nil, err
	}
	//判断需要更新的内容
	if req.MgmtArtistId != 0 {
		preUpdateData.MgmtArtistId = req.MgmtArtistId
	}
	if req.MgmtArtistUid != "" {
		preUpdateData.MgmtArtistUid = req.MgmtArtistUid
	}
	if req.MgmtAccId != 0 {
		preUpdateData.MgmtAccId = req.MgmtAccId
	}
	if req.TelNum != "" && req.TelNum != preUpdateData.TelNum {
		needUpdateMobile = true
		preUpdateData.TelNum = req.TelNum
	}
	if req.InviteCode != "" {
		preUpdateData.InviteCode = req.InviteCode
	}
	if req.IsRealName != 0 {
		preUpdateData.IsRealName = req.IsRealName
	}
	if req.RealNameId != 0 {
		preUpdateData.RealNameId = req.RealNameId
	}
	if req.FddState != 0 {
		preUpdateData.FddState = req.FddState
	}
	if req.CustomerId != "" {
		preUpdateData.CustomerId = req.CustomerId
	}
	if req.OpenId != "" {
		preUpdateData.OpenId = req.OpenId
	}
	if req.IsRead != 0 {
		preUpdateData.IsRead = req.IsRead
	}
	if req.IsLock {
		preUpdateData.IsLock = req.IsLock
	}
	if req.Account != "" {
		preUpdateData.Account = req.Account
	}
	if req.CertificateNum != "" {
		preUpdateData.CertificateNum = req.CertificateNum
	}
	if req.CertificateImg != "" {
		preUpdateData.CertificateImg = req.CertificateImg
	}
	if req.Photo != "" {
		preUpdateData.Photo = req.Photo
	}
	if req.HtmlType != "" {
		preUpdateData.Htmltype = req.HtmlType
	}
	if req.EnvType != "" {
		preUpdateData.Envtype = req.EnvType
	}
	if req.JoinAssoTime != "" {
		preUpdateData.JoinAssoTime = req.JoinAssoTime
	}
	if req.WxAccount != "" {
		preUpdateData.WxAccount = req.WxAccount
	}
	if req.MgmtArtistId != 0 {
		preUpdateData.MgmtArtistId = req.MgmtArtistId
	}

	tx := db.DB.Begin()
	err = tx.Save(&preUpdateData).Error
	if err != nil {
		return nil, err
	}
	//更新实名信息
	if req.RealName != nil {
		var realName = model.RealName{}
		if preUpdateData.RealNameInfo != nil {
			realName = *preUpdateData.RealNameInfo
		}
		if req.RealName.Name != "" {
			realName.Name = req.RealName.Name
		}
		if req.RealName.IdNum != "" {
			realName.IdNum = req.RealName.IdNum
		}
		if req.RealName.IdCardFront != "" {
			realName.IdCardFront = req.RealName.IdCardFront
		}
		if req.RealName.IdCardBack != "" {
			realName.IdCardBack = req.RealName.IdCardBack
		}
		if req.RealName.Age != 0 {
			realName.Age = int(req.RealName.Age)
		}
		if req.RealName.Sex != "" {
			realName.Sex = model.SexType(req.RealName.Sex)
		}
		if req.RealName.Birthday != "" {
			realName.Birthday = req.RealName.Birthday
		}
		if req.RealName.Address != "" {
			realName.Address = req.RealName.Address
		}
		err = db.DB.Save(&realName).Error
	}
	if err != nil {
		return nil, err
	}
	//更新手机号码
	if needUpdateMobile {
		// 更新账号服务中手机号
		if _, err = service.AccountProvider.UpdateTelNum(context.Background(), &account.SendNewTelNumMsgRequest{
			Domain:    req.Domain,
			ID:        uint64(preUpdateData.MgmtAccId),
			NewTelNum: preUpdateData.TelNum,
			Code:      req.VerCode,
			Project:   "",
		}); err != nil {
			fmt.Println("错误1-needUpdateMobile-AccountImpl.UpdateTelNum:", err.Error())
			//tx.Rollback()
			return
		}
		//更新画家服务中的手机号
		if _, err = service.GrpcArtistImpl.UpdateProfile(context.Background(), &artist.ProfileRequest{Uid: preUpdateData.MgmtArtistUid, Phone: preUpdateData.TelNum}); err != nil {
			fmt.Println("错误2-needUpdateMobile-rpcArtistImpl.UpdateProfile:", err.Error())
			//tx.Rollback()
			return
		}
	}
	tx.Commit()
	return nil, nil
}

func PreSaveArtistInfo(in *artistInfoUser.PreSaveArtistInfoData) (rep *artistInfoUser.CommonNoParams, err error) {
	var data = model.TempArtistInfo{}
	err = db.DB.Where("mgmt_acc_id = ?", in.MgmtAccId).Find(&data).Error
	if err != nil {
		return
	}
	var tx = db.DB
	data = model.TempArtistInfo{
		MgmtAccId:   in.MgmtAccId,
		Name:        in.Name,
		CardId:      in.CardId,
		Gender:      in.Gender,
		Age:         in.Age,
		NativePlace: in.NativePlace,
		PenName:     in.PenName,
		Phone:       in.Phone,
		Address:     in.Address,
		StageName:   in.StageName,
		CaaCertNum:  in.CaaCertNum,
		CaaJoinTime: in.CaaJoinTime,
		JoinShow:    in.JoinShow,
	}
	if data.MgmtAccId == 0 {
		err = tx.Create(&data).Error
	} else {
		err = tx.Where("mgmt_acc_id = ?", in.MgmtAccId).Save(&data).Error
	}
	return
}

func GetPreSaveArtistInfo(in *artistInfoUser.GetPreSaveArtistInfoRequest) (res *artistInfoUser.PreSaveArtistInfoData, err error) {
	var data = model.TempArtistInfo{}
	err = db.DB.Where("mgmt_acc_id = ?", in.MgmtAccId).Find(&data).Error
	res = &artistInfoUser.PreSaveArtistInfoData{
		MgmtAccId:   data.MgmtAccId,
		Name:        data.Name,
		CardId:      data.CardId,
		Gender:      data.Gender,
		Age:         data.Age,
		NativePlace: data.NativePlace,
		PenName:     data.PenName,
		Phone:       data.Phone,
		Address:     data.Address,
		StageName:   data.StageName,
		CaaCertNum:  data.CaaCertNum,
		CaaJoinTime: data.CaaJoinTime,
		JoinShow:    data.JoinShow,
	}
	return
}
func CheckUserLock(id int64) (err error) {
	var user model.User
	if err = db.DB.Where("id = ? ", id).First(&user).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return
	}
	fmt.Printf("%+v\n", user)
	if user.IsLock {
		fmt.Println(user.IsLock)
		fmt.Println("22222")
		zap.L().Error("user is lock")
		return errors.New(m.ERROR_ISLOCK)
	}
	fmt.Println("333333")
	return nil
}
func CheckUserLockByArtistUid(artistUid string) (err error) {
	var user model.User
	if err = db.DB.Where("mgmt_artist_uid = ?", artistUid).First(&user).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		if err == gorm.ErrRecordNotFound {
			return errors.New(m.ARTIST_NOT_EXISTS)
		}
		err = errors.New(m.ERROR_SELECT)
		return
	}
	if user.IsLock {
		return errors.New(m.ERROR_ISLOCK)
	}
	return nil
}

// GetInviterInfo 查询邀请人信息
// invitedCode:受邀请人的邀请码
func GetInviterInfo(inviterCode string) (result account.AccountInfo) {
	//查找邀请关系
	var inviteRelation = model.Invite{}
	err := db.DB.Model(model.Invite{}).Where("BINARY invite_code = ?", inviterCode).Find(&inviteRelation).Error
	if err != nil {
		fmt.Println("\n GetInviterInfo： 查询邀请人信息出错", err.Error())
		return
	}
	// todo 接口调用报错 as/ak错误
	//查询邀请人信息
	// res, err := service.AccountProvider.ListByIDs(context.Background(), &account.ListByIDsRequest{
	// 	Page:           1,
	// 	PageSize:       1,
	// 	InvitationCode: []string{inviteRelation.InviteCode},
	// })
	// if err != nil {
	// 	fmt.Println("\n GetInviterInfo 查询邀请人信息出错 service.AccountProvider.ListByIDs Error", err.Error())
	// 	return
	// }
	// if res != nil && len(res.Data) > 0 {
	// 	result = account.AccountInfo{
	// 		ID:             res.Data[0].ID,
	// 		Account:        res.Data[0].Account,
	// 		NickName:       res.Data[0].NickName,
	// 		Type:           res.Data[0].Type,
	// 		TelNum:         res.Data[0].TelNum,
	// 		Status:         res.Data[0].Status,
	// 		Avatar:         res.Data[0].Avatar,
	// 		CreateAt:       res.Data[0].CreateAt,
	// 		RealNameID:     res.Data[0].RealNameID,
	// 		RealName:       res.Data[0].RealName,
	// 		IDNum:          res.Data[0].IDNum,
	// 		MnemonicWords:  res.Data[0].MnemonicWords,
	// 		IsNeedChange:   res.Data[0].IsNeedChange,
	// 		EnterDate:      res.Data[0].EnterDate,
	// 		WorkYear:       res.Data[0].WorkYear,
	// 		Domain:         res.Data[0].Domain,
	// 		Extend:         res.Data[0].Extend,
	// 		JobNum:         res.Data[0].JobNum,
	// 		BirthDate:      res.Data[0].BirthDate,
	// 		Age:            res.Data[0].Age,
	// 		Sex:            res.Data[0].Sex,
	// 		Title:          res.Data[0].Title,
	// 		Departments:    res.Data[0].Departments,
	// 		Ip:             res.Data[0].Ip,
	// 		LoginDate:      res.Data[0].LoginDate,
	// 		InvitationCode: res.Data[0].InvitationCode,
	// 	}
	// 	return
	// }
	return
}

func GetInvitedUserList(in *artistInfoUser.GetInvitedUserListRequest) (res *artistInfoUser.GetInvitedUserListResponse, err error) {
	res = &artistInfoUser.GetInvitedUserListResponse{
		Data: []*artistInfoUser.InvitedUser{},
		Page: &artistInfoUser.UserCommonPageInfo{},
	}
	var inviteRelationIds []int64
	db.DB.Model(model.Invite{}).Where("BINARY invite_code = ?", in.InviterCode).Pluck("invited_id", &inviteRelationIds)
	var invitedList []model.User
	//.Select("sys_user.id,sys_user.created_at,sys_user.mgmt_acc_id,sys_user.mgmt_artist_uid,sys_user.tel_num,sys_user.invited_code,sys_user.account,sys_user.photo,sys_user.is_real_name,sys_user.fdd_state")
	orm := db.DB.Model(model.User{}).Preload("RealNameInfo").
		Joins("LEFT JOIN real_name rn ON rn.id = sys_user.real_name_id").
		Joins("LEFT JOIN invite ON invite.invited_id = sys_user.id").
		Where("sys_user.id in ?", inviteRelationIds).Order("invite.created_at desc").Where("sys_user.is_real_name=1")
	if in.RealName != "" {
		orm = orm.Where("rn.name like ?", "%"+in.RealName+"%")
	}
	if in.Keyword != "" {
		searchWords := "%" + in.Keyword + "%"
		orm = orm.Where("rn.name like ? OR sys_user.tel_num LIKE ? or sys_user.invited_code LIKE ?", searchWords, searchWords, searchWords)
	}
	if err = orm.Count(&res.Page.Total).Scopes(db.Pagination(in.Page, in.PageSize)).Find(&invitedList).Error; err != nil {
		return nil, err
	}
	//查询画家基本信息
	var artistProfileList = &artist.ArtistListResponse{Data: []*artist.ProfileRequest{}}
	var artistUids = []string{}
	for _, v := range invitedList {
		if v.MgmtArtistUid != "" {
			artistUids = append(artistUids, v.MgmtArtistUid)
		}
	}
	artistProfileList, err = service.GrpcArtistImpl.ArtistList(context.Background(), &artist.ArtistListRequest{
		Page:     1,
		PageSize: int32(len(artistUids)),
		Uids:     artistUids,
		Gender:   -1,
	})
	if err != nil {
		return nil, err
	}
	for _, v := range invitedList {
		var (
			realName  string
			idcard    string
			sex       string
			age       int64
			penName   string
			stageName string
		)
		if v.RealNameInfo != nil {
			realName = v.RealNameInfo.Name
			sex = string(v.RealNameInfo.Sex)
			age = int64(v.RealNameInfo.Age)
			idcard = v.RealNameInfo.IdNum
		}
		for _, artistProfile := range artistProfileList.Data {
			if v.MgmtArtistUid == artistProfile.Uid {
				penName = artistProfile.PenName
				stageName = artistProfile.StageName
			}
		}
		res.Data = append(res.Data, &artistInfoUser.InvitedUser{
			UserId:     v.ID,
			AccId:      v.MgmtAccId,
			ArtistUid:  v.MgmtArtistUid,
			TelNum:     v.TelNum,
			InviteCode: v.InviteCode,
			Account:    v.Account,
			Photo:      v.Photo,
			IsRealName: v.IsRealName,
			FddState:   v.FddState,
			RealName:   realName,
			Sex:        sex,
			Age:        age,
			CreatedAt:  stime.TimeToString(v.CreatedAt, stime.Format_Normal_YMDhms),
			PenName:    penName,
			StageName:  stageName,
			IdCard:     idcard,
		})
	}
	return
}

// 查询被哪些人邀请过
func GetInviterUserList(in *artistInfoUser.GetInviterUserListRequest) (res *artistInfoUser.GetInvitedUserListResponse, err error) {
	res = &artistInfoUser.GetInvitedUserListResponse{
		Data: []*artistInfoUser.InvitedUser{},
		Page: &artistInfoUser.UserCommonPageInfo{
			Page:     int32(in.Page),
			PageSize: int32(in.PageSize),
		},
	}
	var inviterIds []int64
	db.DB.Model(model.UserInvited{}).Where("BINARY invited_code = ?", in.InvitedCode).Pluck("user_id", &inviterIds)
	var invitedList []model.User
	orm := db.DB.Model(model.User{}).Preload("RealNameInfo").Where("id in ?", inviterIds) //查询邀请人
	if err = orm.Count(&res.Page.Total).Scopes(db.Pagination(in.Page, in.PageSize)).Find(&invitedList).Error; err != nil {
		return nil, err
	}
	//查询画家基本信息
	var artistProfileList = &artist.ArtistListResponse{Data: []*artist.ProfileRequest{}}
	var artistUids = []string{}
	for _, v := range invitedList {
		if v.MgmtArtistUid != "" {
			artistUids = append(artistUids, v.MgmtArtistUid)
		}
	}
	artistProfileList, err = service.GrpcArtistImpl.ArtistList(context.Background(), &artist.ArtistListRequest{
		Page:     1,
		PageSize: int32(len(artistUids)),
		Uids:     artistUids,
		Gender:   -1,
	})
	if err != nil {
		return nil, err
	}
	for _, v := range invitedList {
		var (
			realName  string
			idCard    string
			sex       string
			age       int64
			penName   string
			stageName string
		)
		if v.RealNameInfo != nil {
			realName = v.RealNameInfo.Name
			sex = string(v.RealNameInfo.Sex)
			age = int64(v.RealNameInfo.Age)
			idCard = v.RealNameInfo.IdNum
		}
		fmt.Println("idCard", idCard)
		for _, artistProfile := range artistProfileList.Data {
			if v.MgmtArtistUid == artistProfile.Uid {
				penName = artistProfile.PenName
				stageName = artistProfile.StageName
			}
		}
		res.Data = append(res.Data, &artistInfoUser.InvitedUser{
			UserId:     v.ID,
			AccId:      v.MgmtAccId,
			ArtistUid:  v.MgmtArtistUid,
			TelNum:     v.TelNum,
			InviteCode: v.InviteCode,
			Account:    v.Account,
			Photo:      v.Photo,
			IsRealName: v.IsRealName,
			FddState:   v.FddState,
			RealName:   realName,
			Sex:        sex,
			Age:        age,
			CreatedAt:  stime.TimeToString(v.CreatedAt, stime.Format_Normal_YMDhms),
			PenName:    penName,
			StageName:  stageName,
			IdCard:     idCard,
		})
	}
	return
}

// 邀请关系数据统计
type inviteStatic struct {
	RealName     string `gorm:"column:real_name"`
	TelNum       string `gorm:"column:tel_num"`
	InviteCode   string `gorm:"column:invite_code"`
	InvitePicUrl string `gorm:"-"`
	InvitedCount int64  `gorm:"column:invited_count"`
}

func GetInviteStaticList(in *artistInfoUser.GetInviteStaticListRequest) (res *artistInfoUser.GetInviteStaticListResponse, err error) {
	res = &artistInfoUser.GetInviteStaticListResponse{Data: []*artistInfoUser.GetInviteStaticListData{}, Page: &artistInfoUser.UserCommonPageInfo{
		Page:     int32(in.Page),
		PageSize: int32(in.PageSize),
	}}
	orm := db.DB.
		Select("ui.invite_code,max(rn.name) real_name, max(su.tel_num) tel_num,max(su.mgmt_artist_uid) artist_uid,count(ui.invited_code) invited_count ").
		Table(model.Invite{}.TableName() + " AS ui").
		Joins(fmt.Sprintf("LEFT JOIN %v su ON BINARY su.invited_code =BINARY  ui.invite_code", model.User{}.TableName())).
		Joins((fmt.Sprintf("LEFT JOIN %v rn ON rn.id = su.real_name_id", model.RealName{}.TableName()))).
		Where("su.deleted_at=0").
		Group("ui.invite_code") //HAVING count(ui.invited_code) >0
	if in.Keyword != "" {
		orm = orm.Where(fmt.Sprintf("rn.name LIKE '%%%v%%' OR su.tel_num LIKE '%%%v%%' OR su.invited_code LIKE '%%%v%%'", in.Keyword, in.Keyword, in.Keyword))
	}
	var datas []inviteStatic
	err = orm.Count(&res.Page.Total).Scopes(db.Pagination(in.Page, in.PageSize)).Find(&datas).Error
	//倒序排序
	sort.Slice(datas, func(i, j int) bool {
		return datas[i].InvitedCount < datas[j].InvitedCount
	})
	if len(datas) > 0 {
		for i, v := range datas {
			res.Data = append(res.Data, &artistInfoUser.GetInviteStaticListData{
				Idx:          int64(i + 1),
				RealName:     v.RealName,
				TelNum:       v.TelNum,
				InviteCode:   v.InviteCode,
				InvitePicUrl: fmt.Sprintf("https://cdn.fontree.cn/artistmgmt/static/qrcode/%v.png", v.InviteCode),
				InvitedCount: v.InvitedCount,
			})
		}
	}
	return
}