AssetManager.API/AssetManager.API/Controllers/PortfolioController.cs

using AssetManager.Models.DTOs;
using AssetManager.Models;
using AssetManager.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

namespace AssetManager.API.Controllers;

[ApiController]
[Route("api/v1/portfolio")]
[Authorize]
public class PortfolioController : ControllerBase
{
    private readonly ILogger<PortfolioController> _logger;
    private readonly IPortfolioService _portfolioService;

    public PortfolioController(ILogger<PortfolioController> logger, IPortfolioService portfolioService)
    {
        _logger = logger;
        _portfolioService = portfolioService;
    }

    /// <summary>
    /// 创建新投资组合
    /// </summary>
    /// <param name="request">投资组合创建请求参数</param>
    /// <returns>创建的投资组合详情</returns>
    /// <remarks>
    /// 此接口用于创建新的投资组合。
    /// </remarks>
    [HttpPost]
    public ActionResult<ApiResponse<CreatePortfolioResponse>> CreatePortfolio([FromBody] CreatePortfolioRequest request)
    {
        try
        {
            _logger.LogInformation("Request to create portfolio");
            
            var response = _portfolioService.CreatePortfolio(request);

            _logger.LogInformation("Portfolio created successfully");
            
            return Ok(new ApiResponse<CreatePortfolioResponse>
            {
                code = AssetManager.Models.StatusCodes.Success,
                data = response,
                message = "success"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating portfolio");
            
            return StatusCode(AssetManager.Models.StatusCodes.InternalServerError, new ApiResponse<CreatePortfolioResponse>
            {
                code = AssetManager.Models.StatusCodes.InternalServerError,
                data = null,
                message = ex.Message
            });
        }
    }

    /// <summary>
    /// 获取投资组合列表
    /// </summary>
    /// <returns>投资组合列表</returns>
    /// <remarks>
    /// 此接口用于获取投资组合列表。
    /// </remarks>
    [HttpGet]
    public ActionResult<ApiResponse<GetPortfoliosResponse>> GetPortfolios()
    {
        try
        {
            _logger.LogInformation("Request to get portfolios");
            
            var response = _portfolioService.GetPortfolios();

            _logger.LogInformation("Portfolios retrieved successfully");
            
            return Ok(new ApiResponse<GetPortfoliosResponse>
            {
                code = AssetManager.Models.StatusCodes.Success,
                data = response,
                message = "success"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving portfolios");
            
            return StatusCode(AssetManager.Models.StatusCodes.InternalServerError, new ApiResponse<GetPortfoliosResponse>
            {
                code = AssetManager.Models.StatusCodes.InternalServerError,
                data = null,
                message = ex.Message
            });
        }
    }

    /// <summary>
    /// 获取总资产情况
    /// </summary>
    /// <returns>总资产情况</returns>
    /// <remarks>
    /// 此接口用于获取用户的总资产情况。
    /// </remarks>
    [HttpGet("assets")]
    public ActionResult<ApiResponse<TotalAssetsResponse>> GetTotalAssets()
    {
        try
        {
            _logger.LogInformation("Request to get total assets");
            
            var response = _portfolioService.GetTotalAssets();

            _logger.LogInformation("Total assets retrieved successfully");
            
            return Ok(new ApiResponse<TotalAssetsResponse>
            {
                code = AssetManager.Models.StatusCodes.Success,
                data = response,
                message = "success"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving total assets");
            
            return StatusCode(AssetManager.Models.StatusCodes.InternalServerError, new ApiResponse<TotalAssetsResponse>
            {
                code = AssetManager.Models.StatusCodes.InternalServerError,
                data = null,
                message = ex.Message
            });
        }
    }

    /// <summary>
    /// 获取单个投资组合详情
    /// </summary>
    /// <param name="id">投资组合ID</param>
    /// <returns>投资组合详情</returns>
    /// <remarks>
    /// 此接口用于获取指定投资组合的详细信息。
    /// </remarks>
    [HttpGet("{id}")]
    public ActionResult<ApiResponse<PortfolioDetailResponse>> GetPortfolioById(string id)
    {
        try
        {
            _logger.LogInformation($"Request to get portfolio by id: {id}");
            
            var response = _portfolioService.GetPortfolioById(id);

            _logger.LogInformation("Portfolio retrieved successfully");
            
            return Ok(new ApiResponse<PortfolioDetailResponse>
            {
                code = AssetManager.Models.StatusCodes.Success,
                data = response,
                message = "success"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving portfolio");
            
            return StatusCode(AssetManager.Models.StatusCodes.InternalServerError, new ApiResponse<PortfolioDetailResponse>
            {
                code = AssetManager.Models.StatusCodes.InternalServerError,
                data = null,
                message = ex.Message
            });
        }
    }

    /// <summary>
    /// 获取交易记录
    /// </summary>
    /// <param name="portfolioId">投资组合ID</param>
    /// <param name="limit">每页记录数</param>
    /// <param name="offset">偏移量</param>
    /// <returns>交易记录列表</returns>
    /// <remarks>
    /// 此接口用于获取指定投资组合的交易记录。
    /// </remarks>
    [HttpGet("transactions")]
    public ActionResult<ApiResponse<GetTransactionsResponse>> GetTransactions([FromQuery] string portfolioId, [FromQuery] int limit = 10, [FromQuery] int offset = 0)
    {
        try
        {
            _logger.LogInformation($"Request to get transactions for portfolio: {portfolioId}");
            
            var response = _portfolioService.GetTransactions(portfolioId, limit, offset);

            _logger.LogInformation("Transactions retrieved successfully");
            
            return Ok(new ApiResponse<GetTransactionsResponse>
            {
                code = AssetManager.Models.StatusCodes.Success,
                data = response,
                message = "success"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving transactions");
            
            return StatusCode(AssetManager.Models.StatusCodes.InternalServerError, new ApiResponse<GetTransactionsResponse>
            {
                code = AssetManager.Models.StatusCodes.InternalServerError,
                data = null,
                message = ex.Message
            });
        }
    }

    /// <summary>
    /// 创建新交易
    /// </summary>
    /// <param name="request">交易创建请求参数</param>
    /// <returns>创建的交易详情</returns>
    /// <remarks>
    /// 此接口用于创建新的交易。
    /// </remarks>
    [HttpPost("transactions")]
    public ActionResult<ApiResponse<CreateTransactionResponse>> CreateTransaction([FromBody] CreateTransactionRequest request)
    {
        try
        {
            _logger.LogInformation("Request to create transaction");
            
            var response = _portfolioService.CreateTransaction(request);

            _logger.LogInformation("Transaction created successfully");
            
            return Ok(new ApiResponse<CreateTransactionResponse>
            {
                code = AssetManager.Models.StatusCodes.Success,
                data = response,
                message = "success"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating transaction");
            
            return StatusCode(AssetManager.Models.StatusCodes.InternalServerError, new ApiResponse<CreateTransactionResponse>
            {
                code = AssetManager.Models.StatusCodes.InternalServerError,
                data = null,
                message = ex.Message
            });
        }
    }
}