Hua.DDNS/Hua.DDNS/SslProviders/Ali/AliSslProvider.cs

using AlibabaCloud.SDK.Cas20200407;
using AlibabaCloud.SDK.Cas20200407.Models;
using AlibabaCloud.OpenApiClient.Models;
using Hua.DDNS.Common.Config.Options;
using Hua.DDNS.SslProviders;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace Hua.DDNS.SslProviders.Ali
{
    /// <summary>
    /// 阿里云 SSL 证书下载提供者
    /// </summary>
    public class AliSslProvider : ISslDownloadProvider
    {
        private readonly Client _client;
        private readonly AliCloudOption _aliCloudOption;
        private readonly ILogger<AliSslProvider> _logger;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="logger">日志对象</param>
        /// <param name="aliCloudOption">阿里云配置</param>
        public AliSslProvider(
            ILogger<AliSslProvider> logger,
            IOptions<AliCloudOption> aliCloudOption)
        {
            _logger = logger;
            _aliCloudOption = aliCloudOption.Value;

            var config = new Config
            {
                AccessKeyId = _aliCloudOption.AccessKeyId,
                AccessKeySecret = _aliCloudOption.AccessKeySecret,
                Endpoint = _aliCloudOption.Endpoint
            };

            _client = new Client(config);
        }

        /// <summary>
        /// 异步获取阿里云上的 SSL 证书列表
        /// </summary>
        /// <returns>证书列表</returns>
        public async Task<List<SslCertificate>> GetCertificatesAsync()
        {
            try
            {
                var request = new ListUserCertificateOrderRequest
                {
                    OrderType = "CERT",
                    Status = "ISSUED" // 也可以不设置，获取所有
                };

                var response = await _client.ListUserCertificateOrderAsync(request);
                var certificates = new List<SslCertificate>();

                if (response.Body.CertificateOrderList != null)
                {
                    foreach (var cert in response.Body.CertificateOrderList)
                    {
                        certificates.Add(new SslCertificate
                        {
                            CertificateId = cert.CertificateId.ToString(),
                            Domain = cert.Domain,
                            Alias = cert.Name,
                            CertEndTime = string.IsNullOrEmpty(cert.EndDate) ? DateTime.MinValue : DateTime.Parse(cert.EndDate),
                            StatusMsg = cert.Status
                        });
                    }
                }

                _logger.LogInformation($"获取到 {certificates.Count} 个阿里云 SSL 证书");
                return certificates;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取阿里云 SSL 证书列表失败");
                throw;
            }
        }

        /// <summary>
        /// 异步下载阿里云上的指定的 SSL 证书
        /// </summary>
        /// <param name="certificateId">证书 ID</param>
        /// <param name="savePath">本地保存目录路径</param>
        /// <param name="fileName">保存的文件名 (不含后缀)</param>
        /// <returns>下载成功返回 true，否则返回 false</returns>
        public async Task<bool> DownloadCertificateAsync(string certificateId, string savePath, string fileName)
        {
            try
            {
                // TODO: 阿里云证书下载逻辑
                _logger.LogWarning($"阿里云 SSL 证书下载功能待实现: {certificateId}");
                return false;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"下载证书失败: {certificateId}");
                return false;
            }
        }

        /// <summary>
        /// 异步清理无效证书
        /// </summary>
        /// <returns></returns>
        public async Task CleanInvalidCertificatesAsync()
        {
            try
            {
                var certificates = await GetCertificatesAsync();
                // 筛选过期的证书
                var expiredCertificates = certificates.Where(c => c.CertEndTime != DateTime.MinValue && c.CertEndTime < DateTime.Now).ToList();

                foreach (var cert in expiredCertificates)
                {
                    try
                    {
                        var deleteRequest = new DeleteUserCertificateRequest
                        {
                            CertId = long.Parse(cert.CertificateId)
                        };
                        await _client.DeleteUserCertificateAsync(deleteRequest);
                        _logger.LogInformation($"已删除阿里云过期证书: {cert.Domain} ({cert.CertificateId}), 过期时间: {cert.CertEndTime}");
                    }
                    catch (Exception ex)
                    {
                        _logger.LogWarning(ex, $"删除阿里云证书失败: {cert.CertificateId}");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "清理阿里云无效证书失败");
                throw;
            }
        }
    }
}