Files
ai_dianshang/server/internal/service/user.go

946 lines
26 KiB
Go
Raw Normal View History

2025-11-17 13:32:54 +08:00
package service
import (
"dianshang/internal/model"
"dianshang/internal/repository"
"dianshang/pkg/jwt"
"errors"
"fmt"
"time"
"gorm.io/gorm"
)
// UserService 用户服务
type UserService struct {
userRepo *repository.UserRepository
db *gorm.DB
}
// NewUserService 创建用户服务
func NewUserService(db *gorm.DB) *UserService {
return &UserService{
userRepo: repository.NewUserRepository(db),
db: db,
}
}
// WeChatLogin 微信登录
func (s *UserService) WeChatLogin(code string) (*model.User, string, error) {
// TODO: 调用微信API获取openid
// 这里暂时模拟
openID := "mock_openid_" + code
// 查找用户
user, err := s.userRepo.GetByOpenID(openID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
// 用户不存在,创建新用户
user = &model.User{
OpenID: openID,
Nickname: "微信用户",
Status: 1,
}
if err := s.userRepo.Create(user); err != nil {
return nil, "", err
}
} else {
return nil, "", err
}
}
// 检查用户状态
if user.Status == 0 {
return nil, "", errors.New("用户已被禁用")
}
// 生成JWT token
token, err := jwt.GenerateToken(user.ID, "user", 7200)
if err != nil {
return nil, "", err
}
return user, token, nil
}
// CreateUser 创建用户
func (s *UserService) CreateUser(user *model.User) error {
// 检查用户是否已存在
existingUser, err := s.userRepo.GetByOpenID(user.OpenID)
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
if existingUser != nil {
return errors.New("用户已存在")
}
return s.userRepo.Create(user)
}
// GetUserByID 根据ID获取用户
func (s *UserService) GetUserByID(id uint) (*model.User, error) {
return s.userRepo.GetByID(id)
}
// UpdateUser 更新用户信息
func (s *UserService) UpdateUser(id uint, updates map[string]interface{}) error {
// 更新用户表
if err := s.userRepo.Update(id, updates); err != nil {
return err
}
// 同步更新微信用户信息表
wechatUpdates := make(map[string]interface{})
if nickname, ok := updates["nickname"]; ok {
wechatUpdates["nick_name"] = nickname
}
if avatar, ok := updates["avatar"]; ok {
wechatUpdates["avatar_url"] = avatar
}
if gender, ok := updates["gender"]; ok {
wechatUpdates["gender"] = gender
}
// 如果有需要更新的微信信息字段
if len(wechatUpdates) > 0 {
wechatUpdates["updated_at"] = time.Now()
// 更新微信用户信息表
if err := s.db.Model(&model.User{}).Where("id = ?", id).Updates(wechatUpdates).Error; err != nil {
// 记录错误但不影响主要更新流程
fmt.Printf("更新微信用户信息失败: %v\n", err)
}
}
return nil
}
// GetUserAddresses 获取用户地址列表
func (s *UserService) GetUserAddresses(userID uint) ([]model.UserAddress, error) {
return s.userRepo.GetAddresses(userID)
}
// GetAddressByID 根据ID获取用户地址
func (s *UserService) GetAddressByID(userID, addressID uint) (*model.UserAddress, error) {
address, err := s.userRepo.GetAddressByID(addressID)
if err != nil {
return nil, err
}
// 检查地址是否属于该用户
if address.UserID != userID {
return nil, errors.New("无权限访问该地址")
}
return address, nil
}
// CreateAddress 创建用户地址
func (s *UserService) CreateAddress(address *model.UserAddress) error {
// 如果设置为默认地址,先取消其他默认地址
if address.IsDefault {
if err := s.userRepo.ClearDefaultAddress(address.UserID); err != nil {
return err
}
}
return s.userRepo.CreateAddress(address)
}
// UpdateAddress 更新用户地址
func (s *UserService) UpdateAddress(userID, addressID uint, updates map[string]interface{}) error {
// 检查地址是否属于该用户
address, err := s.userRepo.GetAddressByID(addressID)
if err != nil {
return err
}
if address.UserID != userID {
return errors.New("无权限操作该地址")
}
// 如果设置为默认地址,先取消其他默认地址
if isDefault, ok := updates["is_default"]; ok && isDefault.(uint8) == 1 {
if err := s.userRepo.ClearDefaultAddress(userID); err != nil {
return err
}
}
return s.userRepo.UpdateAddress(addressID, updates)
}
// DeleteAddress 删除用户地址
func (s *UserService) DeleteAddress(userID, addressID uint) error {
// 检查地址是否属于该用户
address, err := s.userRepo.GetAddressByID(addressID)
if err != nil {
return err
}
if address.UserID != userID {
return errors.New("无权限操作该地址")
}
return s.userRepo.DeleteAddress(addressID)
}
// SetDefaultAddress 设置默认地址
func (s *UserService) SetDefaultAddress(userID, addressID uint) error {
// 检查地址是否属于该用户
address, err := s.userRepo.GetAddressByID(addressID)
if err != nil {
return err
}
if address.UserID != userID {
return errors.New("无权限操作该地址")
}
// 先取消其他默认地址
if err := s.userRepo.ClearDefaultAddress(userID); err != nil {
return err
}
// 设置为默认地址
return s.userRepo.UpdateAddress(addressID, map[string]interface{}{
"is_default": 1,
})
}
// GetFavorites 获取用户收藏列表
func (s *UserService) GetFavorites(userID uint, page, limit int) ([]model.UserFavorite, int64, error) {
offset := (page - 1) * limit
return s.userRepo.GetFavorites(userID, offset, limit)
}
// AddToFavorite 添加收藏
func (s *UserService) AddToFavorite(userID, productID uint) error {
// 检查是否已经收藏
if s.userRepo.IsFavorite(userID, productID) {
return errors.New("商品已在收藏列表中")
}
favorite := &model.UserFavorite{
UserID: userID,
ProductID: productID,
}
return s.userRepo.CreateFavorite(favorite)
}
// RemoveFromFavorite 取消收藏
func (s *UserService) RemoveFromFavorite(userID, productID uint) error {
return s.userRepo.DeleteFavorite(userID, productID)
}
// IsFavorite 检查是否已收藏
func (s *UserService) IsFavorite(userID, productID uint) bool {
return s.userRepo.IsFavorite(userID, productID)
}
// GetUserStatistics 获取用户统计
func (s *UserService) GetUserStatistics(startDate, endDate string) (map[string]interface{}, error) {
result := make(map[string]interface{})
// 总用户数
var totalUsers int64
s.db.Model(&model.User{}).Count(&totalUsers)
result["total_users"] = totalUsers
// 新增用户数(指定日期范围)
var newUsers int64
query := s.db.Model(&model.User{})
if startDate != "" && endDate != "" {
query = query.Where("DATE(created_at) BETWEEN ? AND ?", startDate, endDate)
}
query.Count(&newUsers)
result["new_users"] = newUsers
// 活跃用户数(简化处理,这里用登录用户数代替)
var activeUsers int64
activeQuery := s.db.Model(&model.User{}).Where("status = ?", 1)
if startDate != "" && endDate != "" {
activeQuery = activeQuery.Where("DATE(updated_at) BETWEEN ? AND ?", startDate, endDate)
}
activeQuery.Count(&activeUsers)
result["active_users"] = activeUsers
return result, nil
}
// GetDailyUserStatistics 获取每日用户统计
func (s *UserService) GetDailyUserStatistics(startDate, endDate string) ([]map[string]interface{}, error) {
// 简化实现,返回基础统计数据
var results []map[string]interface{}
// 解析日期
start, err := time.Parse("2006-01-02", startDate)
if err != nil {
return nil, err
}
end, err := time.Parse("2006-01-02", endDate)
if err != nil {
return nil, err
}
// 遍历日期范围
for d := start; !d.After(end); d = d.AddDate(0, 0, 1) {
dateStr := d.Format("2006-01-02")
var newUsers int64
s.db.Model(&model.User{}).
Where("DATE(created_at) = ?", dateStr).
Count(&newUsers)
results = append(results, map[string]interface{}{
"date": dateStr,
"new_users": newUsers,
})
}
return results, nil
}
// GetUserListForAdmin 获取用户列表(管理后台)
func (s *UserService) GetUserListForAdmin(page, pageSize int, conditions map[string]interface{}) ([]model.User, map[string]interface{}, error) {
var users []model.User
var total int64
query := s.db.Model(&model.User{})
// 应用查询条件
if keyword, ok := conditions["keyword"]; ok && keyword != "" {
query = query.Where("nickname LIKE ? OR email LIKE ? OR phone LIKE ?",
"%"+keyword.(string)+"%", "%"+keyword.(string)+"%", "%"+keyword.(string)+"%")
}
if status, ok := conditions["status"]; ok && status != "" {
query = query.Where("status = ?", status)
}
if startDate, ok := conditions["start_date"]; ok && startDate != "" {
query = query.Where("created_at >= ?", startDate)
}
if endDate, ok := conditions["end_date"]; ok && endDate != "" {
query = query.Where("created_at <= ?", endDate)
}
// 获取总数
err := query.Count(&total).Error
if err != nil {
return nil, nil, err
}
// 分页查询
offset := (page - 1) * pageSize
err = query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&users).Error
if err != nil {
return nil, nil, err
}
// 构建分页信息
pagination := map[string]interface{}{
"total": total,
"page": page,
"page_size": pageSize,
"total_pages": (total + int64(pageSize) - 1) / int64(pageSize),
}
return users, pagination, nil
}
// GetUserDetailForAdmin 获取用户详情(管理后台)
func (s *UserService) GetUserDetailForAdmin(userID uint) (map[string]interface{}, error) {
var user model.User
err := s.db.Where("id = ?", userID).First(&user).Error
if err != nil {
return nil, err
}
// 构建返回数据
result := map[string]interface{}{
"id": user.ID,
"openid": user.OpenID,
"unionid": user.UnionID,
"nickname": user.Nickname,
"avatar": user.Avatar,
"gender": user.Gender,
"phone": user.Phone,
"email": user.Email,
"birthday": user.Birthday,
"points": user.Points,
"level": user.Level,
"status": user.Status,
"created_at": user.CreatedAt,
"updated_at": user.UpdatedAt,
}
return result, nil
}
// UpdateUserStatusByAdmin 管理员更新用户状态
func (s *UserService) UpdateUserStatusByAdmin(userID uint, status uint8, remark string, adminID uint) error {
return s.db.Model(&model.User{}).Where("id = ?", userID).Update("status", status).Error
}
// UpdateUserProfile 更新用户资料
func (s *UserService) UpdateUserProfile(userID uint, updates map[string]interface{}) error {
// 验证更新字段
allowedFields := map[string]bool{
"nickname": true,
"avatar": true,
"gender": true,
"phone": true,
"email": true,
"birthday": true,
}
filteredUpdates := make(map[string]interface{})
for key, value := range updates {
if allowedFields[key] {
filteredUpdates[key] = value
}
}
if len(filteredUpdates) == 0 {
return fmt.Errorf("没有有效的更新字段")
}
filteredUpdates["updated_at"] = time.Now()
return s.db.Model(&model.User{}).Where("id = ?", userID).Updates(filteredUpdates).Error
}
// UpdateUserProfileByAdmin 管理员更新用户资料
func (s *UserService) UpdateUserProfileByAdmin(userID uint, updates map[string]interface{}, adminID uint) error {
// 验证更新字段
allowedFields := map[string]bool{
"nickname": true,
"avatar": true,
"gender": true,
"phone": true,
"email": true,
"birthday": true,
}
filteredUpdates := make(map[string]interface{})
for key, value := range updates {
if allowedFields[key] {
filteredUpdates[key] = value
}
}
if len(filteredUpdates) == 0 {
return fmt.Errorf("没有有效的更新字段")
}
filteredUpdates["updated_at"] = time.Now()
// TODO: 记录操作日志
// 可以在这里添加操作日志记录,记录管理员修改用户资料的操作
return s.db.Model(&model.User{}).Where("id = ?", userID).Updates(filteredUpdates).Error
}
// ResetUserPassword 重置用户密码(管理员操作)
func (s *UserService) ResetUserPassword(userID uint, newPassword string, adminID uint) error {
// 这里可以添加密码加密逻辑
// 由于是微信小程序,通常不需要密码,这里预留接口
updates := map[string]interface{}{
"updated_at": time.Now(),
}
return s.db.Model(&model.User{}).Where("id = ?", userID).Updates(updates).Error
}
// CreateUserAddress 创建用户地址
func (s *UserService) CreateUserAddress(address *model.UserAddress) error {
// 如果设置为默认地址,先取消其他默认地址
if address.IsDefault {
s.db.Model(&model.UserAddress{}).Where("user_id = ?", address.UserID).Update("is_default", false)
}
return s.db.Create(address).Error
}
// UpdateUserAddress 更新用户地址
func (s *UserService) UpdateUserAddress(addressID uint, userID uint, updates map[string]interface{}) error {
// 如果设置为默认地址,先取消其他默认地址
if isDefault, ok := updates["is_default"]; ok && isDefault.(bool) {
s.db.Model(&model.UserAddress{}).Where("user_id = ?", userID).Update("is_default", false)
}
updates["updated_at"] = time.Now()
return s.db.Model(&model.UserAddress{}).Where("id = ? AND user_id = ?", addressID, userID).Updates(updates).Error
}
// DeleteUserAddress 删除用户地址
func (s *UserService) DeleteUserAddress(addressID uint, userID uint) error {
return s.db.Where("id = ? AND user_id = ?", addressID, userID).Delete(&model.UserAddress{}).Error
}
// GetUserFavorites 获取用户收藏列表
func (s *UserService) GetUserFavorites(userID uint, page, pageSize int) ([]model.UserFavorite, map[string]interface{}, error) {
var favorites []model.UserFavorite
var total int64
query := s.db.Model(&model.UserFavorite{}).Where("user_id = ?", userID).Preload("Product")
// 获取总数
err := query.Count(&total).Error
if err != nil {
return nil, nil, err
}
// 分页查询
offset := (page - 1) * pageSize
err = query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&favorites).Error
if err != nil {
return nil, nil, err
}
// 构建分页信息
pagination := map[string]interface{}{
"total": total,
"page": page,
"page_size": pageSize,
"total_pages": (total + int64(pageSize) - 1) / int64(pageSize),
}
return favorites, pagination, nil
}
// AddUserFavorite 添加用户收藏
func (s *UserService) AddUserFavorite(userID, productID uint) error {
// 检查是否已收藏
var count int64
s.db.Model(&model.UserFavorite{}).Where("user_id = ? AND product_id = ?", userID, productID).Count(&count)
if count > 0 {
return fmt.Errorf("商品已收藏")
}
favorite := &model.UserFavorite{
UserID: userID,
ProductID: productID,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
return s.db.Create(favorite).Error
}
// RemoveUserFavorite 移除用户收藏
func (s *UserService) RemoveUserFavorite(userID, productID uint) error {
return s.db.Where("user_id = ? AND product_id = ?", userID, productID).Delete(&model.UserFavorite{}).Error
}
// GetUserLevelInfo 获取用户等级信息
func (s *UserService) GetUserLevelInfo(userID uint) (map[string]interface{}, error) {
user, err := s.GetUserByID(userID)
if err != nil {
return nil, err
}
// 计算用户等级相关信息
levelInfo := map[string]interface{}{
"current_level": user.Level,
"current_points": user.Points,
"level_name": s.getLevelName(user.Level),
"next_level": user.Level + 1,
"next_level_name": s.getLevelName(user.Level + 1),
"points_to_next": s.getPointsToNextLevel(user.Level, user.Points),
}
return levelInfo, nil
}
// getLevelName 获取等级名称
func (s *UserService) getLevelName(level int) string {
levelNames := map[int]string{
1: "青铜会员",
2: "白银会员",
3: "黄金会员",
4: "铂金会员",
5: "钻石会员",
}
if name, ok := levelNames[level]; ok {
return name
}
return "普通会员"
}
// getPointsToNextLevel 获取升级到下一等级所需积分
func (s *UserService) getPointsToNextLevel(currentLevel, currentPoints int) int {
levelThresholds := map[int]int{
1: 0,
2: 1000,
3: 3000,
4: 6000,
5: 10000,
}
nextLevel := currentLevel + 1
if threshold, ok := levelThresholds[nextLevel]; ok {
return threshold - currentPoints
}
return 0 // 已达到最高等级
}
// UpdateUserLevel 更新用户等级
func (s *UserService) UpdateUserLevel(userID uint) error {
user, err := s.GetUserByID(userID)
if err != nil {
return err
}
newLevel := s.calculateUserLevel(user.Points)
if newLevel != user.Level {
return s.db.Model(&model.User{}).Where("id = ?", userID).Update("level", newLevel).Error
}
return nil
}
// UpdateUserLevelByAdmin 管理员手动设置用户等级
func (s *UserService) UpdateUserLevelByAdmin(userID uint, level uint8, remark string, adminID uint) error {
// 验证等级范围
if level < 1 || level > 5 {
return errors.New("用户等级必须在1-5之间")
}
// 更新用户等级
err := s.db.Model(&model.User{}).Where("id = ?", userID).Update("level", level).Error
if err != nil {
return err
}
// TODO: 记录操作日志
// 可以在这里添加操作日志记录,记录管理员修改用户等级的操作
return nil
}
// calculateUserLevel 根据积分计算用户等级
func (s *UserService) calculateUserLevel(points int) int {
if points >= 10000 {
return 5
} else if points >= 6000 {
return 4
} else if points >= 3000 {
return 3
} else if points >= 1000 {
return 2
}
return 1
}
// ResetUserPasswordByAdmin 管理员重置用户密码
func (s *UserService) ResetUserPasswordByAdmin(userID uint, newPassword string, adminID uint) error {
// 这里应该对密码进行加密处理,暂时简化实现
// 在实际项目中,用户可能通过微信登录,不需要密码
// 这里只是为了满足接口需求
return s.db.Model(&model.User{}).Where("id = ?", userID).Update("updated_at", time.Now()).Error
}
// GetUserLoginLogs 获取用户登录日志
func (s *UserService) GetUserLoginLogs(userID uint, page, pageSize int) ([]map[string]interface{}, map[string]interface{}, error) {
// 使用LogService获取真实的登录日志数据
logService := NewLogService(s.db)
logs, pagination, err := logService.GetUserLoginLogs(userID, page, pageSize)
if err != nil {
return nil, nil, err
}
// 转换为前端需要的格式
var result []map[string]interface{}
for _, log := range logs {
result = append(result, map[string]interface{}{
"id": log.ID,
"user_id": log.UserID,
"login_time": log.LoginTime.Format("2006-01-02 15:04:05"),
"ip_address": log.LoginIP,
"device": log.UserAgent,
"location": "未知", // 可以后续添加IP地址解析功能
"status": log.Status,
"remark": log.Remark,
})
}
return result, pagination, nil
}
// GetUserPurchaseRanking 获取用户购买排行
func (s *UserService) GetUserPurchaseRanking(startDate, endDate, limit string) ([]map[string]interface{}, error) {
// 简化实现,返回基础排行数据
var results []map[string]interface{}
// 获取活跃用户
var users []model.User
err := s.db.Model(&model.User{}).
Where("status = ?", 1).
Limit(10).
Find(&users).Error
if err != nil {
return nil, err
}
for i, user := range users {
results = append(results, map[string]interface{}{
"user_id": user.ID,
"nickname": user.Nickname,
"purchase_count": 50 - i*3, // 模拟购买次数
"purchase_amount": float64(5000 - i*200), // 模拟购买金额
})
}
return results, nil
}
// GetUserGrowthTrend 获取用户增长趋势
func (s *UserService) GetUserGrowthTrend(days int) ([]map[string]interface{}, error) {
var results []map[string]interface{}
for i := days - 1; i >= 0; i-- {
date := time.Now().AddDate(0, 0, -i).Format("2006-01-02")
// 新增用户数
var newUsers int64
s.db.Model(&model.User{}).
Where("DATE(created_at) = ?", date).
Count(&newUsers)
// 累计用户数
var totalUsers int64
s.db.Model(&model.User{}).
Where("DATE(created_at) <= ?", date).
Count(&totalUsers)
// 活跃用户数(当天有更新记录的用户)
var activeUsers int64
s.db.Model(&model.User{}).
Where("DATE(updated_at) = ? AND status = ?", date, 1).
Count(&activeUsers)
results = append(results, map[string]interface{}{
"date": date,
"new_users": newUsers,
"total_users": totalUsers,
"active_users": activeUsers,
})
}
return results, nil
}
// GetUserActivityAnalysis 获取用户活跃度分析
func (s *UserService) GetUserActivityAnalysis(startDate, endDate string) (map[string]interface{}, error) {
result := make(map[string]interface{})
// 总用户数
var totalUsers int64
s.db.Model(&model.User{}).Count(&totalUsers)
// 活跃用户数(指定时间范围内有更新的用户)
var activeUsers int64
query := s.db.Model(&model.User{}).Where("status = ?", 1)
if startDate != "" && endDate != "" {
query = query.Where("DATE(updated_at) BETWEEN ? AND ?", startDate, endDate)
}
query.Count(&activeUsers)
// 新增用户数
var newUsers int64
newQuery := s.db.Model(&model.User{})
if startDate != "" && endDate != "" {
newQuery = newQuery.Where("DATE(created_at) BETWEEN ? AND ?", startDate, endDate)
}
newQuery.Count(&newUsers)
// 沉默用户数30天内无活动的用户
thirtyDaysAgo := time.Now().AddDate(0, 0, -30).Format("2006-01-02")
var silentUsers int64
s.db.Model(&model.User{}).
Where("status = ? AND DATE(updated_at) < ?", 1, thirtyDaysAgo).
Count(&silentUsers)
// 计算活跃率
var activityRate float64
if totalUsers > 0 {
activityRate = float64(activeUsers) / float64(totalUsers) * 100
}
result["total_users"] = totalUsers
result["active_users"] = activeUsers
result["new_users"] = newUsers
result["silent_users"] = silentUsers
result["activity_rate"] = activityRate
return result, nil
}
// GetUserRetentionRate 获取用户留存率
func (s *UserService) GetUserRetentionRate(days int) ([]map[string]interface{}, error) {
var results []map[string]interface{}
for i := days - 1; i >= 0; i-- {
date := time.Now().AddDate(0, 0, -i).Format("2006-01-02")
nextDate := time.Now().AddDate(0, 0, -i+1).Format("2006-01-02")
// 当天新增用户数
var newUsers int64
s.db.Model(&model.User{}).
Where("DATE(created_at) = ?", date).
Count(&newUsers)
// 次日留存用户数(当天新增且次日有活动的用户)
var retainedUsers int64
if i > 0 { // 确保有次日数据
s.db.Model(&model.User{}).
Where("DATE(created_at) = ? AND DATE(updated_at) = ?", date, nextDate).
Count(&retainedUsers)
}
// 计算留存率
var retentionRate float64
if newUsers > 0 {
retentionRate = float64(retainedUsers) / float64(newUsers) * 100
}
results = append(results, map[string]interface{}{
"date": date,
"new_users": newUsers,
"retained_users": retainedUsers,
"retention_rate": retentionRate,
})
}
return results, nil
}
// GetUserLevelDistribution 获取用户等级分布
func (s *UserService) GetUserLevelDistribution() ([]map[string]interface{}, error) {
var results []map[string]interface{}
// 统计各等级用户数量
for level := 1; level <= 5; level++ {
var count int64
s.db.Model(&model.User{}).
Where("level = ? AND status = ?", level, 1).
Count(&count)
results = append(results, map[string]interface{}{
"level": level,
"level_name": s.getLevelName(level),
"user_count": count,
})
}
return results, nil
}
// GetUserGeographicDistribution 获取用户地域分布
func (s *UserService) GetUserGeographicDistribution() ([]map[string]interface{}, error) {
// 简化实现,返回模拟的地域分布数据
// 在实际项目中可以根据用户地址或IP地址统计
regions := []map[string]interface{}{
{"region": "北京", "user_count": 1200},
{"region": "上海", "user_count": 980},
{"region": "广州", "user_count": 750},
{"region": "深圳", "user_count": 680},
{"region": "杭州", "user_count": 520},
{"region": "成都", "user_count": 450},
{"region": "武汉", "user_count": 380},
{"region": "西安", "user_count": 320},
{"region": "南京", "user_count": 280},
{"region": "其他", "user_count": 1430},
}
return regions, nil
}
// GetUserAgeDistribution 获取用户年龄分布
func (s *UserService) GetUserAgeDistribution() ([]map[string]interface{}, error) {
// 简化实现,返回模拟的年龄分布数据
// 在实际项目中,可以根据用户生日计算年龄分布
ageGroups := []map[string]interface{}{
{"age_group": "18-25", "user_count": 1500},
{"age_group": "26-30", "user_count": 2200},
{"age_group": "31-35", "user_count": 1800},
{"age_group": "36-40", "user_count": 1200},
{"age_group": "41-50", "user_count": 800},
{"age_group": "50+", "user_count": 500},
}
return ageGroups, nil
}
// GetUserEngagementMetrics 获取用户参与度指标
func (s *UserService) GetUserEngagementMetrics(startDate, endDate string) (map[string]interface{}, error) {
result := make(map[string]interface{})
// 平均会话时长(模拟数据)
result["avg_session_duration"] = 25.5 // 分钟
// 页面浏览量(模拟数据)
result["page_views"] = 15680
// 跳出率(模拟数据)
result["bounce_rate"] = 35.2 // 百分比
// 用户互动次数(收藏、评价等)
var favoriteCount int64
query := s.db.Model(&model.UserFavorite{})
if startDate != "" && endDate != "" {
query = query.Where("DATE(created_at) BETWEEN ? AND ?", startDate, endDate)
}
query.Count(&favoriteCount)
result["favorite_count"] = favoriteCount
// 活跃用户数
var activeUsers int64
userQuery := s.db.Model(&model.User{}).Where("status = ?", 1)
if startDate != "" && endDate != "" {
userQuery = userQuery.Where("DATE(updated_at) BETWEEN ? AND ?", startDate, endDate)
}
userQuery.Count(&activeUsers)
result["active_users"] = activeUsers
return result, nil
}
// DeleteUser 删除用户
func (s *UserService) DeleteUser(userID uint) error {
// 软删除用户
return s.db.Delete(&model.User{}, userID).Error
}
// BatchDeleteUsers 批量删除用户
func (s *UserService) BatchDeleteUsers(userIDs []uint) error {
// 批量软删除用户
return s.db.Delete(&model.User{}, userIDs).Error
}
// DeleteUserByAdmin 管理员删除用户
func (s *UserService) DeleteUserByAdmin(userID uint, adminID uint, remark string) error {
// TODO: 记录操作日志
// 可以在这里添加操作日志记录,记录管理员删除用户的操作
// 软删除用户
return s.db.Delete(&model.User{}, userID).Error
}
// BatchDeleteUsersByAdmin 管理员批量删除用户
func (s *UserService) BatchDeleteUsersByAdmin(userIDs []uint, adminID uint, remark string) error {
// TODO: 记录操作日志
// 可以在这里添加操作日志记录,记录管理员批量删除用户的操作
// 批量软删除用户
return s.db.Delete(&model.User{}, userIDs).Error
}