fix ci

2020-11-11 12:54:17 +08:00
24 changed files with 496 additions and 878 deletions
@@ -0,0 +1,34 @@
 name: PublishNugetPackage
 on: [create]
 jobs:
  build:
    name: Build Project
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
    - name: Setup .NET Core
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '5.0.100'
    - name: Build
      run: dotnet build
  publish:
    needs: build
    name: Publish Project to Nuget
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
    - name: Setup .NET Core
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '5.0.100'
    - name: Publish
      run: |
        version=`git describe --tags`
        dotnet pack --configuration release -p:PackageVersion=$version
        dotnet nuget push bin/release/Simcu.SimApi.$version.nupkg -k ${NUGET_APIKEY} -s https://www.nuget.org/api/v2/package
      env:
        NUGET_APIKEY: ${{ secrets.NUGET_APIKEY }}
@@ -1,24 +0,0 @@
 name: PublishNugetPackage
 on:
  push:
    tags:
      - "*"
 jobs:
  publish:
    name: Publish Project to Nuget
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v1
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v1
        with:
          dotnet-version: "6.0.100"
      - name: Publish
        run: |
          version=`git describe --tags`
          dotnet build --configuration release -p:PackageVersion=$version
          dotnet nuget push bin/release/Simcu.SimApi.$version.nupkg -k ${NUGET_APIKEY} -s https://www.nuget.org/api/v2/package
        env:
          NUGET_APIKEY: ${{ secrets.NUGET_APIKEY }}
@@ -19,16 +19,13 @@ namespace SimApi.Attributes
        //默认是user登录类型
        public SimApiAuthAttribute()
        {
-            Types = new[]
+            Types = new[] { "user" };
            {
                "user"
            };
        }
        //只检测一种用户类型的快捷方式
        public SimApiAuthAttribute(string type)
        {
-            Types = type.Split(",");
+            Types = new[] { type };
        }
        //设定特定类型的检测
@@ -40,10 +37,7 @@ namespace SimApi.Attributes
        //只检测一种用户类型的快捷方式
        public SimApiAuthAttribute(string type, string url)
        {
-            Types = new[]
+            Types = new[] { type };
            {
                type
            };
            new HttpPostAttribute(url);
        }
@@ -56,7 +50,7 @@ namespace SimApi.Attributes
                throw new SimApiException(401);
            }
            //检测用户类型
-            if (!Types.Intersect(loginInfo.Type).Any())
+            if (Types.Intersect(loginInfo.Type).Count() == 0)
            {
                throw new SimApiException(403);
            }
@@ -1,23 +1,20 @@
-namespace SimApi.Communications
+using System;
 namespace SimApi.Communications
 {
    /// <summary>
    /// 只有ID的请求
    /// </summary>
-    public record SimApiIdOnlyRequest(int Id);
+    public class SimApiIdOnlyRequest
-
+    {
-    /// <summary>
+        public int Id { get; set; }
-    /// 只有ID的请求(字符串)
+    }
    /// </summary>
    public record SimApiStringIdOnlyRequest(string Id);
    /// <summary>
    /// 动态类型单字段请求
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public record SimApiOneFieldRequest<T>(T Data);
    /// <summary>
    /// 基础分页请求
    /// </summary>
-    public record SimApiBasePageRequest(int Page, int Count);
+    public class SimApiBasePageRequest
    {
        public int Page { get; set; }
        public int Count { get; set; }
    }
 }
@@ -7,38 +7,82 @@ namespace SimApi.Communications
    /// <summary>
    /// 基础相应
    /// </summary>
-    public record SimApiBaseResponse(int Code = 200, string Message = "成功")
+    public class SimApiBaseResponse
    {
        /// <summary>
        /// 错误代码
        /// </summary>
        public int Code { get; set; }
        /// <summary>
        /// 错误描述
        /// </summary>
        public string Message { get; set; }
        /// <summary>
        /// 默认错误代码对应提示信息
        /// </summary>
-        private static readonly Dictionary<int, string> MsgBox = new()
+        private readonly Dictionary<int, string> MsgBox = new Dictionary<int, string>()
        {
-            {
+            {200, "成功"},
-                200, "成功"
+            {204, "没有数据"},
-            },
+            {400, "参数错误"},
-            {
+            {401, "需要登录"},
-                204, "没有数据"
+            {403, "无权访问"},
-            },
+            {404, "接口不存在"},
-            {
+            {500, "服务器错误"}
                400, "参数错误"
            },
            {
                401, "需要登录"
            },
            {
                403, "无权访问"
            },
            {
                404, "接口不存在"
            },
            {
                500, "服务器错误"
            }
        };
-        public SimApiBaseResponse(int code) : this(code, MsgBox.ContainsKey(code) ? MsgBox[code] : "未知错误")
+        /// <summary>
        /// 返回一个成功的空结果
        /// </summary>
        public SimApiBaseResponse()
        {
            SetCode(200);
        }
        /// <summary>
        /// 返回指定代码的描述
        /// </summary>
        /// <param name="code">错误代码</param>
        public SimApiBaseResponse(int code)
        {
            SetCode(code);
        }
        /// <summary>
        /// 返回指定代码的结果,并自定义提示信息
        /// </summary>
        /// <param name="code">错误代码</param>
        /// <param name="message">错误信息</param>
        public SimApiBaseResponse(int code, string message)
        {
            SetCodeMsg(code, message);
        }
        /// <summary>
        /// 设置响应结果的错误代码
        /// </summary>
        /// <param name="code">错误代码</param>
        public void SetCode(int code)
        {
            Code = code;
            Message = MsgBox.ContainsKey(code) ? MsgBox[code] : "未知错误";
        }
        /// <summary>
        /// 设置响应结果的错误代码和错误描述
        /// </summary>
        /// <param name="code">错误代码</param>
        /// <param name="message">错误描述</param>
        public void SetCodeMsg(int code, string message)
        {
            SetCode(code);
            if (!string.IsNullOrEmpty(message))
            {
                Message = message;
            }
        }
        /// <summary>
@@ -51,10 +95,7 @@ namespace SimApi.Communications
            {
                IgnoreReadOnlyProperties = true,
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-                Converters =
+                Converters = { new JsonStringEnumConverter() }
                {
                    new JsonStringEnumConverter()
                }
            });
        }
    }
@@ -63,14 +104,29 @@ namespace SimApi.Communications
    /// 动态内容分页
    /// </summary>
    /// <typeparam name="T"></typeparam>
-    public record SimApiBasePageResponse<T>
+    public class SimApiBasePageResponse<T> : SimApiBaseResponse
-    (T List, int Page = 1, int Count = 1, int Total = 1, int Code = 200,
+    {
-        string Message = "成功") : SimApiBaseResponse(Code, Message);
+        /// <summary>
        /// 动态内容列表
        /// </summary>
        public T List { get; set; }
        //当前页码
        public int Page { get; set; }
        //每页条数
        public int Count { get; set; }
        //总计条数
        public int Total { get; set; }
    }
    /// <summary>
    /// 动态Data返回
    /// </summary>
    /// <typeparam name="T"></typeparam>
-    public record SimApiBaseResponse<T>(T Data, int Code = 200, string Message = "成功") : SimApiBaseResponse(Code,
+    public class SimApiBaseResponse<T> : SimApiBaseResponse
-        Message);
+    {
        /// <summary>
        /// 动态内容列表
        /// </summary>
        public T Data { get; set; }
    }
 }
@@ -1,7 +1,14 @@
-namespace SimApi.Communications
+using System;
 namespace SimApi.Communications
 {
    /// <summary>
    /// 登录信息中间件
    /// </summary>
-    public record SimApiLoginItem(string Id, string[] Type);
+    public class SimApiLoginItem
    {
        //登录用户的ID
        public int Id { get; set; }
        //登录用户来源
        public string[] Type { get; set; }
    }
 }
@@ -1,73 +0,0 @@
 using System;
 using System.Collections.Generic;
 using Swashbuckle.AspNetCore.SwaggerUI;
 namespace SimApi.Configs
 {
    /// <summary>
    /// 文档组配置
    /// </summary>
    public class SimApiDocGroupOption
    {
        /// <summary>
        /// 文档标识
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// 文档名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 文档描述
        /// </summary>
        public string Description { get; set; }
    }
    /// <summary>
    /// 授权配置, Type支持 "SimApiAuth","ClientCredentials","Implicit","AuthorizationCode"
    /// </summary>
    public class SimApiAuthOption
    {
        public string[] Type { get; set; } = new[] {"SimApiAuth"};
        public string Description { get; set; } = "认证服务器颁发的AccessToken";
        public string AuthorizationUrl { get; set; }
        public string TokenUrl { get; set; }
        public Dictionary<string, string> Scopes { get; set; }
    }
    /// <summary>
    /// 文档配置
    /// </summary>
    public class SimApiDocOptions
    {
        /// <summary>
        /// 文档组配置
        /// </summary>
        public SimApiDocGroupOption[] ApiGroups { get; set; } = new[]
        {
            new SimApiDocGroupOption
            {
                Id = "api",
                Name = "Api",
                Description = "Api接口文档"
            }
        };
        /// <summary>
        /// 授权配置
        /// </summary>
        public SimApiAuthOption ApiAuth { get; set; } = new SimApiAuthOption();
        /// <summary>
        /// 文档页面标题
        /// </summary>
        public string DocumentTitle { get; set; } = "API接口文档";
        /// <summary>
        /// 接口支持的调用方式
        /// </summary>
        public SubmitMethod[] SupportedMethod { get; set; } = new[] {SubmitMethod.Post};
    }
 }
@@ -1,76 +0,0 @@
 using System;
 namespace SimApi.Configs
 {
    public class SimApiOptions
    {
        /// <summary>
        /// 启用全部Cors，对于开发前后分离的时候很有用。
        /// default: true
        /// </summary>
        public bool EnableCors { get; set; } = true;
        /// <summary>
        /// 启用SimapiAuth，一个简单的基于Header Token的认证方式。
        /// default: false
        /// </summary>
        public bool EnableSimApiAuth { get; set; } = false;
        /// <summary>
        /// 启用在线文档，启用后 访问 /swagger 可以查看对应的api文档。
        /// default: false
        /// </summary>
        public bool EnableSimApiDoc { get; set; } = false;
        /// <summary>
        /// 启用异常拦截,启用后，所有的异常将被通过json反馈。
        /// default: true
        /// </summary>
        public bool EnableSimApiException { get; set; } = true;
        /// <summary>
        /// 开启S3兼容的存储系统。
        /// default: false
        /// </summary>
        public bool EnableSimApiStorage { get; set; } = false;
        /// <summary>
        /// 开启ForwardHeaders,开启后可以透传负载均衡的Headers
        /// default: true
        /// </summary>
        public bool EnableForwardHeaders { get; set; } = true;
        /// <summary>
        /// 将所有的url都格式化为小写字母
        /// default: true
        /// </summary>
        public bool EnableLowerUrl { get; set; } = true;
        /// <summary>
        /// 启用格式化的 Console Logger
        /// default: false
        /// </summary>
        public bool EnableLogger { get; set; } = false;
        /// <summary>
        /// Swagger文档相关配置，需要启用 EnableSimApiDoc
        /// </summary>
        public SimApiDocOptions SimApiDocOptions { get; set; } = new SimApiDocOptions();
        /// <summary>
        /// S3兼容的存储系统配置，需要启用 EnableSimApiStorage
        /// </summary>
        public SimApiStorageOptions SimApiStorageOptions { get; set; } = new SimApiStorageOptions();
        public void ConfigureSimApiDoc(Action<SimApiDocOptions> options = null)
        {
            options?.Invoke(SimApiDocOptions);
        }
        public void ConfigureSimApiStorage(Action<SimApiStorageOptions> options = null)
        {
            options?.Invoke(SimApiStorageOptions);
        }
    }
 }
@@ -1,24 +0,0 @@
 namespace SimApi.Configs
 {
    public class SimApiStorageOptions
    {
        /// <summary>
        /// S3 服务器入口地址
        /// </summary>
        public string Endpoint { get; set; }
        /// <summary>
        /// S3 服务器文件访问地址
        /// </summary>
        public string ServeUrl { get; set; }
        /// <summary>
        /// S3服务 Bucket
        /// </summary>
        public string Bucket { get; set; }
        public string AccessKey { get; set; }
        public string SecretKey { get; set; }
    }
 }
@@ -29,14 +29,16 @@ namespace SimApi.Controllers
        {
            if (!context.ModelState.IsValid)
            {
-                foreach (var item in context.ModelState.Values.Where(item =>
+                foreach (var item in context.ModelState.Values)
-                             item.ValidationState == ModelValidationState.Invalid))
+                {
                    if (item.ValidationState == ModelValidationState.Invalid)
                    {
                        Error(400, item.Errors.First().ErrorMessage);
                        break;
                    }
                }
            }
        }
        /// <summary>
@@ -45,7 +47,7 @@ namespace SimApi.Controllers
        /// <param name="code">错误代码</param>
        /// <param name="message">错误描述(若是常规错误,代码可自动带取描述)</param>
        /// <returns></returns>
-        protected static void Error(int code = 500, string message = "")
+        protected static void Error(int code = 500, string message = "服务器错误")
        {
            throw new SimApiException(code, message);
        }
@@ -56,7 +58,7 @@ namespace SimApi.Controllers
        /// <param name="condition">检测条件</param>
        /// <param name="code">错误代码</param>
        /// <param name="message">错误描述</param>
-        protected static void ErrorWhen(bool condition, int code = 500, string message = "")
+        protected static void ErrorWhen(bool condition, int code = 500, string message = "服务器错误")
        {
            if (condition)
            {
@@ -70,7 +72,7 @@ namespace SimApi.Controllers
        /// <param name="condition">检测条件</param>
        /// <param name="code">错误代码</param>
        /// <param name="message">错误描述</param>
-        protected static void ErrorWhenNull(object condition, int code = 404, string message = "")
+        protected static void ErrorWhenNull(object condition, int code = 404, string message = "资源不存在")
        {
            ErrorWhen(condition == null, code, message);
        }
@@ -81,7 +83,9 @@ namespace SimApi.Controllers
        /// <returns></returns>
        protected SimApiBaseResponse<string> UploadFile()
        {
-            return new SimApiBaseResponse<string>(null);
+            return new SimApiBaseResponse<string>();
        }
    }
 }
@@ -6,7 +6,6 @@ using SimApi.Helpers;
 namespace SimApi.Controllers
 {
    [ApiExplorerSettings(GroupName = "api")]
    public class YYCommonController : SimApiBaseController
    {
        private SimApiAuth Auth { get; }
@@ -25,7 +24,9 @@ namespace SimApi.Controllers
        [ApiExplorerSettings(IgnoreApi = true)]
        public SimApiBaseResponse ExceptionHandler(int code)
        {
-            return new SimApiBaseResponse(code);
+            var response = new SimApiBaseResponse();
            response.SetCode(code);
            return response;
        }
        /// <summary>
@@ -33,10 +34,10 @@ namespace SimApi.Controllers
        /// </summary>
        /// <returns></returns>
        [HttpPost("/auth/check"), SimApiDoc("认证", "检测登陆")]
-        public SimApiBaseResponse<string> CheckLogin()
+        public SimApiBaseResponse<int> CheckLogin()
        {
            ErrorWhenNull(LoginInfo, 401);
-            return new SimApiBaseResponse<string>(LoginInfo.Id);
+            return new SimApiBaseResponse<int> { Data = LoginInfo.Id };
        }
        /// <summary>
@@ -52,7 +53,6 @@ namespace SimApi.Controllers
            {
                token = Request.Headers["Token"];
            }
            Auth.Logout(token);
            return new SimApiBaseResponse();
        }
@@ -23,12 +23,9 @@ namespace SimApi.Helpers
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
-        public string Login(string id, string type = "user", string token = null)
+        public string Login(int id, string type = "user", string token = null)
        {
-            return Login(id, new[]
+            return Login(id, new[] { type }, token);
            {
                type
            }, token);
        }
        /// <summary>
@@ -37,10 +34,17 @@ namespace SimApi.Helpers
        /// <param name="id"></param>
        /// <param name="type"></param>
        /// <returns></returns>
-        public string Login(string id, string[] type, string uuid = null)
+        public string Login(int id, string[] type, string uuid = null)
        {
-            uuid ??= Guid.NewGuid().ToString();
+            if (uuid == null)
-            var loginItem = new SimApiLoginItem(id, type);
+            {
                uuid = Guid.NewGuid().ToString();
            }
            var loginItem = new SimApiLoginItem
            {
                Id = id,
                Type = type
            };
            Cache.SetString(uuid, JsonSerializer.Serialize(loginItem));
            return uuid;
        }
@@ -56,5 +60,6 @@ namespace SimApi.Helpers
                Cache.Remove(uuid);
            }
        }
    }
 }
@@ -1,103 +0,0 @@
 using System;
 using System.IO;
 using Microsoft.AspNetCore.Http;
 using Minio;
 using Minio.Exceptions;
 using SimApi.Configs;
 namespace SimApi.Helpers
 {
    public class SimApiStorage
    {
        private MinioClient Mc { get; }
        public MinioClient Client => Mc;
        private string ServeUrl { get; }
        public string Bucket { get; }
        private IHttpContextAccessor HttpContextAccessor { get; }
        public SimApiStorage(SimApiOptions apiOptions, IHttpContextAccessor httpContextAccessor)
        {
            var options = apiOptions.SimApiStorageOptions;
            HttpContextAccessor = httpContextAccessor;
            var useSsl = false;
            string endpoint;
            if (options.Endpoint.StartsWith("http://"))
            {
                endpoint = options.Endpoint.Replace("http://", string.Empty);
            }
            else if (options.Endpoint.StartsWith("https://"))
            {
                endpoint = options.Endpoint.Replace("https://", string.Empty);
                useSsl = true;
            }
            else
            {
                throw new Exception("SimApiStorage: Error Endpoint");
            }
            ServeUrl = options.ServeUrl;
            Bucket = options.Bucket;
            var mcb = new MinioClient().WithEndpoint(endpoint)
                .WithCredentials(options.AccessKey, options.SecretKey);
            if (useSsl)
            {
                mcb = mcb.WithSSL();
            }
            Mc = mcb.Build();
            var found = Mc.BucketExistsAsync(new BucketExistsArgs().WithBucket(Bucket)).Result;
            if (!found)
            {
                Mc.MakeBucketAsync(new MakeBucketArgs().WithBucket(Bucket)).Wait();
            }
        }
        /// <summary>
        /// 获取上传的URL
        /// </summary>
        /// <param name="path"></param>
        /// <param name="expire"></param>
        /// <returns></returns>
        public string GetUploadUrl(string path, int expire = 7200)
        {
            return Mc.PresignedPutObjectAsync(new PresignedPutObjectArgs().WithBucket(Bucket)
                .WithObject(path).WithExpiry(expire)).Result;
        }
        /// <summary>
        /// 获取下载的URL
        /// </summary>
        /// <param name="path"></param>
        /// <param name="expire"></param>
        /// <returns></returns>
        public string GetDownloadUrl(string path, int expire = 600)
        {
            return Mc.PresignedGetObjectAsync(new PresignedGetObjectArgs().WithBucket(Bucket).WithObject(path)
                .WithExpiry(expire)).Result;
        }
        public string UploadFile(string path, Stream stream, string contentType = "image/png")
        {
            Mc.PutObjectAsync(new PutObjectArgs().WithBucket(Bucket).WithObject(path).WithObjectSize(stream.Length)
                .WithStreamData(stream).WithContentType(contentType)).Wait();
            return null;
        }
        public string FullUrl(string path)
        {
            var httpRequest = HttpContextAccessor.HttpContext?.Request;
            var url = $"{httpRequest?.Scheme}://{httpRequest?.Host}";
            if (string.IsNullOrEmpty(path))
            {
                return path;
            }
            return path.StartsWith("~") ? url + path.Substring(1, path.Length - 1) : $"{ServeUrl}{path}";
        }
    }
 }
@@ -0,0 +1,103 @@
 using System;
 using System.IO;
 using Microsoft.AspNetCore.Hosting;
 namespace SimApi.Helpers
 {
    public class SimApiUpload
    {
        private string FilePathFolder = "/uploads/";
        public string FilePath
        {
            set
            {
                if (!value.StartsWith("/"))
                {
                    FilePathFolder = $"/{value}";
                }
                if (!FilePathFolder.EndsWith("/"))
                {
                    FilePathFolder += "/";
                }
            }
            get
            {
                return FilePathFolder;
            }
        }
        private IWebHostEnvironment Env { get; }
        public SimApiUpload(IWebHostEnvironment env)
        {
            Env = env;
        }
        public class SimApiUploadInfo
        {
            public string Path { get; set; }
            public int Size { get; set; }
        }
        /// <summary>
        /// 保存base64文件,如果有标头按照标头自动识别
        /// </summary>
        /// <param name="base64"></param>
        /// <param name="ext">扩展名</param>
        /// <param name="path">存放路径</param>
        /// <param name="fileName">文件名</param>
        /// <returns></returns>
        public SimApiUploadInfo SaveFile(string base64, string ext = null, string path = null, string fileName = null)
        {
            byte[] bt;
            var filePath = FilePath + path;
            if (fileName == null)
            {
                fileName = Guid.NewGuid().ToString();
            }
            var baseArr = base64.Split(";");
            if (baseArr.Length == 2)
            {
                var info = baseArr[0].Split(":")[1].Split("/");
                if (path == null)
                {
                    filePath += $"{info[0]}/";
                }
                if (ext == null)
                {
                    ext = info[1];
                }
                var data = baseArr[1].Split(",");
                bt = Convert.FromBase64String(data[1]);
            }
            else
            {
                bt = Convert.FromBase64String(base64);
            }
            var fn = fileName + (string.IsNullOrEmpty(ext) ? string.Empty : $".{ext}");
            return WriteFile(filePath, fn, bt);
        }
        /// <summary>
        /// 把数据写入文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="fileName"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public SimApiUploadInfo WriteFile(string filePath, string fileName, byte[] data)
        {
            var realPath = Directory.GetCurrentDirectory() + "/wwwroot" + filePath;
            if (!Directory.Exists(realPath))
            {
                Directory.CreateDirectory(realPath);
            }
            File.WriteAllBytes(realPath + fileName, data);
            return new SimApiUploadInfo
            {
                Path = filePath + fileName,
                Size = data.Length
            };
        }
    }
 }
@@ -1,31 +1,12 @@
 using System;
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.Encodings.Web;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using System.Text.Unicode;
 namespace SimApi.Helpers
 {
    public static class SimApiUtil
    {
        /// <summary>
        /// 当前CST时间
        /// </summary>
        public static DateTime CstNow
        {
            get => DateTime.UtcNow.AddHours(8);
        }
        /// <summary>
        /// 当前秒级时间戳
        /// </summary>
        public static double TimestampNow
        {
            get => (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds;
        }
        /// <summary>
        /// 检测手机号是否正确
        /// </summary>
@@ -33,7 +14,7 @@ namespace SimApi.Helpers
        /// <returns></returns>
        public static bool CheckCell(string cell)
        {
-            var regex = new Regex("^1[3456789]\\d{9}$");
+            var regex = new Regex("^1[34578]\\d{9}$");
            return regex.IsMatch(cell);
        }
@@ -56,18 +37,5 @@ namespace SimApi.Helpers
            return strbul.ToString();
        }
        /// <summary>
        /// 将对象序列化成JSON （控制台输出中文不会被编码）
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string Json(object obj)
        {
            return JsonSerializer.Serialize(obj, new JsonSerializerOptions
            {
                Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
            });
        }
    }
 }
@@ -1,45 +0,0 @@
 using System;
 using Microsoft.Extensions.Logging;
 using SimApi.Helpers;
 namespace SimApi.Logger
 {
    public class SimApiLogger : ILogger
    {
        private string Name { get; }
        public SimApiLogger(string name)
        {
            Name = name;
        }
        public IDisposable BeginScope<TState>(TState state) => default!;
        public bool IsEnabled(LogLevel logLevel) => true;
        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception,
            Func<TState, Exception, string> formatter)
        {
            var defautColor = Console.ForegroundColor;
            Console.ForegroundColor = logLevel switch
            {
                LogLevel.Debug => ConsoleColor.DarkMagenta,
                LogLevel.Information => ConsoleColor.DarkCyan,
                LogLevel.Warning => ConsoleColor.Yellow,
                LogLevel.Error => ConsoleColor.Red,
                LogLevel.Critical => ConsoleColor.DarkRed,
                _ => defautColor
            };
            Console.WriteLine(
                $"[ {Name} ][ {SimApiUtil.CstNow.ToString("yyyy-MM-dd HH:mm:ss:ffff")} ][ {logLevel.ToString()} ]");
            Console.ForegroundColor = defautColor;
            Console.WriteLine($"{state}");
            if (exception != null)
            {
                Console.WriteLine($"{exception}");
            }
            Console.WriteLine();
        }
    }
 }
@@ -1,15 +0,0 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 namespace SimApi.Logger;
 public class SimApiLoggerConfiguration
 {
    public int EventId { get; set; }
    public Dictionary<LogLevel, ConsoleColor> LogLevels { get; set; } = new()
    {
        [LogLevel.Information] = ConsoleColor.Green
    };
 }
@@ -1,22 +0,0 @@
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Logging;
 namespace SimApi.Logger
 {
    public class SimApiLoggerProvider : ILoggerProvider
    {
        private readonly ConcurrentDictionary<string, SimApiLogger> _loggers =
            new ConcurrentDictionary<string, SimApiLogger>();
        public ILogger CreateLogger(string categoryName)
        {
            return _loggers.GetOrAdd(categoryName, name => new SimApiLogger(name));
        }
        public void Dispose()
        {
            _loggers.Clear();
        }
    }
 }
@@ -1,5 +1,4 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
 using SimApi.Communications;
@@ -14,7 +13,6 @@ namespace SimApi.Middlewares
    public class SimApiExceptionMiddleware
    {
        private RequestDelegate Next { get; }
        private ILogger<SimApiExceptionMiddleware> Log { get; }
        public SimApiExceptionMiddleware(RequestDelegate next, ILogger<SimApiExceptionMiddleware> log)
@@ -34,30 +32,24 @@ namespace SimApi.Middlewares
            try
            {
                await Next(context);
                if (context.Response.StatusCode != 200)
                {
                    if (!new[]
                        {
                            301, 302
                        }.Contains(context.Response.StatusCode))
                    {
                        throw new SimApiException(context.Response.StatusCode);
                    }
                }
            }
            catch (SimApiException ex)
            {
-                response = string.IsNullOrEmpty(ex.Message)
+                if (string.IsNullOrEmpty(ex.Message))
-                    ? new SimApiBaseResponse(ex.Code)
+                {
-                    : new SimApiBaseResponse(ex.Code, ex.Message);
+                    response.SetCode(ex.Code);
-
+                }
                else
                {
                    response.SetCodeMsg(ex.Code, ex.Message);
                }
                ErrorResponse(context, response);
            }
            catch (Exception ex)
            {
                Log.LogError(ex.Message);
                Log.LogError(ex.StackTrace);
-                response = new SimApiBaseResponse(500, ex.Message);
+                response.SetCodeMsg(500, ex.Message);
                ErrorResponse(context, response);
            }
        }
@@ -68,13 +60,10 @@ namespace SimApi.Middlewares
        /// <param name="context"></param>
        /// <param name="response"></param>
        private void ErrorResponse(HttpContext context, SimApiBaseResponse response)
        {
            if (!context.Response.HasStarted)
        {
            context.Response.StatusCode = 200;
            context.Response.Headers.Add("Content-Type", "application/json");
            context.Response.WriteAsync(response.ToString());
        }
    }
    }
 }
@@ -1,84 +0,0 @@
 using System;
 using System.Linq;
 using System.Text.Json;
 using SimApi.Helpers;
 namespace SimApi.Models
 {
    public class SimApiBaseModel
    {
        protected virtual string[] MapperIgnoreField { get; set; } =
        {
            "Id", "CreatedAt", "UpdatedAt"
        };
        protected virtual string UpdatedTimeField { get; set; } = "UpdatedAt";
        public void MapData<TS>(TS source, bool mapAll = false)
        {
            //获取要赋值的源数据不为null的项目
            var sourceProps = source.GetType().GetProperties().Where(x => x.GetValue(source) != null)
                .Select(x => new
                {
                    x.Name,
                    x.PropertyType
                })
                .ToDictionary(x => x.Name, x => x.PropertyType);
            //获取目标对象的属性信息
            var targetProps = GetType().GetProperties().Select(x => new
                {
                    x.Name,
                    x.PropertyType
                })
                .ToDictionary(x => x.Name, x => x.PropertyType);
            foreach (var sp in sourceProps.Where(sp =>
                         targetProps.ContainsKey(sp.Key) && sp.Value == targetProps[sp.Key] &&
                         (!MapperIgnoreField.Contains(sp.Key) || mapAll)))
            {
                GetType().GetProperty(sp.Key)?
                    .SetValue(this, source.GetType().GetProperty(sp.Key)?.GetValue(source));
            }
            UpdateTime();
        }
        public void MapData<TS>(TS source, string[] mapFields)
        {
            //获取要赋值的源数据不为null的项目
            var sourceProps = source.GetType().GetProperties().Where(x => x.GetValue(source) != null)
                .Select(x => new
                {
                    x.Name,
                    x.PropertyType
                })
                .ToDictionary(x => x.Name, x => x.PropertyType);
            //获取目标对象的属性信息
            var targetProps = GetType().GetProperties().Select(x => new
                {
                    x.Name,
                    x.PropertyType
                })
                .ToDictionary(x => x.Name, x => x.PropertyType);
            foreach (var sp in sourceProps.Where(sp =>
                         targetProps.ContainsKey(sp.Key) && sp.Value == targetProps[sp.Key] &&
                         mapFields.Contains(sp.Key)))
            {
                GetType().GetProperty(sp.Key)?
                    .SetValue(this, source.GetType().GetProperty(sp.Key)?.GetValue(source));
            }
            UpdateTime();
        }
        /// <summary>
        /// 更新update时间
        /// </summary>
        /// <returns></returns>
        public void UpdateTime()
        {
            GetType().GetProperty(UpdatedTimeField)?.SetValue(this, SimApiUtil.CstNow);
        }
    }
 }
@@ -4,7 +4,7 @@
    "anonymousAuthentication": true
  },
  "profiles": {
-    "SimApi": {
+    "YYApi": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
@@ -1,4 +1,4 @@
-# YYApi 基于Asp.net Core 3/5的一个基础辅助包
+# YYApi 基于Asp.net Core 3的一个基础辅助包
 ![CI](https://github.com/YY-Tech/YYApi/workflows/CI/badge.svg)
@@ -23,33 +23,43 @@ namespace Controllers
 }
 ```
 2. 基于Swagger的API文档服务
 统一配置，现在只需要进行AddSimApi的配置， Configure中直接 UseSimApi即可。
 ```C#
-services.AddSimApi(options =>
+#Startup.cs
-{
+
-   options.ConfigureSimApiDoc(options =>
+	services.AddSimApiDoc("文档名称", "文档描述");
-   {
+
-     options.ApiGroups = new[]
+	app.UseSimApiDoc("名称",SubmitMethod[])
-     {
+
-        new SimApiDocGroupOption
+#控制器中可以直接使用特性
-            {Id = "admin", Name = "后台管理接口", Description = "本接口调用需要Scope：sac.api.admin"},
+
-        new SimApiDocGroupOption
+	[SimApiDoc("分组","名称")]
-            {Id = "user-v1", Name = "用户中心接口", Description = "本接口调用需要Scope：sac.api.user"}
+```
-     };
+
-     options.ApiAuth = new SimApiAuthOption
+3. 简单的基于Redis的登录TOKEN服务
-       {
+
-         Type = new[] {"ClientCredentials", "Implicit", "AuthorizationCode"},
+```C#
-         Scopes = new Dictionary<string, string>
+#Startup.cs
-            {
+service.AddSimApiAuth();
-              {"sac.api.user", "用户信息接口权限"},
+```
-              {"sac.api.admin", "后台管理API"}
+添加时候, 可以从DI中获取 Auth 类,调用 Auth.Set(int,string) 将用户ID/类型和生成的Token绑定,本方法返回缓存中的Key名称
-            },
+
-         AuthorizationUrl = "/connect/authorize",
+```C#
-         TokenUrl = "/connect/token"
+#Startup.cs
-       };
+app.UseSimApiAuth();
-     });
+```
-     options.EnableSimApiStorage = true;
+调用本中间件,然后再需要登录认证的地方,使用 [YYAuth] 特性,即可完成检测登录相关的操作,
-     options.SimApiStorageOptions = Configuration.GetSection("S3").Get<SimApiStorageOptions>();
+如果需要获取用户的ID, 只需要 直接使用 LoginId 属性即可获取
-});
+
 4. 统一返回
 所有Response 均需要继承 SimApiBaseResponse类
 5. 异常处理
 本异常中间件封装了API错误的异常处理,控制器可以使用 Error(int,string) 直接返回API错误
 ```C#
 #Startup.cs
 app.UseSimApiException();
 ```
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net5.0</TargetFramework>
    <OutputType>Library</OutputType>
    <PackOnBuild>true</PackOnBuild>
    <Version>0.2.3</Version>
@@ -12,11 +13,9 @@
    <IncludeSymbols>true</IncludeSymbols>
    <ReleaseVersion>5.0.0</ReleaseVersion>
    <SynchReleaseVersion>false</SynchReleaseVersion>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    <PackageVersion>5.0.2</PackageVersion>
    <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(RunConfiguration)' == 'YYApi' " />
  <ItemGroup>
    <Folder Include="Helpers\" />
    <Folder Include="Communications\" />
@@ -24,12 +23,10 @@
    <Folder Include="Middlewares\" />
    <Folder Include="Attributes\" />
    <Folder Include="Exceptions\" />
    <Folder Include="Configurations\" />
  </ItemGroup>
  <ItemGroup>
-    <PackageReference Include="Minio" Version="4.0.7" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="5.6.3" />
-    <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="6.5.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="5.6.3" />
    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="6.5.0" />
  </ItemGroup>
  <ProjectExtensions>
    <MonoDevelop>
@@ -3,258 +3,178 @@ using SimApi.Helpers;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.OpenApi.Models;
 using Swashbuckle.AspNetCore.SwaggerUI;
 using SimApi.Middlewares;
 using Microsoft.AspNetCore.HttpOverrides;
 using Microsoft.Extensions.Logging;
 using SimApi.Configs;
 using SimApi.Logger;
 namespace SimApi
 {
    /// <summary>
    /// 加入系统的扩展信息
    /// </summary>
-    public static class SimApiExtensions
+    public static class Extensions
    {
        public static string DocumentTitle = "";
        public static string DocumentDescription = "";
        //**********快捷添加**************
        public static IServiceCollection AddSimApi(this IServiceCollection builder,
            Action<SimApiOptions> options = null)
        {
            var simApiOptions = new SimApiOptions();
            options?.Invoke(simApiOptions);
            if (simApiOptions.EnableLogger)
            {
                builder.AddLogging(logger =>
                {
                    logger.ClearProviders();
                    logger.AddProvider(new SimApiLoggerProvider());
                });
            }
            // 是否使用 AUTH
            if (simApiOptions.EnableSimApiAuth)
            {
                builder.AddScoped<SimApiAuth>();
            }
-            if (simApiOptions.EnableCors)
+        /// <summary>
        /// 添加整个SimAPI,同时增加CORS规则
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="title"></param>
        /// <param name="description"></param>
        /// <returns></returns>
        public static IServiceCollection AddSimApi(this IServiceCollection builder, string title,
            string description = null)
        {
-                builder.AddCors(cors => cors.AddPolicy("any",
+            return builder.AddSimApiAuth().AddSimApiDoc(title, description).AddCors().AddSimApiUpload();
                    policy => { policy.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin(); }));
            }
            // 使用SimApiDoc
            if (simApiOptions.EnableSimApiDoc)
            {
                var docOptions = simApiOptions.SimApiDocOptions;
                builder.AddSwaggerGen(x =>
                {
                    foreach (var group in docOptions.ApiGroups)
                    {
                        x.SwaggerDoc(group.Id, new OpenApiInfo
                        {
                            Title = group.Name,
                            Description = group.Description
                        });
                    }
                    x.EnableAnnotations();
                    var haveOauth = false;
                    var haveSimApiAuth = false;
                    var oauthFlows = new OpenApiOAuthFlows();
                    foreach (var auth in docOptions.ApiAuth.Type)
                    {
                        switch (auth)
                        {
                            case "SimApiAuth":
                                x.AddSecurityRequirement(new OpenApiSecurityRequirement
                                {
                                    {
                                        new OpenApiSecurityScheme
                                        {
                                            Reference = new OpenApiReference
                                            {
                                                Type = ReferenceType.SecurityScheme,
                                                Id = "HeaderToken"
                                            }
                                        },
                                        new[]
                                        {
                                            "readAccess", "writeAccess"
                                        }
                                    }
                                });
                                haveSimApiAuth = true;
                                break;
                            case "ClientCredentials":
                                oauthFlows.ClientCredentials = new OpenApiOAuthFlow
                                {
                                    TokenUrl = new Uri(docOptions.ApiAuth.TokenUrl, UriKind.RelativeOrAbsolute),
                                    Scopes = docOptions.ApiAuth.Scopes
                                };
                                haveOauth = true;
                                break;
                            case "Implicit":
                                oauthFlows.Implicit = new OpenApiOAuthFlow
                                {
                                    AuthorizationUrl = new Uri(docOptions.ApiAuth.AuthorizationUrl,
                                        UriKind.RelativeOrAbsolute),
                                    Scopes = docOptions.ApiAuth.Scopes
                                };
                                haveOauth = true;
                                break;
                            case "AuthorizationCode":
                                oauthFlows.AuthorizationCode = new OpenApiOAuthFlow
                                {
                                    TokenUrl = new Uri(docOptions.ApiAuth.TokenUrl, UriKind.RelativeOrAbsolute),
                                    AuthorizationUrl = new Uri(docOptions.ApiAuth.AuthorizationUrl,
                                        UriKind.RelativeOrAbsolute),
                                    Scopes = docOptions.ApiAuth.Scopes
                                };
                                haveOauth = true;
                                break;
                            case "Password":
                                oauthFlows.Password = new OpenApiOAuthFlow
                                {
                                    TokenUrl = new Uri(docOptions.ApiAuth.TokenUrl, UriKind.RelativeOrAbsolute),
                                    Scopes = docOptions.ApiAuth.Scopes
                                };
                                haveOauth = true;
                                break;
                        }
                    }
                    if (haveOauth)
                    {
                        x.AddSecurityDefinition("oauth2", new OpenApiSecurityScheme
                        {
                            Type = SecuritySchemeType.OAuth2,
                            Flows = oauthFlows,
                            Description = docOptions.ApiAuth.Description,
                            In = ParameterLocation.Header
                        });
                        x.AddSecurityRequirement(new OpenApiSecurityRequirement
                        {
                            {
                                new OpenApiSecurityScheme
                                {
                                    Reference = new OpenApiReference
                                    {
                                        Type = ReferenceType.SecurityScheme,
                                        Id = "oauth2"
                                    }
                                },
                                new[]
                                {
                                    "SimApiAuth"
                                }
                            }
                        });
                    }
                    if (haveSimApiAuth)
                    {
                        x.AddSecurityDefinition("HeaderToken",
                            new OpenApiSecurityScheme
                            {
                                Name = "Token",
                                In = ParameterLocation.Header
                            });
                    }
                });
            }
            // 使用Header转发，应对代理后获取真实ip
            if (simApiOptions.EnableForwardHeaders)
            {
                builder.Configure<ForwardedHeadersOptions>(fwOptions =>
                {
                    fwOptions.ForwardedHeaders = ForwardedHeaders.All;
                    fwOptions.KnownNetworks.Clear();
                    fwOptions.KnownProxies.Clear();
                });
            }
            if (simApiOptions.EnableLowerUrl)
            {
                builder.AddRouting(rOptions => rOptions.LowercaseUrls = true);
            }
            if (simApiOptions.EnableSimApiStorage)
            {
                builder.AddHttpContextAccessor();
                builder.AddSingleton<SimApiStorage>();
            }
            builder.AddSingleton(simApiOptions);
            return builder;
        }
        /// <summary>
        ///  使用所有SimApi自定义中间件
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="title"></param>
        /// <param name="staticFileroot"></param>
        /// <param name="submitMethods"></param>
        /// <returns></returns>
-        public static IApplicationBuilder UseSimApi(this IApplicationBuilder builder)
+        public static IApplicationBuilder UseSimApi(this IApplicationBuilder builder, params SubmitMethod[] submitMethods)
        {
-            var options = builder.ApplicationServices.GetRequiredService<SimApiOptions>();
+            return builder.UseSimApiException().UseSimApiDoc(submitMethods).UseMiddleware<SimApiAuthMiddleware>().UseCors(x => x.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin()).UseSimApiUpload();
            var logger = builder.ApplicationServices.GetRequiredService<ILogger<SimApiOptions>>();
            if (options.EnableForwardHeaders)
            {
                logger.LogInformation("开始配置ForwardedHeaders...");
                builder.UseForwardedHeaders();
        }
-            if (options.EnableCors)
+
        //*********组件快捷方式*************
        /// <summary>
        /// 添加自定义授权认证中间价
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static IServiceCollection AddSimApiAuth(this IServiceCollection builder)
        {
-                logger.LogInformation("开始配置Cors全部允许...");
+            return builder.AddScoped<SimApiAuth>();
                builder.UseCors("any");
        }
-            if (options.EnableSimApiAuth)
+        /// <summary>
        /// 添加Base64上传组件
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static IServiceCollection AddSimApiUpload(this IServiceCollection builder)
        {
-                logger.LogInformation("开始配置SimApiAuth...");
+            return builder.AddSingleton<SimApiUpload>();
                builder.UseMiddleware<SimApiAuthMiddleware>();
        }
-            if (options.EnableSimApiDoc)
+        /// <summary>
        /// 添加Api文档服务
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="title">文档标题</param>
        /// <param name="description">文档描述</param>
        /// <returns></returns>
        public static IServiceCollection AddSimApiDoc(this IServiceCollection builder, string title,
            string description = null)
        {
-                logger.LogInformation("开始配置SimApiDoc...");
+            DocumentTitle = title;
-                var docOptions = options.SimApiDocOptions;
+            DocumentDescription = description;
-                builder.UseSwagger(x => x.RouteTemplate = "/swagger/{documentName}.json").UseSwaggerUI(x =>
+            return builder.AddSwaggerGen(x =>
            {
-                    x.DocumentTitle = docOptions.DocumentTitle;
+                x.SwaggerDoc("api", new OpenApiInfo { Title = DocumentTitle, Description = DocumentDescription });
-                    foreach (var group in docOptions.ApiGroups)
+                x.EnableAnnotations();
                x.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
-                        x.SwaggerEndpoint($"/swagger/{group.Id}.json", name: group.Name);
+                    {
                        new OpenApiSecurityScheme
                        {
                            Reference = new OpenApiReference {Type = ReferenceType.SecurityScheme, Id = "HeaderToken"}
                        },
                        new[] {"readAccess", "writeAccess"}
                    }
                });
                x.AddSecurityDefinition("HeaderToken",
                    new OpenApiSecurityScheme { Name = "Token", In = ParameterLocation.Header });
            });
        }
        /// <summary>
        /// 使用异常中间价扩展
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static IApplicationBuilder UseSimApiException(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<SimApiExceptionMiddleware>();
        }
        /// <summary>
        /// 配置上传组件必须
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static IApplicationBuilder UseSimApiUpload(this IApplicationBuilder builder)
        {
            return builder.UseStaticFiles(new StaticFileOptions
            {
                DefaultContentType = "application/x-msdownload",
                ServeUnknownFileTypes = true
            });
        }
        /// <summary>
        /// 使用文档UI
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="title">文档标题</param>
        /// <param name="submitMethods">文档支持的提交方式(如果不指定,默认使用POST)</param>
        /// <returns></returns>
        public static IApplicationBuilder UseSimApiDoc(this IApplicationBuilder builder, params SubmitMethod[] submitMethods)
        {
            return builder.UseSwagger(x => x.RouteTemplate = "docs/{documentName}.json").UseSwaggerUI(x =>
            {
                x.RoutePrefix = "docs";
                x.DocumentTitle = DocumentTitle;
                x.SwaggerEndpoint("/docs/api.json", name: DocumentTitle);
                x.EnableValidator();
-                    x.SupportedSubmitMethods(docOptions.SupportedMethod);
+                if (submitMethods.Length > 0)
                {
                    x.SupportedSubmitMethods(submitMethods);
                }
                else
                {
                    x.SupportedSubmitMethods(SubmitMethod.Post);
                }
                x.DisplayRequestDuration();
            });
        }
-            if (options.EnableSimApiException)
+
        /// <summary>
        /// 同时使用Api文档和异常处理中间件
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="title">文档标题</param>
        /// <param name="submitMethods">API提交方式定义</param>
        /// <returns></returns>
        public static IApplicationBuilder UseSimApiDocEx(this IApplicationBuilder builder, params SubmitMethod[] submitMethods)
        {
-                logger.LogInformation("开始配置SimApiException...");
+            return builder.UseSimApiException().UseSimApiDoc(submitMethods);
                builder.UseMiddleware<SimApiExceptionMiddleware>();
        }
-            //请求一下检测存储错误
+        /// <summary>
-            if (options.EnableSimApiStorage)
+        /// 使用自定义认证中间件（依赖IDistributedCache）
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static IApplicationBuilder UseSimApiAuth(this IApplicationBuilder builder)
        {
-                logger.LogInformation("开始配置SimApiStorage...");
+            return builder.UseMiddleware<SimApiAuthMiddleware>();
                builder.ApplicationServices.GetService<SimApiStorage>();
        }
            if (options.EnableLowerUrl)
            {
                logger.LogInformation("开始配置使用URL小写...");
            }
            return builder;
        }
    }
 }