junhong_cmp_fiber/internal/service/shop_account/service.go

package shop_account

import (
	"context"

	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	"github.com/break/junhong_cmp_fiber/internal/store"
	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/errors"
	"github.com/break/junhong_cmp_fiber/pkg/middleware"
	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"
)

type Service struct {
	accountStore *postgres.AccountStore
	shopStore    *postgres.ShopStore
}

func New(accountStore *postgres.AccountStore, shopStore *postgres.ShopStore) *Service {
	return &Service{
		accountStore: accountStore,
		shopStore:    shopStore,
	}
}

func (s *Service) List(ctx context.Context, req *dto.ShopAccountListRequest) ([]*dto.ShopAccountResponse, int64, error) {
	opts := &store.QueryOptions{
		Page:     req.Page,
		PageSize: req.PageSize,
		OrderBy:  "created_at DESC",
	}
	if opts.Page == 0 {
		opts.Page = 1
	}
	if opts.PageSize == 0 {
		opts.PageSize = constants.DefaultPageSize
	}

	filters := make(map[string]interface{})
	filters["user_type"] = constants.UserTypeAgent
	if req.Username != "" {
		filters["username"] = req.Username
	}
	if req.Phone != "" {
		filters["phone"] = req.Phone
	}
	if req.Status != nil {
		filters["status"] = *req.Status
	}

	var accounts []*model.Account
	var total int64
	var err error

	if req.ShopID != nil {
		accounts, total, err = s.accountStore.ListByShopID(ctx, *req.ShopID, opts, filters)
	} else {
		filters["user_type"] = constants.UserTypeAgent
		accounts, total, err = s.accountStore.List(ctx, opts, filters)
	}

	if err != nil {
		return nil, 0, errors.Wrap(errors.CodeInternalError, err, "查询代理商账号列表失败")
	}

	shopMap := make(map[uint]string)
	for _, account := range accounts {
		if account.ShopID != nil {
			if _, exists := shopMap[*account.ShopID]; !exists {
				shop, err := s.shopStore.GetByID(ctx, *account.ShopID)
				if err == nil {
					shopMap[*account.ShopID] = shop.ShopName
				}
			}
		}
	}

	responses := make([]*dto.ShopAccountResponse, 0, len(accounts))
	for _, account := range accounts {
		resp := &dto.ShopAccountResponse{
			ID:        account.ID,
			Username:  account.Username,
			Phone:     account.Phone,
			UserType:  account.UserType,
			Status:    account.Status,
			CreatedAt: account.CreatedAt.Format("2006-01-02 15:04:05"),
			UpdatedAt: account.UpdatedAt.Format("2006-01-02 15:04:05"),
		}
		if account.ShopID != nil {
			resp.ShopID = *account.ShopID
			if shopName, ok := shopMap[*account.ShopID]; ok {
				resp.ShopName = shopName
			}
		}
		responses = append(responses, resp)
	}

	return responses, total, nil
}

func (s *Service) Create(ctx context.Context, req *dto.CreateShopAccountRequest) (*dto.ShopAccountResponse, error) {
	currentUserID := middleware.GetUserIDFromContext(ctx)
	if currentUserID == 0 {
		return nil, errors.New(errors.CodeUnauthorized, "未授权访问")
	}

	shop, err := s.shopStore.GetByID(ctx, req.ShopID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.New(errors.CodeShopNotFound, "店铺不存在")
		}
		return nil, errors.Wrap(errors.CodeInternalError, err, "获取店铺失败")
	}

	existing, err := s.accountStore.GetByUsername(ctx, req.Username)
	if err == nil && existing != nil {
		return nil, errors.New(errors.CodeUsernameExists, "用户名已存在")
	}

	existing, err = s.accountStore.GetByPhone(ctx, req.Phone)
	if err == nil && existing != nil {
		return nil, errors.New(errors.CodePhoneExists, "手机号已存在")
	}

	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
	if err != nil {
		return nil, errors.Wrap(errors.CodeInternalError, err, "密码哈希失败")
	}

	account := &model.Account{
		Username: req.Username,
		Phone:    req.Phone,
		Password: string(hashedPassword),
		UserType: constants.UserTypeAgent,
		ShopID:   &req.ShopID,
		Status:   constants.StatusEnabled,
	}
	account.Creator = currentUserID
	account.Updater = currentUserID

	if err := s.accountStore.Create(ctx, account); err != nil {
		return nil, errors.Wrap(errors.CodeInternalError, err, "创建代理商账号失败")
	}

	return &dto.ShopAccountResponse{
		ID:        account.ID,
		ShopID:    *account.ShopID,
		ShopName:  shop.ShopName,
		Username:  account.Username,
		Phone:     account.Phone,
		UserType:  account.UserType,
		Status:    account.Status,
		CreatedAt: account.CreatedAt.Format("2006-01-02 15:04:05"),
		UpdatedAt: account.UpdatedAt.Format("2006-01-02 15:04:05"),
	}, nil
}

func (s *Service) Update(ctx context.Context, id uint, req *dto.UpdateShopAccountRequest) (*dto.ShopAccountResponse, error) {
	currentUserID := middleware.GetUserIDFromContext(ctx)
	if currentUserID == 0 {
		return nil, errors.New(errors.CodeUnauthorized, "未授权访问")
	}

	account, err := s.accountStore.GetByID(ctx, id)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.New(errors.CodeAccountNotFound, "账号不存在")
		}
		return nil, errors.Wrap(errors.CodeInternalError, err, "获取账号失败")
	}

	if account.UserType != constants.UserTypeAgent {
		return nil, errors.New(errors.CodeInvalidParam, "只能更新代理商账号")
	}

	existingAccount, err := s.accountStore.GetByUsername(ctx, req.Username)
	if err == nil && existingAccount != nil && existingAccount.ID != id {
		return nil, errors.New(errors.CodeUsernameExists, "用户名已存在")
	}

	account.Username = req.Username
	account.Updater = currentUserID

	if err := s.accountStore.Update(ctx, account); err != nil {
		return nil, errors.Wrap(errors.CodeInternalError, err, "更新代理商账号失败")
	}

	var shopName string
	if account.ShopID != nil {
		shop, err := s.shopStore.GetByID(ctx, *account.ShopID)
		if err == nil {
			shopName = shop.ShopName
		}
	}

	return &dto.ShopAccountResponse{
		ID:        account.ID,
		ShopID:    *account.ShopID,
		ShopName:  shopName,
		Username:  account.Username,
		Phone:     account.Phone,
		UserType:  account.UserType,
		Status:    account.Status,
		CreatedAt: account.CreatedAt.Format("2006-01-02 15:04:05"),
		UpdatedAt: account.UpdatedAt.Format("2006-01-02 15:04:05"),
	}, nil
}

func (s *Service) UpdatePassword(ctx context.Context, id uint, req *dto.UpdateShopAccountPasswordRequest) error {
	currentUserID := middleware.GetUserIDFromContext(ctx)
	if currentUserID == 0 {
		return errors.New(errors.CodeUnauthorized, "未授权访问")
	}

	account, err := s.accountStore.GetByID(ctx, id)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New(errors.CodeAccountNotFound, "账号不存在")
		}
		return errors.Wrap(errors.CodeInternalError, err, "获取账号失败")
	}

	if account.UserType != constants.UserTypeAgent {
		return errors.New(errors.CodeInvalidParam, "只能更新代理商账号密码")
	}

	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
	if err != nil {
		return errors.Wrap(errors.CodeInternalError, err, "密码哈希失败")
	}

	if err := s.accountStore.UpdatePassword(ctx, id, string(hashedPassword), currentUserID); err != nil {
		return errors.Wrap(errors.CodeInternalError, err, "更新密码失败")
	}

	return nil
}

func (s *Service) UpdateStatus(ctx context.Context, id uint, req *dto.UpdateShopAccountStatusRequest) error {
	currentUserID := middleware.GetUserIDFromContext(ctx)
	if currentUserID == 0 {
		return errors.New(errors.CodeUnauthorized, "未授权访问")
	}

	account, err := s.accountStore.GetByID(ctx, id)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New(errors.CodeAccountNotFound, "账号不存在")
		}
		return errors.Wrap(errors.CodeInternalError, err, "获取账号失败")
	}

	if account.UserType != constants.UserTypeAgent {
		return errors.New(errors.CodeInvalidParam, "只能更新代理商账号状态")
	}

	if err := s.accountStore.UpdateStatus(ctx, id, req.Status, currentUserID); err != nil {
		return errors.Wrap(errors.CodeInternalError, err, "更新账号状态失败")
	}

	return nil
}