junhong_cmp_fiber/internal/store/postgres/account_store.go

package postgres

import (
	"context"

	"github.com/break/junhong_cmp_fiber/internal/store"

	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

// AccountStore 账号数据访问层
type AccountStore struct {
	db    *gorm.DB
	redis *redis.Client
}

// NewAccountStore 创建账号 Store
func NewAccountStore(db *gorm.DB, redis *redis.Client) *AccountStore {
	return &AccountStore{
		db:    db,
		redis: redis,
	}
}

// Create 创建账号
func (s *AccountStore) Create(ctx context.Context, account *model.Account) error {
	return s.db.WithContext(ctx).Create(account).Error
}

// GetByID 根据 ID 获取账号
func (s *AccountStore) GetByID(ctx context.Context, id uint) (*model.Account, error) {
	var account model.Account
	if err := s.db.WithContext(ctx).First(&account, id).Error; err != nil {
		return nil, err
	}
	return &account, nil
}

// GetByUsername 根据用户名获取账号
func (s *AccountStore) GetByUsername(ctx context.Context, username string) (*model.Account, error) {
	var account model.Account
	if err := s.db.WithContext(ctx).Where("username = ?", username).First(&account).Error; err != nil {
		return nil, err
	}
	return &account, nil
}

// GetByPhone 根据手机号获取账号
func (s *AccountStore) GetByPhone(ctx context.Context, phone string) (*model.Account, error) {
	var account model.Account
	if err := s.db.WithContext(ctx).Where("phone = ?", phone).First(&account).Error; err != nil {
		return nil, err
	}
	return &account, nil
}

// GetByShopID 根据店铺 ID 查询账号列表
func (s *AccountStore) GetByShopID(ctx context.Context, shopID uint) ([]*model.Account, error) {
	var accounts []*model.Account
	if err := s.db.WithContext(ctx).Where("shop_id = ?", shopID).Find(&accounts).Error; err != nil {
		return nil, err
	}
	return accounts, nil
}

// GetByEnterpriseID 根据企业 ID 查询账号列表
func (s *AccountStore) GetByEnterpriseID(ctx context.Context, enterpriseID uint) ([]*model.Account, error) {
	var accounts []*model.Account
	if err := s.db.WithContext(ctx).Where("enterprise_id = ?", enterpriseID).Find(&accounts).Error; err != nil {
		return nil, err
	}
	return accounts, nil
}

// Update 更新账号
func (s *AccountStore) Update(ctx context.Context, account *model.Account) error {
	return s.db.WithContext(ctx).Save(account).Error
}

// Delete 软删除账号
func (s *AccountStore) Delete(ctx context.Context, id uint) error {
	return s.db.WithContext(ctx).Delete(&model.Account{}, id).Error
}

// List 查询账号列表
func (s *AccountStore) List(ctx context.Context, opts *store.QueryOptions, filters map[string]interface{}) ([]*model.Account, int64, error) {
	var accounts []*model.Account
	var total int64

	query := s.db.WithContext(ctx).Model(&model.Account{})

	// 应用过滤条件
	if username, ok := filters["username"].(string); ok && username != "" {
		query = query.Where("username LIKE ?", "%"+username+"%")
	}
	if phone, ok := filters["phone"].(string); ok && phone != "" {
		query = query.Where("phone LIKE ?", "%"+phone+"%")
	}
	if userType, ok := filters["user_type"].(int); ok {
		query = query.Where("user_type = ?", userType)
	}
	if status, ok := filters["status"].(int); ok {
		query = query.Where("status = ?", status)
	}

	// 计算总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 分页
	if opts == nil {
		opts = store.DefaultQueryOptions()
	}
	offset := (opts.Page - 1) * opts.PageSize
	query = query.Offset(offset).Limit(opts.PageSize)

	// 排序
	if opts.OrderBy != "" {
		query = query.Order(opts.OrderBy)
	}

	// 执行查询
	if err := query.Find(&accounts).Error; err != nil {
		return nil, 0, err
	}

	return accounts, total, nil
}