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

package dao

import (
	"encoding/json"
	"errors"
	"fmt"
	"gorm.io/plugin/soft_delete"
	"time"

	"github.com/alibaba/sentinel-golang/logging"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	"github.com/fonchain/fonchain-artistinfo/pb/artistinfo"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"
	"github.com/fonchain/fonchain-artistinfo/pkg/m"
	"github.com/fonchain/utils/utils"
	"go.uber.org/zap"
)

func RegisterUser(req *artistinfo.RegisterUserRequest) (rep *artistinfo.RegisterUserRespond, err error) {

	var user = model.User{
		MgmtUserId:   req.MgmtUserId,
		TelNum:       req.TelNum,
		MgmtArtistId: req.MgmtArtistId,
	}
	user.TelNum = req.TelNum
	user.MgmtArtistId = req.MgmtArtistId
	if err := db.DB.Create(&user).Error; err != nil {
		zap.L().Error("register user err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	return
}

func CreateUserInfo(req *artistinfo.CreateUserInfoRequest) (rep *artistinfo.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.Name = req.RealName
	user.PenName = req.PenName
	user.RealNameID = int32(realname.ID)
	user.StageName = req.StageName
	user.Age = int32(utils.IdCardTurnAge(realname.IDNum))
	user.Sex = req.Sex
	user.JoinAssoTime = req.JoinAssoTime
	user.CertificateNum = req.CertificateNum
	conAddessByte, err := json.Marshal(req.ConAddress)
	if err != nil {
		zap.L().Error("CreateUserInfo err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	user.ConAddress = string(conAddessByte)
	user.CreatedAt = time.Now()
	user.Photo = req.Photo
	user.WxAccount = req.WxAccount
	user.CertificateImg = req.CertificateImg
	user.Video = req.Video
	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 {
		InvitedId, 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("invited_code =?", invitedCode).Find(&user).Error; err != nil {
		return 0, err
	}
	if user.ID == 0 {
		return 0, errors.New("邀请码无效")
	}
	return uint(user.ID), nil
}
func GetUser(req *artistinfo.GetUserRequest) (rep *artistinfo.GetUserRespond, err error) {
	rep = &artistinfo.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))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	// rep.
	fmt.Println(user)
	rep.Id = user.ID
	rep.MgmtUserId = user.MgmtUserId
	rep.MgmtArtistId = user.MgmtArtistId
	rep.TelNum = user.TelNum
	rep.IsFdd = 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 *artistinfo.GetUserByIdRequest) (rep *artistinfo.GetUserByIdRespond, err error) {
	rep = &artistinfo.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("mgmt_user_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.MgmtUserId = user.MgmtUserId
	rep.MgmtArtistId = user.MgmtArtistId
	rep.TelNum = user.TelNum
	rep.IsFdd = user.FddState
	rep.IsRealName = user.IsRealName
	rep.Ruler = user.Ruler
	return rep, nil
}
func UpdateRealName(req *artistinfo.UpdateRealNameRequest) (rep *artistinfo.UpdateRealNameRespond, err error) {
	var updateData = model.User{
		IsRealName: int64(req.Id),
		Name:       req.Name,
		IDNum:      req.IdNum,
	}
	//user.ID = req.Id
	// 使用账号id来定位需要更新的数据
	if err = db.DB.Model(model.User{}).Where("mgmt_user_id = ?", req.Id).Updates(&updateData).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 FinishVerify(req *artistinfo.FinishVerifyRequest) (rep *artistinfo.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 *artistinfo.ArtistSupplyListRequest) (rep *artistinfo.ArtistSupplyListRespond, err error) {
	var artistList = make([]artistinfo.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 uint64
	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 *artistinfo.UserLockRequest) (rep *artistinfo.UserLockRespond, err error) {
	var user model.User
	user.ID = uint64(req.Id)
	if err = db.DB.Model(&user).Update("is_lock", req.IsLock).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}

	if !req.IsLock {

		var vas model.ExhVideo
		vas.UserId = uint(req.Id)
		if err = db.DB.Model(&vas).Update("state", 5).Where("state = 1 or state = 2 or state = 3").Error; err != nil {
			zap.L().Error("get user info err", zap.Error(err))
			err = errors.New(m.ERROR_SELECT)
			return nil, err
		}
		var ee model.ExhExam
		ee.UserId = uint(req.Id)
		if err = db.DB.Model(&ee).Update("state", 5).Where("state = 1 or state = 2 or state = 3 or state = 4").Error; err != nil {
			zap.L().Error("get user info err", zap.Error(err))
			err = errors.New(m.ERROR_SELECT)
			return nil, err
		}
		var si model.SupplyInfo
		si.UserId = uint(req.Id)
		if err = db.DB.Model(&si).Update("state", 5).Where("state = 1 or state = 2 or state = 3 or state = 4").Error; err != nil {
			zap.L().Error("get user info err", zap.Error(err))
			err = errors.New(m.ERROR_SELECT)
			return nil, err
		}
		var ai model.ArtistInfo
		ai.UserId = uint(req.Id)
		if err = db.DB.Model(&ai).Update("state", 5).Where("state = 1 or state = 2 or state = 3 or state = 4").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 CheckInvitedCode(req *artistinfo.CheckInvitedCodeRequest) (rep *artistinfo.GetUserRespond, err error) {
	rep = &artistinfo.GetUserRespond{}
	// service := &artist.UserUpdateInfoService{}
	var user model.User
	if err = db.DB.First(&user, "invited_code = ?", req.InvitedCode).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	// rep.
	rep.Id = user.ID
	rep.MgmtUserId = user.MgmtUserId
	rep.MgmtArtistId = user.MgmtArtistId
	rep.TelNum = user.TelNum
	rep.IsFdd = user.IsFdd
	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 *artistinfo.UnFinishListRequest) (rep *artistinfo.UnFinishListRespond, err error) {
	rep = &artistinfo.UnFinishListRespond{}
	var user model.User
	if err := db.DB.Where("id = ? ", req.Id).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 realName model.RealName
	if err := db.DB.Where("id = ? ", user.RealNameID).First(&realName).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	var contract model.Contract
	var contractCount int64
	if err := db.DB.Model(&contract).Where("state = ? and (user_id = ? or card_id = ?) and (type =1 or type = 2 or type = 3)", "1", user.ID, realName.IDNum).Count(&contractCount).Error; err != nil {
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.ContractList = contractCount
	var accountStateCount int64
	fmt.Println(realName.IDNum)
	if err := db.DB.Model(&contract).Where("state = ? and (user_id = ? or card_id = ?) and type = 4", "1", user.ID, realName.IDNum).Count(&accountStateCount).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.AccountStateList = accountStateCount
	var supplyInfo model.SupplyInfo
	var supplyInfoCount int64
	if err := db.DB.Model(&supplyInfo).Where("types = ? and user_id = ? ", "1", user.ID).Count(&supplyInfoCount).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.SupplyInfoList += supplyInfoCount
	var exhVideo model.ExhVideo
	var exhVideoCount int64
	if err := db.DB.Model(&exhVideo).Where("types = ? and user_id = ? ", "1", user.ID).Count(&exhVideoCount).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.SupplyInfoList += exhVideoCount
	var exhExam model.ExhExam
	var exhExamCount int64
	if err := db.DB.Model(&exhExam).Where("types = ? and user_id = ? ", "1", user.ID).Count(&exhExamCount).Error; err != nil {
		zap.L().Error("get user info err", zap.Error(err))
		err = errors.New(m.ERROR_SELECT)
		return nil, err
	}
	rep.SupplyInfoList += exhExamCount

	return rep, nil
}

func GetUserMsg(req *artistinfo.GetUserMsgRequest) (rep *artistinfo.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(artistinfo.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 *artistinfo.FindUserRequest) (rep *artistinfo.UserInfo, err error) {
	rep = &artistinfo.UserInfo{}
	var data = model.User{}
	var tx = db.DB.Model(model.User{})
	if req.MgmtUserId != 0 {
		tx = tx.Where("mgmt_user_id = ?", req.MgmtUserId)
	}
	if req.MgmtArtistId != "" {
		tx = tx.Where("mgmt_artist_id = ?", req.MgmtArtistId)
	}
	if req.InvitedCode != "" {
		tx = tx.Where("invited_code = ?", req.InvitedCode)
	}
	err = tx.First(&data).Error
	if err != nil {
		return
	}
	rep = &artistinfo.UserInfo{
		Id:             data.ID,
		MgmtUserId:     data.MgmtUserId,
		MgmtArtistId:   data.MgmtArtistId,
		Account:        data.Account,
		MnemonicWords:  data.MnemonicWords,
		TelNum:         data.TelNum,
		Name:           data.Name,
		PenName:        data.PenName,
		StageName:      data.StageName,
		JoinAssoTime:   data.JoinAssoTime,
		CertificateNum: data.CertificateNum,
		CertificateImg: data.CertificateImg,
		Key:            data.Key,
		RealNameID:     data.RealNameID,
		IDNum:          data.IDNum,
		Sex:            data.Sex,
		Ruler:          data.Ruler,
		OpenId:         data.OpenId,
		CustomerId:     data.CustomerId,
		Age:            data.Age,
		Introduct:      data.Introduct,
		CreatedAt:      data.CreatedAt.Unix(),
		ConAddress:     data.ConAddress,
		Photo:          data.Photo,
		Video:          data.Video,
		IsRealName:     data.IsRealName,
		IsFdd:          data.IsFdd,
		FddState:       data.FddState,
		WxAccount:      data.WxAccount,
		IsLock:         data.IsLock,
		InvitedCode:    data.InvitedCode,
		IsRead:         data.IsRead,
		IsImport:       data.IsImport,
		Enable:         data.Enable,
		DeletedAt:      int64(data.DeletedAt),
		UpdatedAt:      data.UpdatedAt.Unix(),
	}

	return rep, nil
}
func UpdateUserData(req *artistinfo.UserInfo) (rep *artistinfo.CommonNoParams, err error) {
	var updateData = model.User{
		Model: model.Model{
			ID:        req.Id,
			CreatedAt: time.Unix(req.CreatedAt, 0),
			UpdatedAt: time.Unix(req.UpdatedAt, 0),
			DeletedAt: soft_delete.DeletedAt(req.DeletedAt),
		},
		MgmtUserId:     req.MgmtUserId,
		MgmtArtistId:   req.MgmtArtistId,
		Account:        req.Account,
		MnemonicWords:  req.MnemonicWords,
		TelNum:         req.TelNum,
		Name:           req.Name,
		PenName:        req.PenName,
		StageName:      req.StageName,
		JoinAssoTime:   req.JoinAssoTime,
		CertificateNum: req.CertificateNum,
		CertificateImg: req.CertificateImg,
		Key:            req.Key,
		RealNameID:     req.RealNameID,
		IDNum:          req.IDNum,
		Sex:            req.Sex,
		Ruler:          req.Ruler,
		OpenId:         req.OpenId,
		CustomerId:     req.CustomerId,
		Age:            req.Age,
		Introduct:      req.Introduct,
		ConAddress:     req.ConAddress,
		Photo:          req.Photo,
		Video:          req.Video,
		IsRealName:     req.IsRealName,
		IsFdd:          req.IsFdd,
		FddState:       req.FddState,
		WxAccount:      req.WxAccount,
		IsLock:         req.IsLock,
		InvitedCode:    req.InvitedCode,
		IsRead:         req.IsRead,
		IsImport:       req.IsImport,
		Enable:         req.Enable,
	}
	db.DB.Save(&updateData)
	return nil, nil
}