lone-services/services/user/internal/logic/infoLogic.go

package logic

import (
	"context"
	"strconv"

	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	user "lone-services/rpc/user/pb"
	"lone-services/services/user/internal/dao"
	"lone-services/services/user/internal/model"
	"lone-services/services/user/internal/svc"

	"github.com/zeromicro/go-zero/core/logx"
)

type InfoLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
}

func NewInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *InfoLogic {
	return &InfoLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *InfoLogic) Info(in *user.InfoReq) (*user.Response, error) {
	loginUser := utils.GetUserFromCtx(l.ctx)
	if loginUser.ID < utils.NumberOne {
		return failResponse(utils.ErrorNoLoginInfo), nil
	}

	row, err := loadEnabledUser(loginUser.ID)
	if err != nil {
		l.Errorf("info load user: %v", err)
		return failResponse(utils.ErrorNotFund), nil
	}

	userType := loginUser.Type
	if userType < utils.NumberOne {
		userType = dao.TypeUser
	}
	mobile, _ := utils.DecryptPhone(row.Mobile)
	ret := dao.ProfileData{
		Type: userType,
		Base: dao.ProfileBase{
			Id:       row.Id,
			Name:     row.Name,
			Avatar:   row.Avatar,
			Mobile:   mobile,
			Gender:   row.Gender,
			Birthday: row.Birthday.DateString(),
			Status:   row.Status,
		},
	}

	detail, detailErr := loadUserDetail(row.Id)
	if detailErr != nil {
		l.Errorf("info load detail: %v", detailErr)
		return failResponse(utils.Fail), nil
	}
	if detail != nil {
		ret.Detail = &dao.ProfileDetail{RealName: detail.RealName}
	} else {
		ret.Detail = &dao.ProfileDetail{}
	}

	if loginUser.ClientCode != utils.StringEmpty {
		clientInfo, clientErr := loadProfileClient(row.Id, loginUser.ClientCode)
		if clientErr != nil {
			l.Errorf("info load user client: %v", clientErr)
			return failResponse(utils.Fail), nil
		}
		ret.Client = clientInfo
	}

	switch userType {
	case dao.TypeUser:
		return okResponse(ret), nil
	case dao.TypeSale:
		saleData, saleErr := l.loadSaleProfile(loginUser)
		if saleErr != nil {
			l.Errorf("info load sale: %v", saleErr)
			return failResponse(utils.Fail), nil
		}
		if saleData == nil {
			return outResponse(utils.ErrorNotFund, "销售信息不存在"), nil
		}
		ret.Sale = saleData
		return okResponse(ret), nil
	case dao.TypeStore:
		return outResponse(utils.Fail, "门店详情暂未开放"), nil
	default:
		return outResponse(utils.ErrorParams, "未知的用户类型"), nil
	}
}

func (l *InfoLogic) loadSaleProfile(loginUser utils.UserInfo) (*dao.ProfileSaleData, error) {
	if loginUser.BizId > utils.NumberZero {
		data, err := fetchSaleById(l.ctx, l.svcCtx.SaleSvcName, loginUser.BizId)
		if err != nil {
			return nil, err
		}
		if data != nil {
			return toProfileSale(data), nil
		}
	}
	data, err := fetchSaleByUserId(l.ctx, l.svcCtx.SaleSvcName, loginUser.ID)
	if err != nil {
		return nil, err
	}
	return toProfileSale(data), nil
}

func loadProfileClient(userId int64, clientCode string) (*dao.ProfileClient, error) {
	var row dao.UserClient
	err := model.UserClientModel{}.Init().GetOne(modelbase.Params{
		Eq: map[string]string{
			"user_id":     strconv.FormatInt(userId, utils.NumberTen),
			"client_code": clientCode,
			"status":      strconv.Itoa(int(dao.StatusEnabled)),
		},
	}, &row)
	if err != nil {
		return nil, err
	}
	if row.Id < utils.NumberOne {
		return nil, nil
	}
	return &dao.ProfileClient{
		ClientCode: row.ClientCode,
		OpenedAt:   row.OpenedAt.Format(),
	}, nil
}