252 lines
9.5 KiB
Go
252 lines
9.5 KiB
Go
// Package shop 提供店铺创建与业务员归属的简单写事务脚本。
|
|
package shop
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"golang.org/x/crypto/bcrypt"
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/internal/model/dto"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
"github.com/break/junhong_cmp_fiber/pkg/middleware"
|
|
)
|
|
|
|
// CreateService 收口平台与代理创建店铺的完整事务。
|
|
type CreateService struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewCreateService 创建店铺创建事务脚本。
|
|
func NewCreateService(db *gorm.DB) *CreateService {
|
|
return &CreateService{db: db}
|
|
}
|
|
|
|
// Create 按操作者类型执行平台显式归属或代理安全继承。
|
|
func (s *CreateService) Create(ctx context.Context, request *dto.CreateShopRequest) (*dto.ShopResponse, error) {
|
|
userType := middleware.GetUserTypeFromContext(ctx)
|
|
operatorID := middleware.GetUserIDFromContext(ctx)
|
|
if operatorID == 0 {
|
|
return nil, errors.New(errors.CodeUnauthorized)
|
|
}
|
|
resolver := resolvePlatformBusinessOwner
|
|
switch userType {
|
|
case constants.UserTypeSuperAdmin, constants.UserTypePlatform:
|
|
case constants.UserTypeAgent:
|
|
if request.BusinessOwnerAccountIDSet {
|
|
return nil, errors.New(errors.CodeForbidden, "无权限设置店铺业务员")
|
|
}
|
|
if request.ParentID == nil {
|
|
return nil, errors.New(errors.CodeForbidden, "无权限操作该资源或资源不存在")
|
|
}
|
|
if err := middleware.CanManageShop(ctx, *request.ParentID); err != nil {
|
|
return nil, errors.New(errors.CodeForbidden, "无权限操作该资源或资源不存在")
|
|
}
|
|
resolver = resolveInheritedBusinessOwner
|
|
default:
|
|
return nil, errors.New(errors.CodeForbidden, "无权限操作该资源或资源不存在")
|
|
}
|
|
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(request.InitPassword), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
return nil, errors.Wrap(errors.CodeInternalError, err, "密码哈希失败")
|
|
}
|
|
|
|
var response *dto.ShopResponse
|
|
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
created, createErr := createShop(tx, request, operatorID, string(hashedPassword), resolver)
|
|
if createErr != nil {
|
|
return createErr
|
|
}
|
|
response = created
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
type businessOwnerResolver func(*gorm.DB, *dto.CreateShopRequest, *model.Shop) (*uint, error)
|
|
|
|
func createShop(tx *gorm.DB, request *dto.CreateShopRequest, operatorID uint, hashedPassword string, resolveOwner businessOwnerResolver) (*dto.ShopResponse, error) {
|
|
if exists, err := recordExists(tx, &model.Shop{}, "shop_code = ?", request.ShopCode); err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "校验店铺编号失败")
|
|
} else if exists {
|
|
return nil, errors.New(errors.CodeShopCodeExists, "店铺编号已存在")
|
|
}
|
|
if exists, err := recordExists(tx, &model.Account{}, "username = ?", request.InitUsername); err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "校验初始账号用户名失败")
|
|
} else if exists {
|
|
return nil, errors.New(errors.CodeUsernameExists, "初始账号用户名已存在")
|
|
}
|
|
if exists, err := recordExists(tx, &model.Account{}, "phone = ?", request.InitPhone); err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "校验初始账号手机号失败")
|
|
} else if exists {
|
|
return nil, errors.New(errors.CodePhoneExists, "初始账号手机号已存在")
|
|
}
|
|
|
|
parent, level, err := resolveParent(tx, request.ParentID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ownerID, err := resolveOwner(tx, request, parent)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var role model.Role
|
|
if err := tx.Where("id = ? AND role_type = ? AND status = ?", request.DefaultRoleID, constants.RoleTypeCustomer, constants.StatusEnabled).First(&role).Error; err != nil {
|
|
return nil, errors.New(errors.CodeInvalidParam, "请选择启用的客户角色")
|
|
}
|
|
|
|
shop := &model.Shop{
|
|
ShopName: request.ShopName, ShopCode: request.ShopCode, ParentID: request.ParentID,
|
|
BusinessOwnerAccountID: ownerID, Level: level, ContactName: request.ContactName,
|
|
ContactPhone: request.ContactPhone, Province: request.Province, City: request.City,
|
|
District: request.District, Address: request.Address, Status: constants.ShopStatusEnabled,
|
|
}
|
|
shop.Creator = operatorID
|
|
shop.Updater = operatorID
|
|
if err := tx.Create(shop).Error; err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建店铺失败")
|
|
}
|
|
|
|
account := &model.Account{
|
|
Username: request.InitUsername, Phone: request.InitPhone, Password: hashedPassword,
|
|
UserType: constants.UserTypeAgent, ShopID: &shop.ID, Status: constants.StatusEnabled, IsPrimary: true,
|
|
}
|
|
account.Creator = operatorID
|
|
account.Updater = operatorID
|
|
if err := tx.Create(account).Error; err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建初始账号失败")
|
|
}
|
|
if err := tx.Create(&model.AccountRole{
|
|
AccountID: account.ID, RoleID: request.DefaultRoleID, Status: constants.StatusEnabled,
|
|
Creator: operatorID, Updater: operatorID,
|
|
}).Error; err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "为初始账号分配角色失败")
|
|
}
|
|
if err := tx.Create(&model.ShopRole{
|
|
ShopID: shop.ID, RoleID: request.DefaultRoleID, Status: constants.StatusEnabled,
|
|
Creator: operatorID, Updater: operatorID,
|
|
}).Error; err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "设置店铺默认角色失败")
|
|
}
|
|
if err := tx.Create([]*model.AgentWallet{
|
|
{
|
|
ShopID: shop.ID, WalletType: constants.AgentWalletTypeMain,
|
|
CreditEnabled: role.DefaultCreditEnabled, CreditLimit: role.DefaultCreditLimit,
|
|
Currency: "CNY", Status: constants.AgentWalletStatusNormal, ShopIDTag: shop.ID,
|
|
},
|
|
{
|
|
ShopID: shop.ID, WalletType: constants.AgentWalletTypeCommission,
|
|
CreditEnabled: false, CreditLimit: 0,
|
|
Currency: "CNY", Status: constants.AgentWalletStatusNormal, ShopIDTag: shop.ID,
|
|
},
|
|
}).Error; err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "初始化店铺钱包失败")
|
|
}
|
|
|
|
parentName := ""
|
|
if parent != nil {
|
|
parentName = parent.ShopName
|
|
}
|
|
response := newShopResponse(shop, parentName)
|
|
if err := fillBusinessOwnerResponse(tx, shop, response); err != nil {
|
|
return nil, err
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func resolveParent(tx *gorm.DB, parentID *uint) (*model.Shop, int, error) {
|
|
if parentID == nil {
|
|
return nil, 1, nil
|
|
}
|
|
var parent model.Shop
|
|
if err := tx.First(&parent, *parentID).Error; err != nil {
|
|
return nil, 0, errors.New(errors.CodeInvalidParentID, "上级店铺不存在或无效")
|
|
}
|
|
level := parent.Level + 1
|
|
if level > constants.ShopMaxLevel {
|
|
return nil, 0, errors.New(errors.CodeShopLevelExceeded, "店铺层级不能超过 7 级")
|
|
}
|
|
return &parent, level, nil
|
|
}
|
|
|
|
func resolvePlatformBusinessOwner(tx *gorm.DB, request *dto.CreateShopRequest, parent *model.Shop) (*uint, error) {
|
|
if !request.BusinessOwnerAccountIDSet {
|
|
if parent == nil || parent.BusinessOwnerAccountID == nil {
|
|
return nil, nil
|
|
}
|
|
ownerID := *parent.BusinessOwnerAccountID
|
|
return &ownerID, nil
|
|
}
|
|
if request.BusinessOwnerAccountID == nil {
|
|
return nil, nil
|
|
}
|
|
if *request.BusinessOwnerAccountID == 0 {
|
|
return nil, errors.New(errors.CodeInvalidParam, "业务员账号无效")
|
|
}
|
|
var account model.Account
|
|
if err := tx.Where("id = ? AND user_type = ? AND status = ?", *request.BusinessOwnerAccountID, constants.UserTypePlatform, constants.StatusEnabled).
|
|
First(&account).Error; err != nil {
|
|
return nil, errors.New(errors.CodeInvalidParam, "业务员账号无效或不可用")
|
|
}
|
|
ownerID := account.ID
|
|
return &ownerID, nil
|
|
}
|
|
|
|
func resolveInheritedBusinessOwner(_ *gorm.DB, _ *dto.CreateShopRequest, parent *model.Shop) (*uint, error) {
|
|
if parent == nil || parent.BusinessOwnerAccountID == nil {
|
|
return nil, nil
|
|
}
|
|
ownerID := *parent.BusinessOwnerAccountID
|
|
return &ownerID, nil
|
|
}
|
|
|
|
func recordExists(tx *gorm.DB, target any, query string, value any) (bool, error) {
|
|
var count int64
|
|
err := tx.Model(target).Where(query, value).Count(&count).Error
|
|
return count > 0, err
|
|
}
|
|
|
|
func newShopResponse(shop *model.Shop, parentName string) *dto.ShopResponse {
|
|
return &dto.ShopResponse{
|
|
ID: shop.ID, ShopName: shop.ShopName, ShopCode: shop.ShopCode, ParentID: shop.ParentID,
|
|
BusinessOwnerAccountID: shop.BusinessOwnerAccountID,
|
|
ParentShopName: parentName, Level: shop.Level, ContactName: shop.ContactName,
|
|
ContactPhone: shop.ContactPhone, Province: shop.Province, City: shop.City,
|
|
District: shop.District, Address: shop.Address, Status: shop.Status,
|
|
StatusName: constants.GetStatusName(shop.Status), CreatedAt: shop.CreatedAt.Format("2006-01-02 15:04:05"),
|
|
UpdatedAt: shop.UpdatedAt.Format("2006-01-02 15:04:05"),
|
|
}
|
|
}
|
|
|
|
func fillBusinessOwnerResponse(tx *gorm.DB, shop *model.Shop, response *dto.ShopResponse) error {
|
|
if shop.BusinessOwnerAccountID == nil {
|
|
return nil
|
|
}
|
|
var account model.Account
|
|
err := tx.Unscoped().Where("id = ?", *shop.BusinessOwnerAccountID).First(&account).Error
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return errors.Wrap(errors.CodeDatabaseError, err, "查询业务员摘要失败")
|
|
}
|
|
response.BusinessOwnerUsername = account.Username
|
|
response.BusinessOwnerPhoneSummary = maskBusinessOwnerPhone(account.Phone)
|
|
response.BusinessOwnerAvailable = account.UserType == constants.UserTypePlatform && account.Status == constants.StatusEnabled && !account.DeletedAt.Valid
|
|
return nil
|
|
}
|
|
|
|
func maskBusinessOwnerPhone(phone string) string {
|
|
phone = strings.TrimSpace(phone)
|
|
if len(phone) < 7 {
|
|
return ""
|
|
}
|
|
return phone[:3] + "****" + phone[len(phone)-4:]
|
|
}
|