diff --git a/Haoliang.Core/Services/StubServices.cs b/Haoliang.Core/Services/StubServices.cs
index 56957fa..c27610d 100644
--- a/Haoliang.Core/Services/StubServices.cs
+++ b/Haoliang.Core/Services/StubServices.cs
@@ -20,35 +20,176 @@ using Haoliang.Models.Production;
 using Haoliang.Models.System;
 using Haoliang.Models.Template;
 using Haoliang.Models.DataCollection;
+using Haoliang.Data.Repositories;
 
 namespace Haoliang.Core.Services
 {
     #region ========== 用户与认证服务 ==========
     public class AuthService : IAuthService
     {
-        public Task<AuthResult> LoginAsync(LoginRequest request) => Task.FromResult<AuthResult>(null);
-        public Task<bool> LogoutAsync(int userId) => Task.FromResult(false);
+        private readonly IUserRepository _userRepository;
+        private readonly ICacheService _cache;
+        
+        public AuthService(IUserRepository userRepository, ICacheService cache)
+        {
+            _userRepository = userRepository;
+            _cache = cache;
+        }
+        
+        public async Task<AuthResult> LoginAsync(LoginRequest request)
+        {
+            var user = await _userRepository.AuthenticateAsync(request.Username, request.Password);
+            if (user == null)
+            {
+                return new AuthResult
+                {
+                    Success = false,
+                    Message = "用户名或密码错误"
+                };
+            }
+            
+            return new AuthResult
+            {
+                Success = true,
+                User = user,
+                Message = "登录成功",
+                Permissions = user.Role?.Permissions ?? new List<string>()
+            };
+        }
+        
+        public Task<bool> LogoutAsync(int userId) => Task.FromResult(true);
+        
         public Task<AuthResult> RefreshTokenAsync(string refreshToken) => Task.FromResult<AuthResult>(null);
-        public Task<bool> UsernameExistsAsync(string username) => Task.FromResult(false);
-        public Task<bool> EmailExistsAsync(string email) => Task.FromResult(false);
-        public Task<User> GetUserByIdAsync(int userId) => Task.FromResult<User>(null);
+        
+        public Task<bool> UsernameExistsAsync(string username) => _userRepository.UsernameExistsAsync(username);
+        
+        public Task<bool> EmailExistsAsync(string email) => _userRepository.EmailExistsAsync(email);
+        
+        public async Task<User> GetUserByIdAsync(int userId)
+        {
+            return await _userRepository.GetByIdAsync(userId);
+        }
     }
 
     public class UserService : IUserService
     {
-        public Task<UserViewModel> CreateUserAsync(User user) => Task.FromResult<UserViewModel>(null);
-        public Task<UserViewModel> GetUserByIdAsync(int userId) => Task.FromResult<UserViewModel>(null);
-        public Task<IEnumerable<UserViewModel>> GetAllUsersAsync() => Task.FromResult<IEnumerable<UserViewModel>>(new List<UserViewModel>());
-        public Task<UserViewModel> UpdateUserAsync(int userId, User user) => Task.FromResult<UserViewModel>(null);
-        public Task<bool> ChangePasswordAsync(int userId, string oldPassword, string newPassword) => Task.FromResult(false);
-        public Task<bool> ActivateUserAsync(int userId) => Task.FromResult(false);
-        public Task<bool> DeactivateUserAsync(int userId) => Task.FromResult(false);
+        private readonly IUserRepository _userRepository;
+        
+        public UserService(IUserRepository userRepository)
+        {
+            _userRepository = userRepository;
+        }
+        
+        public async Task<UserViewModel> CreateUserAsync(User user)
+        {
+            user.CreatedAt = DateTime.Now;
+            user.UpdatedAt = DateTime.Now;
+            await _userRepository.AddAsync(user);
+            await _userRepository.SaveAsync();
+            
+            return MapToUserViewModel(user);
+        }
+        
+        public async Task<UserViewModel?> GetUserByIdAsync(int userId)
+        {
+            var user = await _userRepository.GetByIdAsync(userId);
+            return user != null ? MapToUserViewModel(user) : null;
+        }
+        
+        public async Task<IEnumerable<UserViewModel>> GetAllUsersAsync()
+        {
+            var users = await _userRepository.GetAllAsync();
+            return users.Select(MapToUserViewModel);
+        }
+        
+        public async Task<UserViewModel?> UpdateUserAsync(int userId, User user)
+        {
+            var existingUser = await _userRepository.GetByIdAsync(userId);
+            if (existingUser == null)
+                return null;
+            
+            existingUser.RealName = user.RealName;
+            existingUser.Email = user.Email;
+            existingUser.Phone = user.Phone;
+            existingUser.Department = user.Department;
+            existingUser.RoleId = user.RoleId;
+            existingUser.IsActive = user.IsActive;
+            existingUser.UpdatedAt = DateTime.Now;
+            
+            _userRepository.Update(existingUser);
+            await _userRepository.SaveAsync();
+            
+            return MapToUserViewModel(existingUser);
+        }
+        
+        public Task<bool> ChangePasswordAsync(int userId, string oldPassword, string newPassword) 
+            => _userRepository.ChangePasswordAsync(userId, oldPassword, newPassword);
+        
+        public async Task<bool> ActivateUserAsync(int userId)
+        {
+            var user = await _userRepository.GetByIdAsync(userId);
+            if (user == null) return false;
+            
+            user.IsActive = true;
+            user.UpdatedAt = DateTime.Now;
+            _userRepository.Update(user);
+            await _userRepository.SaveAsync();
+            return true;
+        }
+        
+        public async Task<bool> DeactivateUserAsync(int userId)
+        {
+            var user = await _userRepository.GetByIdAsync(userId);
+            if (user == null) return false;
+            
+            user.IsActive = false;
+            user.UpdatedAt = DateTime.Now;
+            _userRepository.Update(user);
+            await _userRepository.SaveAsync();
+            return true;
+        }
+        
+        private UserViewModel MapToUserViewModel(User user)
+        {
+            return new UserViewModel
+            {
+                Id = user.Id,
+                Username = user.Username,
+                RealName = user.RealName,
+                Email = user.Email,
+                Phone = user.Phone,
+                Role = user.Role?.RoleName,
+                RoleName = user.Role?.RoleName,
+                Department = user.Department,
+                IsActive = user.IsActive,
+                LastLoginTime = user.LastLoginTime,
+                CreatedAt = user.CreatedAt,
+                Permissions = user.Role?.Permissions ?? new List<string>()
+            };
+        }
     }
 
     public class PermissionService : IPermissionService
     {
-        public Task<IEnumerable<string>> GetUserPermissionsAsync(int userId) => Task.FromResult<IEnumerable<string>>(new List<string>());
-        public Task<bool> HasPermissionAsync(int userId, string permission) => Task.FromResult(false);
+        private readonly IUserRepository _userRepository;
+        
+        public PermissionService(IUserRepository userRepository)
+        {
+            _userRepository = userRepository;
+        }
+        
+        public async Task<IEnumerable<string>> GetUserPermissionsAsync(int userId)
+        {
+            var user = await _userRepository.GetByIdAsync(userId);
+            return user?.Role?.Permissions ?? new List<string>();
+        }
+        
+        public async Task<bool> HasPermissionAsync(int userId, string permission)
+        {
+            var permissions = await GetUserPermissionsAsync(userId);
+            return permissions.Contains(permission);
+        }
+        
         public Task AssignPermissionsToUserAsync(int userId, IEnumerable<string> permissions) => Task.CompletedTask;
         public Task RemoveAllPermissionsFromUserAsync(int userId) => Task.CompletedTask;
     }