fonchain-artistinfo/cmd/internal/controller/artisrInfo.go

package controller

import (
	"context"
	"fmt"
	"github.com/fonchain/fonchain-artistinfo/cmd/model"
	db "github.com/fonchain/fonchain-artistinfo/pkg/db"

	"github.com/fonchain/fonchain-artistinfo/cmd/internal/logic"
	"github.com/fonchain/fonchain-artistinfo/pb/artistinfo"
)

var _ artistinfo.ArtistInfoServer = new(ArtistInfoProvider)

type ArtistInfoProvider struct {
	artistinfo.UnimplementedArtistInfoServer
	artistInfoLogic *logic.ArtistInfo
}

func (a *ArtistInfoProvider) RegisterUser(ctx context.Context, req *artistinfo.RegisterUserRequest) (rep *artistinfo.RegisterUserRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.RegisterUser(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) GetUser(ctx context.Context, req *artistinfo.GetUserRequest) (rep *artistinfo.GetUserRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.GetUser(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) UpdateRealName(ctx context.Context, req *artistinfo.UpdateRealNameRequest) (rep *artistinfo.UpdateRealNameRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.UpdateRealName(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) FinishVerify(ctx context.Context, req *artistinfo.FinishVerifyRequest) (rep *artistinfo.FinishVerifyRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.FinishVerify(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) CheckUserLock(ctx context.Context, req *artistinfo.CheckUserLockRequest) (rep *artistinfo.CheckUserLockRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.CheckUserLock(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) ArtistSupplyList(ctx context.Context, req *artistinfo.ArtistSupplyListRequest) (rep *artistinfo.ArtistSupplyListRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserInfoRespond{}
	if rep, err = a.artistInfoLogic.ArtistSupplyList(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) CheckInvitedCode(ctx context.Context, req *artistinfo.CheckInvitedCodeRequest) (rep *artistinfo.GetUserRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.CheckInvitedCodeInfoRespond{}
	if rep, err = a.artistInfoLogic.CheckInvitedCode(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) UnFinishList(ctx context.Context, req *artistinfo.UnFinishListRequest) (rep *artistinfo.UnFinishListRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.UnFinishListInfoRespond{}
	if rep, err = a.artistInfoLogic.UnFinishList(req); err != nil {
		return nil, err
	}
	return rep, nil
}

func (a *ArtistInfoProvider) GetUserMsg(ctx context.Context, req *artistinfo.GetUserMsgRequest) (rep *artistinfo.GetUserMsgRespond, err error) {
	fmt.Println("第一处")
	// backup := &artistInfo.GetUserMsgInfoRespond{}
	if rep, err = a.artistInfoLogic.GetUserMsg(req); err != nil {
		return nil, err
	}
	return rep, nil
}

// 绑定邀请人和受邀请人的账号,并加入到次数统计
func (a *ArtistInfoProvider) BindInviteInvitedAccount(ctx context.Context, in *artistinfo.BindInviteInvitedAccountRequest) (res *artistinfo.BindInviteInvitedAccountRespond, err error) {
	if in.UserId == 0 || in.InvitedUserId == 0 {
		return nil, err
	}
	// todo 变量in 参数检测: 邀请码没填的话需要从账号服务获取
	// ..
	// ..
	var data model.Invite
	// 只能绑定一个邀请人
	if err = db.DB.Where("invited_id = ?", in.InvitedUserId).Find(&data).Error; err != nil {
		return nil, err
	}
	if data.UserId == 0 {
		data = model.Invite{
			UserId:      in.UserId,
			InvitedId:   in.InvitedUserId,
			InvitedCode: in.InvitedCode,
			InviteCode:  in.InviteCode,
		}
		if err = db.DB.Create(&data).Error; err != nil {
			return nil, err
		}
	}

	// 添加到次数统计
	var countData model.UserInvited
	if err = db.DB.Where("user_id= ? AND invited_user_id= ?", in.UserId, in.GetInvitedUserId()).Find(&countData).Error; err != nil {
		return nil, err
	}
	if countData.UserId == 0 {
		countData = model.UserInvited{
			UserId:        in.UserId,
			InvitedUserId: in.InvitedUserId,
			Count:         1,
			InvitedCode:   in.InvitedCode,
			InviteCode:    in.InviteCode,
		}
		if err = db.DB.Create(&countData).Error; err != nil {
			return nil, err
		}
	} else {
		countData.Count += 1
		if err = db.DB.Model(model.UserInvited{}).Where("id = ?", countData.ID).Updates(&countData).Error; err != nil {
			return nil, err
		}
	}
	return nil, err
}

func (a *ArtistInfoProvider) BindArtistId(ctx context.Context, in *artistinfo.BindArtistIdRequest) (*artistinfo.BindArtistIdResp, error) {
	if err := db.DB.Model(model.User{}).Where("mgmt_user_id = ?", in.UserId).Update("mgmt_artist_id", in.ArtistId).Error; err != nil {
		return &artistinfo.BindArtistIdResp{Error: err.Error()}, err
	}
	return nil, nil
}

func (a *ArtistInfoProvider) FindUser(ctx context.Context, in *artistinfo.FindUserRequest) (*artistinfo.UserInfo, error) {
	return a.artistInfoLogic.FindUser(in)
}

func (a *ArtistInfoProvider) UpdateUserData(ctx context.Context, in *artistinfo.UserInfo) (*artistinfo.CommonNoParams, error) {
	return a.artistInfoLogic.UpdateUserData(in)
}