lone-services/services/store/internal/logic/createLogic.go

package logic

import (
	"context"
	"lone-services/pkg/utils"
	sale "lone-services/rpc/sale/pb"
	"lone-services/rpc/store/pb"
	user "lone-services/rpc/user/pb"
	"lone-services/services/store/internal/dao"
	"lone-services/services/store/internal/model"
	"lone-services/services/store/internal/svc"
	"lone-services/services/store/validator"
	"strings"

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

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

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

func (l *CreateLogic) Create(in *store.CreateRequest) (*store.Response, error) {
	var v validator.StoreCreateValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}

	adminInfo := utils.GetUserFromCtx(l.ctx)
	if adminInfo.ID < utils.NumberOne {
		return l.fail(utils.ErrorNoLoginInfo)
	}

	uErr := l.checkUser(in.UserMobile)
	if uErr != utils.Ok {
		return l.fail(uErr)
	}

	encryptMobile, cErr := utils.EncryptPhone(in.UserMobile)
	if cErr != nil {
		return l.fail(utils.ErrorEncryptAesError)
	}

	encryptData, cErr := utils.Crypto{}.AESEncryptECB(in.BusinessLicense)
	if cErr != nil {
		return l.fail(utils.ErrorEncryptAesError)
	}

	encryptIdCard, cErr := utils.Crypto{}.AESEncryptECB(in.IdCard)
	if cErr != nil {
		return l.fail(utils.ErrorEncryptAesError)
	}

	data := dao.StoreCreate{
		Name:            in.Name,
		UserName:        in.UserName,
		UserMobile:      encryptMobile,
		BusinessLicense: encryptData,
		District:        in.DistrictIds,
		Address:         in.Address,
		Status:          utils.StatusOk,
		SaleId:          in.SaleId,
		SourceType:      model.StoreTypeAdmin,
		StoreType:       strings.Join(in.StoreType, utils.DecollatorComma),
		Images:          in.Images,
		Contact:         in.Contact,
		Content:         in.Content,
		BankInfo:        in.BankInfo,
		OpenTime:        in.OpenTime,
		LongitudeWgs84:  in.LongitudeWgs84,
		LatitudeWgs84:   in.LatitudeWgs84,
		LongitudeGcj02:  in.LongitudeGcj02,
		LatitudeGcj02:   in.LatitudeGcj02,
		AdminId:         adminInfo.ID,
		AdminName:       adminInfo.Name,
		StoreImages:     in.StoreImages,
		IdCard:          encryptIdCard,
		Area:            in.Area,
		Receipt:         in.Receipt,
		Type:            in.Type,
		Province:        in.Province,
		City:            in.City,
		County:          in.County,
		ProvinceName:    in.ProvinceName,
		CityName:        in.CityName,
		CountyName:      in.CountyName,
	}
	groupId, sErr := l.getSaleInfo(in.SaleId)
	if sErr != utils.Ok {
		return l.fail(sErr)
	}
	if groupId < utils.NumberOne {
		return l.fail(utils.ErrorNotFund)
	}

	data.GroupId = groupId

	modelObj := model.StoreModel{}.Init()
	modelObj.Begin()
	err := modelObj.Create(&data)
	if err != nil {
		modelObj.Rollback()
		return l.fail(utils.ErrorInternalServer)
	}
	uErr = l.createUser(data, in.Password)
	if uErr != utils.Ok {
		modelObj.Rollback()
		return l.fail(uErr)
	}
	modelObj.Commit()
	return l.ok(utils.NumberOne)
}

func (l *CreateLogic) getSaleInfo(id int64) (int64, utils.Status) {
	cli, err := svc.GetRpcClient(l.svcCtx.SaleName)
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return utils.NumberZero, utils.ErrorInternalServer
	}

	client := sale.NewSaleClient(cli.Conn())
	w := sale.InfoReq{Id: id}
	info, err := client.InfoInternal(context.Background(), &w)
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return utils.NumberZero, utils.ErrorInternalServer
	}
	return info.GroupId, utils.Ok
}

func (l *CreateLogic) createUser(info dao.StoreCreate, password string) utils.Status {
	cli, err := svc.GetRpcClient(l.svcCtx.UserName)
	if err != nil {
		logx.Errorf("get user err: %v", err)
		return utils.ErrorInternalServer
	}

	client := user.NewUserClient(cli.Conn())

	mobile, sErr := utils.EncryptPhone(info.UserMobile)
	if sErr != nil {
		return utils.ErrorEncryptAesError
	}
	data := user.InternalCreateReq{
		BizId:          info.Id,
		Mobile:         mobile,
		Name:           info.UserName,
		ClientCode:     strings.Split(info.StoreType, utils.DecollatorComma), //哪端
		CredentialType: []string{dao.LoginTypePassword, dao.LoginTypeSms},
		Identifier:     mobile,   //手机号
		Secret:         password, //密码
	}

	_, err = client.InternalCreate(context.Background(), &data)
	if err != nil {
		logx.Errorf("get user err: %v", err)
		return utils.ErrorInternalServer
	}

	return utils.Ok
}

func (l *CreateLogic) checkUser(mobile string) utils.Status {
	cli, err := svc.GetRpcClient(l.svcCtx.UserName)
	if err != nil {
		logx.Errorf("get user err: %v", err)
		return utils.ErrorInternalServer
	}

	client := user.NewUserClient(cli.Conn())

	data := user.InternalCheckCreateReq{
		Mobile: mobile,
	}
	_, err = client.InternalCheckCreate(context.Background(), &data)
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return utils.ErrorInternalServer
	}

	return utils.Ok
}