XdCxRhDW/XdCxRhDW.WebApi/Startup.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.Remoting.Contexts;
using System.Text;
using System.Threading;
using System.Web.Http;
using System.Web.Http.Description;
using System.Web.Http.Filters;
using System.Web.Http.Metadata;
using System.Web.Http.Routing;
using System.Web.Http.Validation;
using System.Web.Http.Validation.Providers;
using System.Xml;
using System.Xml.Linq;
using Autofac;
using Autofac.Integration.Owin;
using Microsoft.Owin;
using Microsoft.Owin.Cors;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using Owin;
using Swashbuckle.Application;
using Swashbuckle.Swagger;
using Autofac.Integration.WebApi;
using XdCxRhDw.Dto;
using Autofac.Core;
using Microsoft.Owin.FileSystems;
using Microsoft.Owin.StaticFiles;

[assembly: OwinStartup(typeof(XdCxRhDW.WebApi.Startup))]

namespace XdCxRhDW.WebApi
{
    /// <summary>
    /// WebApi启动类
    /// </summary>
    public class Startup
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="app"></param>
        public void Configuration(IAppBuilder app)
        {
            app.UseStaticFiles("/wwwroot");
            Directory.CreateDirectory("wwwroot");
            //启用静态目录浏览
            //string root = AppDomain.CurrentDomain.BaseDirectory;
            //var physicalFileSystem = new PhysicalFileSystem(Path.Combine(root, "wwwroot"));
            //var options = new FileServerOptions
            //{
            //    RequestPath = PathString.Empty,
            //    EnableDefaultFiles = true,
            //    FileSystem = physicalFileSystem
            //};
            //options.StaticFileOptions.FileSystem = physicalFileSystem;
            //options.StaticFileOptions.ServeUnknownFileTypes = false;
            //app.UseFileServer(options);


            HttpConfiguration config = new HttpConfiguration();
            IEnumerable<ModelValidatorProvider> modelValidatorProviders = config.Services.GetModelValidatorProviders();

            DataAnnotationsModelValidatorProvider provider = (DataAnnotationsModelValidatorProvider)
                    modelValidatorProviders.Single(x => x is DataAnnotationsModelValidatorProvider);

            provider.RegisterDefaultValidatableObjectAdapter(typeof(CustomModelValidator));

            JsonSerializerSettings setting = new JsonSerializerSettings()
            {
                //日期类型默认格式化处理
                DateFormatHandling = DateFormatHandling.MicrosoftDateFormat,
                DateFormatString = "yyyy-MM-dd HH:mm:ss",

                //驼峰样式
                //ContractResolver = new CamelCasePropertyNamesContractResolver(),

                //空值处理
                //NullValueHandling = NullValueHandling.Ignore,

                //设置序列化的最大层数
                MaxDepth = 10,

                //解决json序列化时的循环引用问题
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };
            config.Formatters.JsonFormatter.SerializerSettings = setting;
            config.Formatters.Remove(config.Formatters.XmlFormatter);

            config.Filters.Add(new HandlerErrorAttribute());

            //config.Routes.MapHttpRoute("DefaultApiWithId", "Api/{controller}/{id}", new { id = RouteParameter.Optional }, new { id = @"\d+" });
            config.Routes.MapHttpRoute("DefaultApiWithAction", "Api/{controller}/{action}");
            //config.Routes.MapHttpRoute("DefaultApiGet", "Api/{controller}", new { action = "Get" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) });
            //config.Routes.MapHttpRoute("DefaultApiPost", "Api/{controller}", new { action = "Post" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Post) });
            ConfigureSwagger(config);
            //添加路由路径
            config.MapHttpAttributeRoutes();

            var builder = new ContainerBuilder();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            //将程序集中的所有Service注入到容器
            var serviceTypes = Assembly.GetExecutingAssembly().GetTypes().Where(p => p.Namespace != null && p.Namespace.EndsWith(".Service")).ToList();
            foreach (var serviceType in serviceTypes)
            {
                //单例模式注入Service
                builder.RegisterTypes(serviceType).SingleInstance();
            }
            
            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacLifetimeScopeInjector(container);
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);

            app.UseCors(CorsOptions.AllowAll);
            app.UseWebApi(config);
        }

        private static void ConfigureSwagger(HttpConfiguration config)
        {
            var thisAssembly = typeof(Startup).Assembly;
            config.EnableSwagger(c =>
             {
                 c.IgnoreObsoleteActions();//忽略过时的方法
                 c.IgnoreObsoleteProperties();//忽略过时的属性
                 c.PrettyPrint();//漂亮缩进
                 c.SingleApiVersion("v1", "多模式融合定位平台Http接口");
                 c.ApiKey("123456");

                 //设置接口描述xml路径地址
                 var webApiXmlPath1 = $"{AppDomain.CurrentDomain.BaseDirectory}{typeof(Startup).Assembly.GetName().Name}.xml";
                 c.IncludeXmlComments(webApiXmlPath1);
                 var webApiXmlPath2 = $"{AppDomain.CurrentDomain.BaseDirectory}{typeof(AjaxResult).Assembly.GetName().Name}.xml";
                 c.IncludeXmlComments(webApiXmlPath2);
                 //c.UseFullTypeNameInSchemaIds();//使用完整类型名称
                 //加入控制器描述
                 c.CustomProvider((defaultProvider) => new SwaggerControllerDescProvider(defaultProvider, webApiXmlPath1));
                 c.OperationFilter<FileUploadOperation>();
                 c.SchemaFilter<SwaggerEnumFilter>();
             })
             .EnableSwaggerUi(c =>
             {
                 c.InjectJavaScript(thisAssembly, $"{Assembly.GetExecutingAssembly().GetName().Name}.Swagger.js");
                 c.DocumentTitle("多模式融合定位平台Http接口");
             });
        }


        class FileUploadOperation : IOperationFilter
        {
            public void Apply(Operation operation, SchemaRegistry schemaRegistry, ApiDescription apiDescription)
            {
                if (operation.parameters == null)
                {
                    operation.parameters = new List<Swashbuckle.Swagger.Parameter>();
                }
                var requestAttributes = apiDescription.GetControllerAndActionAttributes<SwaggerFormAttribute>();
                foreach (var attr in requestAttributes)
                {
                    operation.parameters.Add(new Swashbuckle.Swagger.Parameter
                    {
                        description = attr.Description,
                        name = attr.Name,
                        @in = "formData",
                        required = true,
                        type = "file",
                    });
                    operation.consumes.Add("multipart/form-data");
                }
            }
        }
        class HandlerErrorAttribute : ExceptionFilterAttribute
        {
            /// <summary>
            /// 控制器方法中出现异常，会调用该方法捕获异常
            /// </summary>
            /// <param name="context">提供使用</param>
            public override void OnException(HttpActionExecutedContext context)
            {
                base.OnException(context);
                Serilog.Log.Error(context.Exception, context.Exception.Message);
                //LogFile.WriteError(context.Exception.Message);
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new StringContent(
                   JsonConvert.SerializeObject(
                    new
                    {
                        code = -1,
                        data = "",
                        msg = context.Exception.Message
                    }), Encoding.UTF8, "text/json")
                });
            }
        };

        class SwaggerControllerDescProvider : ISwaggerProvider
        {
            private readonly ISwaggerProvider _swaggerProvider;
            private static ConcurrentDictionary<string, SwaggerDocument> _cache = new ConcurrentDictionary<string, SwaggerDocument>();
            private readonly string _xml;
            /// <summary>
            /// 
            /// </summary>
            /// <param name="swaggerProvider"></param>
            /// <param name="xml">xml文档路径</param>
            public SwaggerControllerDescProvider(ISwaggerProvider swaggerProvider, string xml)
            {
                _swaggerProvider = swaggerProvider;
                _xml = xml;
            }

            public SwaggerDocument GetSwagger(string rootUrl, string apiVersion)
            {

                var cacheKey = string.Format("{0}_{1}", rootUrl, apiVersion);
                SwaggerDocument srcDoc = null;
                //只读取一次
                if (!_cache.TryGetValue(cacheKey, out srcDoc))
                {
                    srcDoc = _swaggerProvider.GetSwagger(rootUrl, apiVersion);

                    srcDoc.vendorExtensions = new Dictionary<string, object> { { "ControllerDesc", GetControllerDesc() } };
                    _cache.TryAdd(cacheKey, srcDoc);
                }
                return srcDoc;
            }

            /// <summary>
            /// 从API文档中读取控制器描述
            /// </summary>
            /// <returns>所有控制器描述</returns>
            public ConcurrentDictionary<string, string> GetControllerDesc()
            {
                string xmlpath = _xml;
                ConcurrentDictionary<string, string> controllerDescDict = new ConcurrentDictionary<string, string>();
                if (File.Exists(xmlpath))
                {
                    XmlDocument xmldoc = new XmlDocument();
                    xmldoc.Load(xmlpath);
                    string type = string.Empty, path = string.Empty, controllerName = string.Empty;

                    string[] arrPath;
                    int length = -1, cCount = "Controller".Length;
                    XmlNode summaryNode = null;
                    foreach (XmlNode node in xmldoc.SelectNodes("//member"))
                    {
                        type = node.Attributes["name"].Value;
                        if (type.StartsWith("T:"))
                        {
                            //控制器
                            arrPath = type.Split('.');
                            length = arrPath.Length;
                            controllerName = arrPath[length - 1];
                            if (controllerName.EndsWith("Controller"))
                            {
                                //获取控制器注释
                                summaryNode = node.SelectSingleNode("summary");
                                string key = controllerName.Remove(controllerName.Length - cCount, cCount);
                                if (summaryNode != null && !string.IsNullOrEmpty(summaryNode.InnerText) && !controllerDescDict.ContainsKey(key))
                                {
                                    controllerDescDict.TryAdd(key, summaryNode.InnerText.Trim());
                                }
                            }
                        }
                    }
                }
                return controllerDescDict;
            }
        }

    }
    /// <summary>
    /// Swagger文件上传特性标注
    /// </summary>
    [AttributeUsage(AttributeTargets.Method)]
    public sealed class SwaggerFormAttribute : Attribute
    {

        /// <summary>
        /// 
        /// </summary>
        public SwaggerFormAttribute()
        {
            this.Name = "文件";
            this.Description = "选择文件";
        }
        /// <summary>
        /// Swagger特性标注
        /// </summary>
        /// <param name="name"></param>
        /// <param name="description"></param>
        public SwaggerFormAttribute(string name, string description)
        {
            Name = name;
            Description = description;
        }
        /// <summary>
        /// 名称
        /// </summary>
        public string Name { get; private set; }
        /// <summary>
        /// 描述
        /// </summary>
        public string Description { get; private set; }
    }


    /// <summary>
    /// autofac属性注入
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class AutowiredAttribute : Attribute
    {
    }
    // 属性注入选择器
    class AutowiredPropertySelector : IPropertySelector
    {
        public bool InjectProperty(PropertyInfo propertyInfo, object instance)
        {
            // 带有 AutowiredAttribute 特性的属性会进行属性注入
            return propertyInfo.CustomAttributes.Any(it => it.AttributeType == typeof(AutowiredAttribute));
        }
    }
    class SwaggerEnumFilter : ISchemaFilter
    {
        public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
        {
            UpdateSchemaDescription(schema, type);
        }
        private void UpdateSchemaDescription(Schema schema, Type type)
        {
            if (type.IsEnum)//枚举直接应用在controller接口中
            {
                var items = GetEnumInfo(type);
                if (items.Length > 0)
                {
                    var description = GetEnumInfo(type);
                    schema.description = string.IsNullOrEmpty(schema.description) ? description : $"{schema.description}:{description}";
                }
            }
            else if (type.IsClass && type != typeof(string))//枚举在类的属性中
            {
                if (schema.properties == null) return;
                var props = type.GetProperties();
                foreach (var prop in props)
                {
                    var propScheama = schema.properties[prop.Name];
                    if (prop.PropertyType.IsClass && prop.PropertyType != typeof(string))
                    {
                        UpdateSchemaDescription(propScheama, prop.PropertyType);
                    }
                    else
                    {
                        if (prop.PropertyType.IsEnum)
                        {
                            var description = GetEnumInfo(prop.PropertyType);
                            propScheama.description = string.IsNullOrWhiteSpace(propScheama.description) ? description : $"{propScheama.description}:{description}";
                            propScheama.@enum = null;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 获取枚举值+描述  
        /// </summary>
        /// <param name="enumType"></param>
        /// <returns></returns>
        private string GetEnumInfo(Type enumType)
        {
            var fields = enumType.GetFields();
            List<string> list = new List<string>();
            foreach (var field in fields)
            {
                if (!field.FieldType.IsEnum) continue;
                string description = null;
                if (description == null)//取DescriptionAttribute的值
                {
                    var descriptionAttr = field.GetCustomAttribute<DescriptionAttribute>();
                    if (descriptionAttr != null && !string.IsNullOrWhiteSpace(descriptionAttr.Description))
                    {
                        description = descriptionAttr.Description;
                    }
                }
                if (description == null)//取DisplayAttribute的值
                {
                    var dispalyAttr = field.GetCustomAttribute<DisplayAttribute>();
                    if (dispalyAttr != null && !string.IsNullOrWhiteSpace(dispalyAttr.Name))
                    {
                        description = dispalyAttr.Name;
                    }
                }
                if (description == null)//取DisplayNameAttribute的值
                {
                    var dispalyNameAttr = field.GetCustomAttribute<DisplayNameAttribute>();
                    if (dispalyNameAttr != null && !string.IsNullOrWhiteSpace(dispalyNameAttr.DisplayName))
                    {
                        description = dispalyNameAttr.DisplayName;
                    }
                }
                if (description == null)//取字段名
                {
                    description = field.Name;
                }
                var value = field.GetValue(null);
                list.Add($"{description}={(int)value}");
            }
            return string.Join(",", list);
        }
    }
    class CustomModelValidator : ModelValidator
    {
        public CustomModelValidator(IEnumerable<ModelValidatorProvider> modelValidatorProviders) : base(modelValidatorProviders)
        {

        }


        public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
        {
            if (metadata.IsComplexType && metadata.Model == null)
            {
                return new List<ModelValidationResult> { new ModelValidationResult { MemberName = metadata.GetDisplayName(), Message = "请求参数对象不能为空。" } };
            }

            if (typeof(IValidatableObject).IsAssignableFrom(metadata.ModelType))
            {
                var validationResult = (metadata.Model as IValidatableObject).Validate(new ValidationContext(metadata.Model));
                if (validationResult != null)
                {
                    var modelValidationResults = new List<ModelValidationResult>();
                    foreach (var result in validationResult)
                    {
                        modelValidationResults.Add(new ModelValidationResult
                        {
                            MemberName = string.Join(",", result.MemberNames),
                            Message = result.ErrorMessage
                        });
                    }

                    return modelValidationResults;
                }
                return null;
            }

            return GetModelValidator(ValidatorProviders).Validate(metadata, container);
        }
    }
}