初始化

2025-10-16 09:56:36 +08:00
commit de704db577
272 changed files with 37331 additions and 0 deletions
--- a/FutureMailAPI/Controllers/AIAssistantController.cs
+++ b/FutureMailAPI/Controllers/AIAssistantController.cs
@@ -0,0 +1,74 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/ai")]
+    [Authorize]
+    public class AIAssistantController : ControllerBase
+    {
+        private readonly IAIAssistantService _aiAssistantService;
+        
+        public AIAssistantController(IAIAssistantService aiAssistantService)
+        {
+            _aiAssistantService = aiAssistantService;
+        }
+        
+        [HttpPost("writing-assistant")]
+        public async Task<ActionResult<ApiResponse<WritingAssistantResponseDto>>> GetWritingAssistance([FromBody] WritingAssistantRequestDto request)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<WritingAssistantResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            var result = await _aiAssistantService.GetWritingAssistanceAsync(request);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("sentiment-analysis")]
+        public async Task<ActionResult<ApiResponse<SentimentAnalysisResponseDto>>> AnalyzeSentiment([FromBody] SentimentAnalysisRequestDto request)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<SentimentAnalysisResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            var result = await _aiAssistantService.AnalyzeSentimentAsync(request);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("future-prediction")]
+        public async Task<ActionResult<ApiResponse<FuturePredictionResponseDto>>> PredictFuture([FromBody] FuturePredictionRequestDto request)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<FuturePredictionResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            var result = await _aiAssistantService.PredictFutureAsync(request);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/AIController.cs
+++ b/FutureMailAPI/Controllers/AIController.cs
@@ -0,0 +1,130 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/ai")]
+    [Authorize]
+    public class AIController : ControllerBase
+    {
+        private readonly IAIAssistantService _aiAssistantService;
+        private readonly ILogger<AIController> _logger;
+        
+        public AIController(IAIAssistantService aiAssistantService, ILogger<AIController> logger)
+        {
+            _aiAssistantService = aiAssistantService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// AI写作辅助
+        /// </summary>
+        /// <param name="request">写作辅助请求</param>
+        /// <returns>AI生成的内容和建议</returns>
+        [HttpPost("writing-assistant")]
+        public async Task<ActionResult<ApiResponse<WritingAssistantResponseDto>>> WritingAssistant([FromBody] WritingAssistantRequestDto request)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<WritingAssistantResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            try
+            {
+                var result = await _aiAssistantService.GetWritingAssistanceAsync(request);
+                
+                if (!result.Success)
+                {
+                    return BadRequest(result);
+                }
+                
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取写作辅助时发生错误");
+                return StatusCode(500, ApiResponse<WritingAssistantResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 情感分析
+        /// </summary>
+        /// <param name="request">情感分析请求</param>
+        /// <returns>情感分析结果</returns>
+        [HttpPost("sentiment-analysis")]
+        public async Task<ActionResult<ApiResponse<SentimentAnalysisResponseDto>>> SentimentAnalysis([FromBody] SentimentAnalysisRequestDto request)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<SentimentAnalysisResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            try
+            {
+                var result = await _aiAssistantService.AnalyzeSentimentAsync(request);
+                
+                if (!result.Success)
+                {
+                    return BadRequest(result);
+                }
+                
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "进行情感分析时发生错误");
+                return StatusCode(500, ApiResponse<SentimentAnalysisResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 未来预测
+        /// </summary>
+        /// <param name="request">未来预测请求</param>
+        /// <returns>未来预测结果</returns>
+        [HttpPost("future-prediction")]
+        public async Task<ActionResult<ApiResponse<FuturePredictionResponseDto>>> FuturePrediction([FromBody] FuturePredictionRequestDto request)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<FuturePredictionResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            try
+            {
+                var result = await _aiAssistantService.PredictFutureAsync(request);
+                
+                if (!result.Success)
+                {
+                    return BadRequest(result);
+                }
+                
+                return Ok(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "进行未来预测时发生错误");
+                return StatusCode(500, ApiResponse<FuturePredictionResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从JWT令牌中获取当前用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int? GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out int userId))
+            {
+                return userId;
+            }
+            return null;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/AuthController.cs
+++ b/FutureMailAPI/Controllers/AuthController.cs
@@ -0,0 +1,123 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using FutureMailAPI.Extensions;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/auth")]
+    public class AuthController : ControllerBase
+    {
+        private readonly IAuthService _authService;
+        private readonly ILogger<AuthController> _logger;
+        
+        public AuthController(IAuthService authService, ILogger<AuthController> logger)
+        {
+            _authService = authService;
+            _logger = logger;
+        }
+        
+        [HttpPost("register")]
+        [AllowAnonymous]
+        public async Task<ActionResult<ApiResponse<AuthResponseDto>>> Register([FromBody] UserRegisterDto registerDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<AuthResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            var result = await _authService.RegisterAsync(registerDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("login")]
+        [AllowAnonymous]
+        public async Task<ActionResult<ApiResponse<AuthResponseDto>>> Login([FromBody] UserLoginDto loginDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<AuthResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            var result = await _authService.LoginAsync(loginDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("refresh")]
+        [AllowAnonymous]
+        public async Task<ActionResult<ApiResponse<AuthResponseDto>>> RefreshToken([FromBody] RefreshTokenRequestDto request)
+        {
+            if (request == null || string.IsNullOrEmpty(request.Token))
+            {
+                return BadRequest(ApiResponse<AuthResponseDto>.ErrorResult("令牌不能为空"));
+            }
+            
+            // 使用OAuth刷新令牌
+            var tokenResult = await _authService.RefreshTokenAsync(request.Token);
+            
+            if (!tokenResult.Success)
+            {
+                return BadRequest(ApiResponse<AuthResponseDto>.ErrorResult(tokenResult.Message));
+            }
+            
+            // 创建认证响应DTO
+            var authResponse = new AuthResponseDto
+            {
+                Token = tokenResult.Data,
+                Expires = DateTime.UtcNow.AddHours(1) // OAuth访问令牌默认1小时过期
+            };
+            
+            return Ok(ApiResponse<AuthResponseDto>.SuccessResult(authResponse, "令牌刷新成功"));
+        }
+        
+        [HttpPost("logout")]
+        public async Task<ActionResult<ApiResponse<bool>>> Logout()
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<bool>.ErrorResult("未授权访问"));
+            }
+            
+            // 这里可以实现令牌黑名单或其他注销逻辑
+            // 目前只返回成功响应
+            return Ok(ApiResponse<bool>.SuccessResult(true));
+        }
+        
+        private int? GetCurrentUserId()
+        {
+            // 从OAuth中间件获取用户ID
+            var userId = HttpContext.GetCurrentUserId();
+            if (userId.HasValue)
+            {
+                return userId.Value;
+            }
+            
+            // 兼容旧的JWT方式
+            var userIdClaim = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier);
+            
+            if (userIdClaim == null || !int.TryParse(userIdClaim.Value, out var jwtUserId))
+            {
+                return null;
+            }
+            
+            return jwtUserId;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/CapsulesController.cs
+++ b/FutureMailAPI/Controllers/CapsulesController.cs
@@ -0,0 +1,81 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/capsules")]
+    [Authorize]
+    public class CapsulesController : ControllerBase
+    {
+        private readonly ITimeCapsuleService _timeCapsuleService;
+        private readonly ILogger<CapsulesController> _logger;
+        
+        public CapsulesController(ITimeCapsuleService timeCapsuleService, ILogger<CapsulesController> logger)
+        {
+            _timeCapsuleService = timeCapsuleService;
+            _logger = logger;
+        }
+        
+        [HttpGet]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleViewResponseDto>>> GetCapsules()
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleViewResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.GetTimeCapsuleViewAsync(currentUserId.Value);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPut("{capsuleId}/style")]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleResponseDto>>> UpdateCapsuleStyle(int capsuleId, [FromBody] TimeCapsuleStyleUpdateDto updateDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.UpdateTimeCapsuleStyleAsync(currentUserId.Value, capsuleId, updateDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        private int? GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier);
+            
+            if (userIdClaim == null || !int.TryParse(userIdClaim.Value, out var userId))
+            {
+                return null;
+            }
+            
+            return userId;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/FileUploadController.cs
+++ b/FutureMailAPI/Controllers/FileUploadController.cs
@@ -0,0 +1,189 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using FutureMailAPI.Helpers;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/[controller]")]
+    [Authorize]
+    public class FileUploadController : ControllerBase
+    {
+        private readonly IFileUploadService _fileUploadService;
+        private readonly ILogger<FileUploadController> _logger;
+        
+        public FileUploadController(IFileUploadService fileUploadService, ILogger<FileUploadController> logger)
+        {
+            _fileUploadService = fileUploadService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 上传附件
+        /// </summary>
+        /// <param name="request">文件上传请求</param>
+        /// <returns>上传结果</returns>
+        [HttpPost("attachment")]
+        public async Task<IActionResult> UploadAttachment([FromForm] FileUploadWithFileRequestDto request)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (request.File == null || request.File.Length == 0)
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("请选择要上传的文件"));
+                }
+                
+                var result = await _fileUploadService.UploadFileAsync(request.File, userId, request);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "上传附件时发生错误");
+                return StatusCode(500, ApiResponse<FileUploadResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 上传头像
+        /// </summary>
+        /// <param name="request">文件上传请求</param>
+        /// <returns>上传结果</returns>
+        [HttpPost("avatar")]
+        public async Task<IActionResult> UploadAvatar([FromForm] FileUploadWithFileRequestDto request)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (request.File == null || request.File.Length == 0)
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("请选择要上传的头像文件"));
+                }
+                
+                // 设置头像特定的属性
+                request.Type = AttachmentType.IMAGE;
+                request.Category = "avatar";
+                
+                var result = await _fileUploadService.UploadFileAsync(request.File, userId, request);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "上传头像时发生错误");
+                return StatusCode(500, ApiResponse<FileUploadResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 删除文件
+        /// </summary>
+        /// <param name="fileId">文件ID</param>
+        /// <returns>删除结果</returns>
+        [HttpDelete("{fileId}")]
+        public async Task<IActionResult> DeleteFile(string fileId)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (string.IsNullOrEmpty(fileId))
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("文件ID不能为空"));
+                }
+                
+                var result = await _fileUploadService.DeleteFileAsync(fileId, userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "删除文件时发生错误");
+                return StatusCode(500, ApiResponse<bool>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 获取文件信息
+        /// </summary>
+        /// <param name="fileId">文件ID</param>
+        /// <returns>文件信息</returns>
+        [HttpGet("info/{fileId}")]
+        public async Task<IActionResult> GetFile(string fileId)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (string.IsNullOrEmpty(fileId))
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("文件ID不能为空"));
+                }
+                
+                var result = await _fileUploadService.GetFileAsync(fileId, userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取文件信息时发生错误");
+                return StatusCode(500, ApiResponse<FileUploadResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从当前请求中获取用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out var userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/MailsController.cs
+++ b/FutureMailAPI/Controllers/MailsController.cs
@@ -0,0 +1,225 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/[controller]")]
+    [Authorize]
+    public class MailsController : ControllerBase
+    {
+        private readonly IMailService _mailService;
+        
+        public MailsController(IMailService mailService)
+        {
+            _mailService = mailService;
+        }
+        
+        [HttpPost]
+        public async Task<ActionResult<ApiResponse<SentMailResponseDto>>> CreateMail([FromBody] SentMailCreateDto createDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<SentMailResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<SentMailResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.CreateMailAsync(currentUserId.Value, createDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return CreatedAtAction(
+                nameof(GetMail), 
+                new { mailId = result.Data!.Id }, 
+                result);
+        }
+        
+        [HttpGet("{mailId}")]
+        public async Task<ActionResult<ApiResponse<SentMailResponseDto>>> GetMail(int mailId)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<SentMailResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.GetSentMailByIdAsync(currentUserId.Value, mailId);
+            
+            if (!result.Success)
+            {
+                return NotFound(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpGet]
+        public async Task<ActionResult<ApiResponse<PagedResponse<SentMailResponseDto>>>> GetMails([FromQuery] MailListQueryDto queryDto)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<PagedResponse<SentMailResponseDto>>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.GetSentMailsAsync(currentUserId.Value, queryDto);
+            
+            return Ok(result);
+        }
+        
+        [HttpPut("{mailId}")]
+        public async Task<ActionResult<ApiResponse<SentMailResponseDto>>> UpdateMail(int mailId, [FromBody] SentMailUpdateDto updateDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<SentMailResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<SentMailResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.UpdateMailAsync(currentUserId.Value, mailId, updateDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpDelete("{mailId}")]
+        public async Task<ActionResult<ApiResponse<bool>>> DeleteMail(int mailId)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<bool>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.DeleteMailAsync(currentUserId.Value, mailId);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpGet("received")]
+        public async Task<ActionResult<ApiResponse<PagedResponse<ReceivedMailResponseDto>>>> GetReceivedMails([FromQuery] MailListQueryDto queryDto)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<PagedResponse<ReceivedMailResponseDto>>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.GetReceivedMailsAsync(currentUserId.Value, queryDto);
+            
+            return Ok(result);
+        }
+        
+        [HttpGet("received/{id}")]
+        public async Task<ActionResult<ApiResponse<ReceivedMailResponseDto>>> GetReceivedMail(int id)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<ReceivedMailResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.GetReceivedMailByIdAsync(currentUserId.Value, id);
+            
+            if (!result.Success)
+            {
+                return NotFound(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("received/{id}/mark-read")]
+        public async Task<ActionResult<ApiResponse<bool>>> MarkReceivedMailAsRead(int id)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<bool>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.MarkReceivedMailAsReadAsync(currentUserId.Value, id);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("{mailId}/revoke")]
+        public async Task<ActionResult<ApiResponse<bool>>> RevokeMail(int mailId)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<bool>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _mailService.RevokeMailAsync(currentUserId.Value, mailId);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        private int? GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            
+            if (userIdClaim == null || !int.TryParse(userIdClaim.Value, out var userId))
+            {
+                return null;
+            }
+            
+            return userId;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/NotificationController.cs
+++ b/FutureMailAPI/Controllers/NotificationController.cs
@@ -0,0 +1,105 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/notification")]
+    [Authorize]
+    public class NotificationController : ControllerBase
+    {
+        private readonly INotificationService _notificationService;
+        private readonly ILogger<NotificationController> _logger;
+        
+        public NotificationController(INotificationService notificationService, ILogger<NotificationController> logger)
+        {
+            _notificationService = notificationService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 注册设备
+        /// </summary>
+        /// <param name="request">设备注册请求</param>
+        /// <returns>注册结果</returns>
+        [HttpPost("device")]
+        public async Task<IActionResult> RegisterDevice([FromBody] NotificationDeviceRequestDto request)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (string.IsNullOrEmpty(request.DeviceType) || string.IsNullOrEmpty(request.DeviceToken))
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("设备类型和设备令牌不能为空"));
+                }
+                
+                var result = await _notificationService.RegisterDeviceAsync(userId, request);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "注册设备时发生错误");
+                return StatusCode(500, ApiResponse<NotificationDeviceResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 获取通知设置
+        /// </summary>
+        /// <returns>通知设置</returns>
+        [HttpGet("settings")]
+        public async Task<IActionResult> GetNotificationSettings()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _notificationService.GetNotificationSettingsAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取通知设置时发生错误");
+                return StatusCode(500, ApiResponse<NotificationSettingsDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从JWT令牌中获取当前用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out int userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/OAuthController.cs
+++ b/FutureMailAPI/Controllers/OAuthController.cs
@@ -0,0 +1,295 @@
+using Microsoft.AspNetCore.Mvc;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using FutureMailAPI.Models;
+using FutureMailAPI.Extensions;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/oauth")]
+    public class OAuthController : ControllerBase
+    {
+        private readonly IOAuthService _oauthService;
+        private readonly ILogger<OAuthController> _logger;
+        
+        public OAuthController(IOAuthService oauthService, ILogger<OAuthController> logger)
+        {
+            _oauthService = oauthService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// OAuth登录端点
+        /// </summary>
+        [HttpPost("login")]
+        public async Task<IActionResult> Login([FromBody] OAuthLoginDto loginDto)
+        {
+            try
+            {
+                var result = await _oauthService.LoginAsync(loginDto);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "OAuth登录时发生错误");
+                return StatusCode(500, new { message = "服务器内部错误" });
+            }
+        }
+        
+        /// <summary>
+        /// 创建OAuth客户端
+        /// </summary>
+        [HttpPost("clients")]
+        public async Task<IActionResult> CreateClient([FromBody] OAuthClientCreateDto createDto)
+        {
+            try
+            {
+                // 从OAuth中间件获取当前用户ID
+                var userId = HttpContext.GetCurrentUserId();
+                if (!userId.HasValue)
+                {
+                    return Unauthorized(new { message = "未授权访问" });
+                }
+                
+                var result = await _oauthService.CreateClientAsync(userId.Value, createDto);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "创建OAuth客户端时发生错误");
+                return StatusCode(500, new { message = "服务器内部错误" });
+            }
+        }
+        
+        /// <summary>
+        /// 获取OAuth客户端信息
+        /// </summary>
+        [HttpGet("clients/{clientId}")]
+        public async Task<IActionResult> GetClient(string clientId)
+        {
+            try
+            {
+                var result = await _oauthService.GetClientAsync(clientId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return NotFound(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取OAuth客户端信息时发生错误");
+                return StatusCode(500, new { message = "服务器内部错误" });
+            }
+        }
+        
+        /// <summary>
+        /// OAuth授权端点
+        /// </summary>
+        [HttpGet("authorize")]
+        public async Task<IActionResult> Authorize([FromQuery] OAuthAuthorizationRequestDto request)
+        {
+            try
+            {
+                // 从OAuth中间件获取当前用户ID
+                var userId = HttpContext.GetCurrentUserId();
+                if (!userId.HasValue)
+                {
+                    // 如果用户未登录，重定向到登录页面
+                    var loginRedirectUri = $"/api/v1/auth/login?redirect_uri={Uri.EscapeDataString(request.RedirectUri)}";
+                    if (!string.IsNullOrEmpty(request.State))
+                    {
+                        loginRedirectUri += $"&state={request.State}";
+                    }
+                    return Redirect(loginRedirectUri);
+                }
+                
+                var result = await _oauthService.AuthorizeAsync(userId.Value, request);
+                
+                if (result.Success)
+                {
+                    // 重定向到客户端，携带授权码
+                    var redirectUri = $"{request.RedirectUri}?code={result.Data.Code}";
+                    if (!string.IsNullOrEmpty(request.State))
+                    {
+                        redirectUri += $"&state={request.State}";
+                    }
+                    
+                    return Redirect(redirectUri);
+                }
+                
+                // 错误重定向
+                var errorRedirectUri = $"{request.RedirectUri}?error={result.Message}";
+                if (!string.IsNullOrEmpty(request.State))
+                {
+                    errorRedirectUri += $"&state={request.State}";
+                }
+                
+                return Redirect(errorRedirectUri);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "OAuth授权时发生错误");
+                
+                // 错误重定向
+                var errorRedirectUri = $"{request.RedirectUri}?error=server_error";
+                if (!string.IsNullOrEmpty(request.State))
+                {
+                    errorRedirectUri += $"&state={request.State}";
+                }
+                
+                return Redirect(errorRedirectUri);
+            }
+        }
+        
+        /// <summary>
+        /// OAuth令牌端点
+        /// </summary>
+        [HttpPost("token")]
+        [Microsoft.AspNetCore.Authorization.AllowAnonymous]
+        public async Task<IActionResult> ExchangeToken([FromForm] OAuthTokenRequestDto request)
+        {
+            _logger.LogInformation("OAuth令牌端点被调用");
+            
+            try
+            {
+                _logger.LogInformation("OAuth令牌交换请求: GrantType={GrantType}, ClientId={ClientId}, Username={Username}", 
+                    request.GrantType, request.ClientId, request.Username);
+                
+                if (request.GrantType == "authorization_code")
+                {
+                    var result = await _oauthService.ExchangeCodeForTokenAsync(request);
+                    
+                    if (result.Success)
+                    {
+                        return Ok(result);
+                    }
+                    
+                    return BadRequest(result);
+                }
+                else if (request.GrantType == "refresh_token")
+                {
+                    var result = await _oauthService.RefreshTokenAsync(request);
+                    
+                    if (result.Success)
+                    {
+                        return Ok(result);
+                    }
+                    
+                    return BadRequest(result);
+                }
+                else if (request.GrantType == "password")
+                {
+                    _logger.LogInformation("处理密码授权类型登录请求");
+                    
+                    // 创建OAuth登录请求
+                    var loginDto = new OAuthLoginDto
+                    {
+                        UsernameOrEmail = request.Username,
+                        Password = request.Password,
+                        ClientId = request.ClientId,
+                        ClientSecret = request.ClientSecret,
+                        Scope = request.Scope
+                    };
+                    
+                    var result = await _oauthService.LoginAsync(loginDto);
+                    
+                    if (result.Success)
+                    {
+                        _logger.LogInformation("密码授权类型登录成功");
+                        return Ok(result);
+                    }
+                    
+                    _logger.LogWarning("密码授权类型登录失败: {Message}", result.Message);
+                    return BadRequest(result);
+                }
+                else
+                {
+                    _logger.LogWarning("不支持的授权类型: {GrantType}", request.GrantType);
+                    return BadRequest(new { message = "不支持的授权类型" });
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "OAuth令牌交换时发生错误");
+                return StatusCode(500, new { message = "服务器内部错误" });
+            }
+        }
+        
+        /// <summary>
+        /// 撤销令牌
+        /// </summary>
+        [HttpPost("revoke")]
+        public async Task<IActionResult> RevokeToken([FromForm] string token, [FromForm] string token_type_hint = "access_token")
+        {
+            try
+            {
+                var result = await _oauthService.RevokeTokenAsync(token);
+                
+                if (result.Success)
+                {
+                    return Ok(new { message = "令牌已撤销" });
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "撤销令牌时发生错误");
+                return StatusCode(500, new { message = "服务器内部错误" });
+            }
+        }
+        
+        /// <summary>
+        /// 验证令牌
+        /// </summary>
+        [HttpPost("introspect")]
+        public async Task<IActionResult> IntrospectToken([FromForm] string token)
+        {
+            try
+            {
+                var result = await _oauthService.ValidateTokenAsync(token);
+                
+                if (result.Success)
+                {
+                    var accessToken = await _oauthService.GetAccessTokenAsync(token);
+                    
+                    if (accessToken != null)
+                    {
+                        return Ok(new
+                        {
+                            active = true,
+                            scope = accessToken.Scopes,
+                            client_id = accessToken.Client.ClientId,
+                            username = accessToken.User.Email,
+                            exp = ((DateTimeOffset)accessToken.ExpiresAt).ToUnixTimeSeconds(),
+                            iat = ((DateTimeOffset)accessToken.CreatedAt).ToUnixTimeSeconds()
+                        });
+                    }
+                }
+                
+                return Ok(new { active = false });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "验证令牌时发生错误");
+                return StatusCode(500, new { message = "服务器内部错误" });
+            }
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/PersonalSpaceController.cs
+++ b/FutureMailAPI/Controllers/PersonalSpaceController.cs
@@ -0,0 +1,174 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using FutureMailAPI.Helpers;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/[controller]")]
+    [Authorize]
+    public class PersonalSpaceController : ControllerBase
+    {
+        private readonly IPersonalSpaceService _personalSpaceService;
+        private readonly ILogger<PersonalSpaceController> _logger;
+        
+        public PersonalSpaceController(IPersonalSpaceService personalSpaceService, ILogger<PersonalSpaceController> logger)
+        {
+            _personalSpaceService = personalSpaceService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 获取用户时间线
+        /// </summary>
+        /// <param name="type">时间线类型</param>
+        /// <param name="startDate">开始日期</param>
+        /// <param name="endDate">结束日期</param>
+        /// <returns>用户时间线</returns>
+        [HttpGet("timeline")]
+        public async Task<IActionResult> GetTimeline(
+            [FromQuery] TimelineType type = TimelineType.ALL,
+            [FromQuery] DateTime? startDate = null,
+            [FromQuery] DateTime? endDate = null)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var query = new TimelineQueryDto
+                {
+                    Type = type,
+                    StartDate = startDate,
+                    EndDate = endDate
+                };
+                
+                var result = await _personalSpaceService.GetTimelineAsync(userId, query);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取时间线时发生错误");
+                return StatusCode(500, ApiResponse<TimelineResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 获取用户统计数据
+        /// </summary>
+        /// <returns>用户统计数据</returns>
+        [HttpGet("statistics")]
+        public async Task<IActionResult> GetStatistics()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _personalSpaceService.GetStatisticsAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取统计数据时发生错误");
+                return StatusCode(500, ApiResponse<StatisticsResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 获取用户订阅信息
+        /// </summary>
+        /// <returns>用户订阅信息</returns>
+        [HttpGet("subscription")]
+        public async Task<IActionResult> GetSubscription()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _personalSpaceService.GetSubscriptionAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取订阅信息时发生错误");
+                return StatusCode(500, ApiResponse<SubscriptionResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 获取用户资料
+        /// </summary>
+        /// <returns>用户资料</returns>
+        [HttpGet("profile")]
+        public async Task<IActionResult> GetUserProfile()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _personalSpaceService.GetUserProfileAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取用户资料时发生错误");
+                return StatusCode(500, ApiResponse<UserProfileResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从当前请求中获取用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out var userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/StatisticsController.cs
+++ b/FutureMailAPI/Controllers/StatisticsController.cs
@@ -0,0 +1,68 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/statistics")]
+    [Authorize]
+    public class StatisticsController : ControllerBase
+    {
+        private readonly IPersonalSpaceService _personalSpaceService;
+        private readonly ILogger<StatisticsController> _logger;
+        
+        public StatisticsController(IPersonalSpaceService personalSpaceService, ILogger<StatisticsController> logger)
+        {
+            _personalSpaceService = personalSpaceService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 获取用户统计数据
+        /// </summary>
+        /// <returns>用户统计数据</returns>
+        [HttpGet]
+        public async Task<IActionResult> GetStatistics()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _personalSpaceService.GetStatisticsAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取统计数据时发生错误");
+                return StatusCode(500, ApiResponse<StatisticsResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从JWT令牌中获取当前用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out int userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/TimeCapsulesController.cs
+++ b/FutureMailAPI/Controllers/TimeCapsulesController.cs
@@ -0,0 +1,224 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/[controller]")]
+    [Authorize]
+    public class TimeCapsulesController : ControllerBase
+    {
+        private readonly ITimeCapsuleService _timeCapsuleService;
+        private readonly ILogger<TimeCapsulesController> _logger;
+        
+        public TimeCapsulesController(ITimeCapsuleService timeCapsuleService, ILogger<TimeCapsulesController> logger)
+        {
+            _timeCapsuleService = timeCapsuleService;
+            _logger = logger;
+        }
+        
+        [HttpPost]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleResponseDto>>> CreateTimeCapsule([FromBody] TimeCapsuleCreateDto createDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.CreateTimeCapsuleAsync(currentUserId.Value, createDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return CreatedAtAction(
+                nameof(GetTimeCapsule),
+                new { capsuleId = result.Data!.Id },
+                result);
+        }
+        
+        [HttpGet("{capsuleId}")]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleResponseDto>>> GetTimeCapsule(int capsuleId)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.GetTimeCapsuleByIdAsync(currentUserId.Value, capsuleId);
+            
+            if (!result.Success)
+            {
+                return NotFound(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpGet]
+        public async Task<ActionResult<ApiResponse<PagedResponse<TimeCapsuleResponseDto>>>> GetTimeCapsules([FromQuery] TimeCapsuleListQueryDto queryDto)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<PagedResponse<TimeCapsuleResponseDto>>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.GetTimeCapsulesAsync(currentUserId.Value, queryDto);
+            
+            return Ok(result);
+        }
+        
+        [HttpPut("{capsuleId}")]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleResponseDto>>> UpdateTimeCapsule(int capsuleId, [FromBody] TimeCapsuleUpdateDto updateDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.UpdateTimeCapsuleAsync(currentUserId.Value, capsuleId, updateDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpDelete("{capsuleId}")]
+        public async Task<ActionResult<ApiResponse<bool>>> DeleteTimeCapsule(int capsuleId)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<bool>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.DeleteTimeCapsuleAsync(currentUserId.Value, capsuleId);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpGet("public")]
+        [AllowAnonymous]
+        public async Task<ActionResult<ApiResponse<PagedResponse<TimeCapsuleResponseDto>>>> GetPublicTimeCapsules([FromQuery] TimeCapsuleListQueryDto queryDto)
+        {
+            var result = await _timeCapsuleService.GetPublicTimeCapsulesAsync(queryDto);
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("public/{capsuleId}/claim")]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleResponseDto>>> ClaimPublicCapsule(int capsuleId)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.ClaimPublicCapsuleAsync(currentUserId.Value, capsuleId);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpGet("view")]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleViewResponseDto>>> GetTimeCapsuleView()
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleViewResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.GetTimeCapsuleViewAsync(currentUserId.Value);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPut("{capsuleId}/style")]
+        public async Task<ActionResult<ApiResponse<TimeCapsuleResponseDto>>> UpdateTimeCapsuleStyle(int capsuleId, [FromBody] TimeCapsuleStyleUpdateDto updateDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<TimeCapsuleResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            var result = await _timeCapsuleService.UpdateTimeCapsuleStyleAsync(currentUserId.Value, capsuleId, updateDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        private int? GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier);
+            
+            if (userIdClaim == null || !int.TryParse(userIdClaim.Value, out var userId))
+            {
+                return null;
+            }
+            
+            return userId;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/TimelineController.cs
+++ b/FutureMailAPI/Controllers/TimelineController.cs
@@ -0,0 +1,81 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/timeline")]
+    [Authorize]
+    public class TimelineController : ControllerBase
+    {
+        private readonly IPersonalSpaceService _personalSpaceService;
+        private readonly ILogger<TimelineController> _logger;
+        
+        public TimelineController(IPersonalSpaceService personalSpaceService, ILogger<TimelineController> logger)
+        {
+            _personalSpaceService = personalSpaceService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 获取用户时间线
+        /// </summary>
+        /// <param name="type">时间线类型</param>
+        /// <param name="startDate">开始日期</param>
+        /// <param name="endDate">结束日期</param>
+        /// <returns>用户时间线</returns>
+        [HttpGet]
+        public async Task<IActionResult> GetTimeline(
+            [FromQuery] TimelineType type = TimelineType.ALL,
+            [FromQuery] DateTime? startDate = null,
+            [FromQuery] DateTime? endDate = null)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var query = new TimelineQueryDto
+                {
+                    Type = type,
+                    StartDate = startDate,
+                    EndDate = endDate
+                };
+                
+                var result = await _personalSpaceService.GetTimelineAsync(userId, query);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取时间线时发生错误");
+                return StatusCode(500, ApiResponse<TimelineResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从JWT令牌中获取当前用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out int userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/UploadController.cs
+++ b/FutureMailAPI/Controllers/UploadController.cs
@@ -0,0 +1,115 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/upload")]
+    [Authorize]
+    public class UploadController : ControllerBase
+    {
+        private readonly IFileUploadService _fileUploadService;
+        private readonly ILogger<UploadController> _logger;
+        
+        public UploadController(IFileUploadService fileUploadService, ILogger<UploadController> logger)
+        {
+            _fileUploadService = fileUploadService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 上传附件
+        /// </summary>
+        /// <param name="request">文件上传请求</param>
+        /// <returns>上传结果</returns>
+        [HttpPost("attachment")]
+        public async Task<IActionResult> UploadAttachment([FromForm] FileUploadWithFileRequestDto request)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (request.File == null || request.File.Length == 0)
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("请选择要上传的文件"));
+                }
+                
+                var result = await _fileUploadService.UploadFileAsync(request.File, userId, request);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "上传附件时发生错误");
+                return StatusCode(500, ApiResponse<FileUploadResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 上传头像
+        /// </summary>
+        /// <param name="request">文件上传请求</param>
+        /// <returns>上传结果</returns>
+        [HttpPost("avatar")]
+        public async Task<IActionResult> UploadAvatar([FromForm] FileUploadWithFileRequestDto request)
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                if (request.File == null || request.File.Length == 0)
+                {
+                    return BadRequest(ApiResponse<object>.ErrorResult("请选择要上传的头像文件"));
+                }
+                
+                // 设置头像特定的属性
+                request.Type = AttachmentType.IMAGE;
+                request.Category = "avatar";
+                
+                var result = await _fileUploadService.UploadFileAsync(request.File, userId, request);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "上传头像时发生错误");
+                return StatusCode(500, ApiResponse<FileUploadResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从JWT令牌中获取当前用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out int userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/UserController.cs
+++ b/FutureMailAPI/Controllers/UserController.cs
@@ -0,0 +1,99 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+using System.Security.Claims;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/user")]
+    [Authorize]
+    public class UserController : ControllerBase
+    {
+        private readonly IPersonalSpaceService _personalSpaceService;
+        private readonly ILogger<UserController> _logger;
+        
+        public UserController(IPersonalSpaceService personalSpaceService, ILogger<UserController> logger)
+        {
+            _personalSpaceService = personalSpaceService;
+            _logger = logger;
+        }
+        
+        /// <summary>
+        /// 获取用户订阅信息
+        /// </summary>
+        /// <returns>用户订阅信息</returns>
+        [HttpGet("subscription")]
+        public async Task<IActionResult> GetSubscription()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _personalSpaceService.GetSubscriptionAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取订阅信息时发生错误");
+                return StatusCode(500, ApiResponse<SubscriptionResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 获取用户资料
+        /// </summary>
+        /// <returns>用户资料</returns>
+        [HttpGet("profile")]
+        public async Task<IActionResult> GetUserProfile()
+        {
+            try
+            {
+                var userId = GetCurrentUserId();
+                if (userId <= 0)
+                {
+                    return Unauthorized(ApiResponse<object>.ErrorResult("无效的用户令牌"));
+                }
+                
+                var result = await _personalSpaceService.GetUserProfileAsync(userId);
+                
+                if (result.Success)
+                {
+                    return Ok(result);
+                }
+                
+                return BadRequest(result);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取用户资料时发生错误");
+                return StatusCode(500, ApiResponse<UserProfileResponseDto>.ErrorResult("服务器内部错误"));
+            }
+        }
+        
+        /// <summary>
+        /// 从JWT令牌中获取当前用户ID
+        /// </summary>
+        /// <returns>用户ID</returns>
+        private int GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
+            if (userIdClaim != null && int.TryParse(userIdClaim.Value, out int userId))
+            {
+                return userId;
+            }
+            return 0;
+        }
+    }
+}
--- a/FutureMailAPI/Controllers/UsersController.cs
+++ b/FutureMailAPI/Controllers/UsersController.cs
@@ -0,0 +1,125 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using FutureMailAPI.Services;
+using FutureMailAPI.DTOs;
+
+namespace FutureMailAPI.Controllers
+{
+    [ApiController]
+    [Route("api/v1/users")]
+    [Authorize]
+    public class UsersController : ControllerBase
+    {
+        private readonly IUserService _userService;
+        private readonly ILogger<UsersController> _logger;
+        
+        public UsersController(IUserService userService, ILogger<UsersController> logger)
+        {
+            _userService = userService;
+            _logger = logger;
+        }
+        
+        [HttpGet("{id}")]
+        public async Task<ActionResult<ApiResponse<UserResponseDto>>> GetUser(int id)
+        {
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<UserResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            // 只有用户本人可以查看自己的信息
+            if (currentUserId != id)
+            {
+                return Forbid();
+            }
+            
+            var result = await _userService.GetUserByIdAsync(id);
+            
+            if (!result.Success)
+            {
+                return NotFound(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPut("{id}")]
+        public async Task<ActionResult<ApiResponse<UserResponseDto>>> UpdateUser(int id, [FromBody] UserUpdateDto updateDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<UserResponseDto>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<UserResponseDto>.ErrorResult("未授权访问"));
+            }
+            
+            // 只有用户本人可以更新自己的信息
+            if (currentUserId != id)
+            {
+                return Forbid();
+            }
+            
+            var result = await _userService.UpdateUserAsync(id, updateDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        [HttpPost("{id}/change-password")]
+        public async Task<ActionResult<ApiResponse<bool>>> ChangePassword(int id, [FromBody] ChangePasswordDto changePasswordDto)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ApiResponse<bool>.ErrorResult("输入数据无效"));
+            }
+            
+            // 从JWT令牌中获取当前用户ID
+            var currentUserId = GetCurrentUserId();
+            
+            if (currentUserId == null)
+            {
+                return Unauthorized(ApiResponse<bool>.ErrorResult("未授权访问"));
+            }
+            
+            // 只有用户本人可以修改自己的密码
+            if (currentUserId != id)
+            {
+                return Forbid();
+            }
+            
+            var result = await _userService.ChangePasswordAsync(id, changePasswordDto);
+            
+            if (!result.Success)
+            {
+                return BadRequest(result);
+            }
+            
+            return Ok(result);
+        }
+        
+        private int? GetCurrentUserId()
+        {
+            var userIdClaim = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier);
+            
+            if (userIdClaim == null || !int.TryParse(userIdClaim.Value, out var userId))
+            {
+                return null;
+            }
+            
+            return userId;
+        }
+    }
+}