添加日志

ApiLog.Act/ApiLog.Act.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{42144D88-4A3C-407A-9CAC-70907E482821}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ApiLog.Act</RootNamespace>
+    <AssemblyName>ApiLog.Act</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="MongoDB.Bson, Version=2.2.4.26, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\MongoDB.Bson.2.2.4\lib\net45\MongoDB.Bson.dll</HintPath>
+    </Reference>
+    <Reference Include="MongoDB.Driver, Version=2.2.4.26, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\MongoDB.Driver.2.2.4\lib\net45\MongoDB.Driver.dll</HintPath>
+    </Reference>
+    <Reference Include="MongoDB.Driver.Core, Version=2.2.4.26, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\MongoDB.Driver.Core.2.2.4\lib\net45\MongoDB.Driver.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="MongoDB.Driver.Legacy, Version=2.2.4.26, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\mongocsharpdriver.2.2.4\lib\net45\MongoDB.Driver.Legacy.dll</HintPath>
+    </Reference>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Http">
+      <HintPath>..\..\..\develop\负责项目\许Boss\new_edc\packages\Microsoft.AspNet.WebApi.Core.5.2.3\lib\net45\System.Web.Http.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="DAL\MongoLogRepository.cs" />
+    <Compile Include="DAL\Mongo\APILogsMongRepository.cs" />
+    <Compile Include="DAL\Mongo\APIWebLogsMongRepository.cs" />
+    <Compile Include="Filters\RequestLogAttribute.cs" />
+    <Compile Include="Filters\ResponseLogAttribute.cs" />
+    <Compile Include="Models\LogModel\Entity\BaseEntity.cs" />
+    <Compile Include="Models\LogModel\Entity\KafkaLog.cs" />
+    <Compile Include="Models\LogModel\Model\AddRequestLogModel.cs" />
+    <Compile Include="Models\LogModel\Param\AddRequestLogParam.cs" />
+    <Compile Include="Models\LogModel\Param\AddResponseLogParam.cs" />
+    <Compile Include="Models\Mongo\PushAPILogs.cs" />
+    <Compile Include="Models\Mongo\APIWebLogs.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Tools\APILogConfig.cs" />
+    <Compile Include="Tools\IdHelp.cs" />
+    <Compile Include="Tools\KafkaConfig.cs" />
+    <Compile Include="Tools\SysUtil.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="BLL\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\PushPlatform.Common\PushPlatform.Common.csproj">
+      <Project>{3bcad396-cae2-4c69-83dc-67e955433678}</Project>
+      <Name>PushPlatform.Common</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file

ApiLog.Act/DAL/Mongo/APILogsMongRepository.cs

+using ApiLog.Act.Models.Log;
+using ApiLog.Act.Models.Mongo;
+using MongoDB.Driver;
+using PushPlatform.Common.Util;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ApiLog.Act.DAL.Mongo
+{
+    public class APILogsMongRepository
+    {
+        private MongoLogRepository mongoRep = new MongoLogRepository();
+
+        /// <summary>
+        /// 集合名称
+        /// </summary>
+        private static readonly string _CollectionName = "PushAPILogs";
+
+        #region 新增请求日志
+
+        /// <summary>
+        /// 新增请求日志
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public async Task<AddRequestLogModel> AddRequestLogAsync(AddRequestLogParam param)
+        {
+            PushAPILogs entity = new PushAPILogs();
+            ObjectUtil.CopyPropertys(param, entity);
+            entity.ID = param.TraceID;
+            entity.RequestTime = DateTime.Now;
+            mongoRep.Add<PushAPILogs>(entity);
+            return new AddRequestLogModel() { RequestTime = entity.RequestTime, TraceID = param.TraceID };
+        }
+
+        #endregion
+
+        #region 新增响应日志
+
+        /// <summary>
+        /// 新增响应日志
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public void AddResponseLog(AddResponseLogParam param)
+        {
+            var builder = Builders<PushAPILogs>.Filter;
+            var filter = builder.Eq(nameof(PushAPILogs.ID), param.ParentTraceID);
+            var update = Builders<PushAPILogs>.Update
+                .Set(nameof(PushAPILogs.ResponseBody), param.ResponseBody)
+                .Set(nameof(PushAPILogs.ResponseTime), DateTime.Now)
+                .Set(nameof(PushAPILogs.TimeCost), param.TimeCost);
+
+            if (param.IsError)
+            {
+                update = update.Set(nameof(PushAPILogs.IsError), param.IsError)
+                    .Set(nameof(PushAPILogs.ErrorBody), param.ErrorBody)
+                    .Set(nameof(PushAPILogs.ErrorBody), param.ErrorBody);
+            }
+
+            mongoRep.Update(_CollectionName.ToLower(),filter, update);
+        }
+        #endregion
+    }
+}

ApiLog.Act/DAL/Mongo/APIWebLogsMongRepository.cs

+using ApiLog.Act.Models.Log;
+using ApiLog.Act.Models.Mongo;
+using MongoDB.Driver;
+using PushPlatform.Common.Util;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ApiLog.Act.DAL.Mongo
+{
+    public class APIWebLogsMongRepository
+    {
+        private MongoLogRepository mongoRep = new MongoLogRepository();
+        //private MongoRepository mongoRep = new MongoRepository();
+
+        /// <summary>
+        /// 集合名称
+        /// </summary>
+        private static readonly string _CollectionName = "APIWebLogs";
+
+        #region 新增请求日志
+
+        /// <summary>
+        /// 新增请求日志
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public async Task<AddRequestLogModel> AddRequestLogAsync(AddRequestLogParam param)
+        {
+            APIWebLogs entity = new APIWebLogs();
+            ObjectUtil.CopyPropertys(param, entity);
+            entity.ID = param.TraceID;
+            entity.RequestTime = DateTime.Now;
+            mongoRep.Add<APIWebLogs>(entity);
+            return new AddRequestLogModel() { RequestTime = entity.RequestTime, TraceID = param.TraceID };
+        }
+
+        #endregion
+
+        #region 新增响应日志
+
+        /// <summary>
+        /// 新增响应日志
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public void AddResponseLog(AddResponseLogParam param)
+        {
+            var builder = Builders<APIWebLogs>.Filter;
+            var filter = builder.Eq(nameof(APIWebLogs.ID), param.ParentTraceID);
+            var update = Builders<APIWebLogs>.Update
+                .Set(nameof(APIWebLogs.ResponseBody), param.ResponseBody)
+                .Set(nameof(APIWebLogs.ResponseTime), DateTime.Now)
+                .Set(nameof(APIWebLogs.TimeCost), param.TimeCost);
+
+            if (param.IsError)
+            {
+                update = update.Set(nameof(APIWebLogs.IsError), param.IsError)
+                    .Set(nameof(APIWebLogs.ErrorBody), param.ErrorBody)
+                    .Set(nameof(APIWebLogs.ErrorBody), param.ErrorBody);
+            }
+
+            mongoRep.Update(_CollectionName.ToLower(),filter, update);
+        }
+
+
+
+        /// <summary>
+        /// 查询日志信息
+        /// </summary>
+        /// <param name="aPIWebLogs"></param>
+        /// <returns></returns>
+        public async Task<SearchLogsPaggingAsyncOutput> SearchLogsPaggingAsync(SearchAPIWebLogs aPIWebLogs)
+        {
+            SearchLogsPaggingAsyncOutput searchLogsPaggingAsyncOutput = new SearchLogsPaggingAsyncOutput();
+            Expression<Func<APIWebLogs, bool>> expre = x => x.RequestTime > aPIWebLogs.BeginDate && x.RequestTime < aPIWebLogs.EndDate&&x.IsError==aPIWebLogs.IsError;
+            Expression<Func<APIWebLogs, object>> sort = x => x.RequestTime;
+            if (aPIWebLogs.APIName != null && aPIWebLogs.APIName != "") {
+                expre = x => x.APIName == aPIWebLogs.APIName && x.RequestTime > aPIWebLogs.BeginDate && x.RequestTime < aPIWebLogs.EndDate && x.IsError == aPIWebLogs.IsError;
+            }
+            var result=await mongoRep.PagingQueryAndOrderWithoutBaseEntity<APIWebLogs>(expre, sort, aPIWebLogs.pageIndex, aPIWebLogs.PageSize,true);
+            var count= mongoRep.GetCountWithoutBaseEntity<APIWebLogs>(expre);
+            searchLogsPaggingAsyncOutput.aPIWebLogs = result;
+            searchLogsPaggingAsyncOutput.Count = (int)count;
+            return searchLogsPaggingAsyncOutput;
+        }
+
+        #endregion
+    }
+}

ApiLog.Act/DAL/MongoLogRepository.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using MongoDB.Bson;
+using MongoDB.Driver;
+using System.Configuration;
+using System.Linq.Expressions;
+using ApiLog.Act.Models.Log.Entity;
+
+namespace ApiLog.Act.DAL
+{
+    public class MongoLogRepository
+    {
+        protected static IMongoClient _client;
+        protected static MongoClientSettings _setting;
+        protected static IMongoDatabase _database;
+
+        #region 构造方法 测试环境
+        /// <summary>
+        /// 构造方法
+        /// </summary>
+        /// <param name="isExpand">是否使用扩展的mongo，默认使用自己的mongo</param>
+        public MongoLogRepository()
+        {
+            string name = "mongo_edc_log";
+            string connStr = ConfigurationManager.ConnectionStrings[name].ConnectionString;
+            MongoUrl url = new MongoUrl(connStr);
+            if (_client == null)
+                _client = new MongoClient(url);
+            if (_database == null)
+                _database = _client.GetDatabase(url.DatabaseName);
+        }
+
+        public static void RefreshClient(bool isExpand = false)
+        {
+        }
+
+        ///// <summary>
+        ///// 构造方法
+        ///// </summary>
+        ///// <param name="connStr">mongodb连接字符串</param>
+        public MongoLogRepository(string connStr)
+        {
+            MongoUrl url = new MongoUrl(connStr);
+            _client = new MongoClient(url);
+            _database = _client.GetDatabase(url.DatabaseName);
+        }
+        #endregion
+
+        #region 构造方法副本集 正式环境
+        ///// <summary>
+        ///// 构造方法副本集
+        ///// </summary>
+        //public MongoRepository()
+        //{
+        //    string connStr = ConfigurationManager.ConnectionStrings["mongo_address"].ConnectionString;
+        //    string databaseName = ConfigurationManager.ConnectionStrings["mongo_edc"].ConnectionString;
+        //    string replica = ConfigurationManager.ConnectionStrings["mongo_replica"].ConnectionString;
+        //    var ips = connStr.Split(';');
+        //    var servicesList = new List<MongoServerAddress>();
+        //    foreach (var ip in ips)
+        //    {
+        //        var host = ip.Split(':')[0];
+        //        var port = Convert.ToInt32(ip.Split(':')[1]);
+        //        servicesList.Add(new MongoServerAddress(host, port));
+        //    }
+        //    _setting = new MongoClientSettings();
+        //    _setting.ReplicaSetName = replica;
+        //    _setting.Servers = servicesList;
+
+        //    if (_client == null)
+        //        _client = new MongoClient(_setting);
+
+        //    if (_database == null)
+        //        _database = _client.GetDatabase(databaseName);
+        //}
+
+        ///// <summary>
+        ///// 构造方法
+        ///// </summary>
+        ///// <param name = "connStr" > mongodb连接字符串 </ param >
+        //public MongoRepository(string connStr)
+        //{
+        //    MongoUrl url = new MongoUrl(connStr);
+        //    _client = new MongoClient(url);
+        //    _database = _client.GetDatabase(url.DatabaseName);
+        //}
+        #endregion
+
+        #region 添加纪录
+
+        #region 添加单条纪录（泛型）
+        /// <summary>
+        /// 添加纪录（泛型）
+        /// </summary>
+        /// <typeparam name="T">对象类型</typeparam>
+        /// <param name="obj">对象</param>
+        public void Add<T>(T obj)
+        {
+            string collectionName = GetCollectionName<T>();
+            var collection = _database.GetCollection<T>(collectionName);
+            collection.InsertOneAsync(obj);
+        }
+        #endregion
+
+        #region 批量添加（泛型）
+        /// <summary>
+        /// 批量添加（泛型）
+        /// </summary>
+        /// <typeparam name="T">对象类型</typeparam>
+        /// <param name="list">实体集合</param>
+        public void AddMany<T>(List<T> list)
+        {
+            string collectionName = GetCollectionName<T>();
+            var collection = _database.GetCollection<T>(collectionName);
+            collection.InsertMany(list);
+        }
+        #endregion
+
+        #region 添加单条纪录（bson文档）
+        /// <summary>
+        /// 添加纪录（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="bson">bson文档</param>
+        public void Add(string collectionName, BsonDocument bson)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            collection.InsertOneAsync(bson);
+        }
+        #endregion
+
+        #region 批量添加（bson文档）
+        /// <summary>
+        /// 批量添加（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="bson">bson文档集合</param>
+        public void AddMany(string collectionName, List<BsonDocument> bson)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            collection.InsertManyAsync(bson);
+        }
+        #endregion
+
+        #endregion
+
+        #region 更新记录
+
+        #region 更新一条记录（泛型）
+        /// <summary>
+        /// 更新一条记录（泛型）
+        /// </summary>
+        /// <typeparam name="T">对象类型</typeparam>
+        /// <param name="obj">对象</param>
+        public void Update<T>(T obj)
+        {
+            string tableName = string.Empty;
+            string objId = string.Empty;
+            var updateBson = ObjectToUpdateBson(obj, out tableName, out objId);
+            if (!string.IsNullOrEmpty(tableName) && updateBson != null)
+            {
+                var filter = Builders<BsonDocument>.Filter.Eq("_id", objId);
+                _database.GetCollection<BsonDocument>(tableName).FindOneAndUpdateAsync(filter, updateBson);
+            }
+        }
+
+        public void Replace(string collectionName, FilterDefinition<BsonDocument> filter, BsonDocument document)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+
+            collection.ReplaceOneAsync(filter, document);
+        }
+
+
+        /// <summary>
+        /// 更新单条数据（泛型）
+        /// </summary>
+        /// <typeparam name="T">类型</typeparam>
+        /// <param name="collectionName">集合名称</param>
+        /// <param name="filter">条件</param>
+        /// <param name="update">更新内容</param>
+        /// <returns>更新条数</returns>
+        public long Update<T>(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions updateOptions = null) where T : new()
+        {
+            string collectionName = GetCollectionName<T>();
+            var collection = _database.GetCollection<T>(collectionName);
+            var result = collection.UpdateOneAsync(filter, update, updateOptions).Result;
+            return result.ModifiedCount;
+        }
+
+
+        public long Update<T>(string collectionName, FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions updateOptions = null) where T : new()
+        {
+            var collection = _database.GetCollection<T>(collectionName);
+            var result = collection.UpdateOneAsync(filter, update, updateOptions).Result;
+            return result.ModifiedCount;
+        }
+        #endregion
+
+        #region 批量更新记录（泛型）
+        /// <summary>
+        /// 批量更新记录（泛型）
+        /// </summary>
+        /// <typeparam name="T">实体类型</typeparam>
+        /// <param name="expre">更新表达式</param>
+        /// <param name="updateDefinition">更新内容</param>
+        public void UpdateMany<T>(Expression<Func<T, bool>> expre, UpdateDefinition<T> updateDefinition)
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            collection.UpdateManyAsync<T>(expre, updateDefinition);
+        }
+        #endregion
+
+        #region 更新记录（bson文档）
+        /// <summary>
+        /// 更新一条记录（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">更新条件</param>
+        /// <param name="updateDefinition">更新内容</param>
+        public long Update(string collectionName, FilterDefinition<BsonDocument> filter, UpdateDefinition<BsonDocument> updateDefinition)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            //Task<BsonDocument> task = collection.FindOneAndUpdateAsync(filter, updateDefinition, new FindOneAndUpdateOptions<BsonDocument>() { IsUpsert = true });
+            //BsonDocument result = task.Result;
+            UpdateResult result = collection.UpdateOne(filter, updateDefinition, new UpdateOptions { IsUpsert = true });
+            return result.ModifiedCount;
+        }
+        #endregion
+
+        #region 更新记录（bson文档）
+        /// <summary>
+        /// 更新一条记录（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">更新条件</param>
+        /// <param name="updateDefinition">更新内容</param>
+        public void UpdateMany(string collectionName, FilterDefinition<BsonDocument> filter, UpdateDefinition<BsonDocument> updateDefinition)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+
+            collection.UpdateManyAsync(filter, updateDefinition);
+        }
+        #endregion
+
+        #endregion
+
+        #region 删除记录
+
+        #region 删除单条记录（泛型）
+        /// <summary>
+        /// 删除单条记录（泛型）
+        /// </summary>
+        /// <typeparam name="T">实体类型</typeparam>
+        /// <param name="expre">条件表达式</param>
+        public void Delete<T>(Expression<Func<T, bool>> expre)
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            collection.FindOneAndDeleteAsync<T>(expre);
+        }
+
+        public long Delete<T>(string collectionName, FilterDefinition<T> filter)
+        {
+            var collection = _database.GetCollection<T>(collectionName);
+
+            return collection.DeleteOne(filter).DeletedCount;
+        }
+
+        #endregion
+
+        #region 批量删除记录（泛型）
+        /// <summary>
+        /// 批量删除记录（泛型）
+        /// </summary>
+        /// <typeparam name="T">对象类型</typeparam>
+        /// <param name="expre">条件表达式</param>
+        public void DeleteMany<T>(Expression<Func<T, bool>> expre)
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            collection.DeleteManyAsync<T>(expre);
+        }
+        #endregion
+
+        #region 删除单条记录(bson文档)
+        /// <summary>
+        /// 删除单条记录(bson文档)
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">删除条件</param>
+        public void Delete(string collectionName, FilterDefinition<BsonDocument> filter)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            collection.FindOneAndDeleteAsync(filter);
+        }
+        #endregion
+
+        #region 批量删除记录(bson文档)
+        /// <summary>
+        /// 批量删除记录(bson文档)
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">删除条件</param>
+        public void DeleteMany(string collectionName, FilterDefinition<BsonDocument> filter)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            collection.DeleteMany(filter);
+        }
+        public void DeleteMany<T>(string collectionName, FilterDefinition<T> filter)
+        {
+            var collection = _database.GetCollection<T>(collectionName);
+            collection.DeleteMany(filter);
+        }
+        #endregion
+
+        #endregion
+
+        #region 查询记录
+
+        #region 根据条件查询（泛型）
+        /// <summary>
+        /// 根据条件查询（泛型）
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="expre">查询条件</param>
+        /// <returns></returns>
+        public Task<List<T>> Query<T>(Expression<Func<T, bool>> expre) where T : BaseEntity
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            return collection.Find<T>(expre).ToListAsync();
+        }
+        #endregion
+
+        #region 根据条件分页查询（泛型）
+        /// <summary>
+        /// 根据条件分页查询（泛型）
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="expre">条件</param>
+        /// <param name="pageIndex">页码</param>
+        /// <param name="pageSize">没页大小</param>
+        /// <returns></returns>
+        public Task<List<T>> PagingQuery<T>(Expression<Func<T, bool>> expre, int pageIndex, int pageSize) where T : BaseEntity
+        {
+            int skip = (pageIndex - 1) * pageSize;
+
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            return collection.Find<T>(expre).Skip(skip).Limit(pageSize).ToListAsync();
+        }
+        #endregion
+
+        #region 根据条件分页，排序查询（泛型）
+        /// <summary>
+        /// 根据条件分页，排序查询（泛型）
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="expre">查询条件</param>
+        /// <param name="orderExpre">排序字段</param>
+        /// <param name="pageIndex">页码</param>
+        /// <param name="pageSize">每页大小</param>
+        /// <param name="isAsc">是否正序</param>
+        /// <returns></returns>
+        public Task<List<T>> PagingQueryAndOrder<T>(Expression<Func<T, bool>> expre, Expression<Func<T, object>> sort, int pageIndex, int pageSize, bool isAsc) where T : BaseEntity
+        {
+            int skip = (pageIndex - 1) * pageSize;
+
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            if (isAsc)
+            {
+                return collection.Find<T>(expre).SortBy(sort).Skip(skip).Limit(pageSize).ToListAsync();
+            }
+            else
+            {
+                return collection.Find<T>(expre).SortByDescending(sort).Skip(skip).Limit(pageSize).ToListAsync();
+            }
+        }
+
+
+        /// <summary>
+        /// 根据条件分页，排序查询（泛型）
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="expre">查询条件</param>
+        /// <param name="orderExpre">排序字段</param>
+        /// <param name="pageIndex">页码</param>
+        /// <param name="pageSize">每页大小</param>
+        /// <param name="isAsc">是否正序</param>
+        /// <returns></returns>
+        public Task<List<T>> PagingQueryAndOrderWithoutBaseEntity<T>(Expression<Func<T, bool>> expre, Expression<Func<T, object>> sort, int pageIndex, int pageSize, bool isAsc)
+        {
+            int skip = (pageIndex - 1) * pageSize;
+
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            if (isAsc)
+            {
+                return collection.Find<T>(expre).SortBy(sort).Skip(skip).Limit(pageSize).ToListAsync();
+            }
+            else
+            {
+                return collection.Find<T>(expre).SortByDescending(sort).Skip(skip).Limit(pageSize).ToListAsync();
+            }
+        }
+        #endregion
+
+        #region 查询记录条数（泛型）
+        /// <summary>
+        /// 查询记录条数（泛型）
+        /// </summary>
+        /// <typeparam name="T">类型</typeparam>
+        /// <param name="expre">查询条件</param>
+        /// <returns></returns>
+        public long GetCount<T>(Expression<Func<T, bool>> expre)
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            return collection.Count(expre);
+        }
+        #endregion
+
+        #region 根据条件查询（bson文档）
+        /// <summary>
+        /// 根据条件查询（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">查询条件</param>
+        /// <returns></returns>
+        public Task<List<BsonDocument>> Query(string collectionName, FilterDefinition<BsonDocument> filter)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            return collection.Find(filter).ToListAsync();
+        }
+
+        public Task<BsonDocument> Query(string collectionName, FilterDefinition<BsonDocument> filter, ProjectionDefinition<BsonDocument> projection)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            return collection.Find(filter).Project(projection).SingleOrDefaultAsync();
+        }
+
+        public Task<List<BsonDocument>> Query(string collectionName, FilterDefinition<BsonDocument> filter, SortDefinition<BsonDocument> sort)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            return collection.Find(filter).Sort(sort).ToListAsync();
+        }
+
+        #endregion
+
+        #region 根据条件分页查询（bson文档）
+        /// <summary>
+        /// 根据条件分页查询（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">查询条件</param>
+        /// <param name="pageIndex">页码</param>
+        /// <param name="pageSize">每页大小</param>
+        /// <returns></returns>
+        public Task<List<BsonDocument>> PagingQuery(string collectionName, FilterDefinition<BsonDocument> filter, int pageIndex, int pageSize)
+        {
+            int skip = (pageIndex - 1) * pageSize;
+
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+
+            return collection.Find(filter).Skip(skip).Limit(pageSize).ToListAsync();
+        }
+        #endregion
+
+        #region 根据条件分页，排序查询（bson文档）
+        /// <summary>
+        /// 根据条件分页，排序查询（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">查询条件</param>
+        /// <param name="sort">排序</param>
+        /// <param name="pageIndex">页码</param>
+        /// <param name="pageSize">每页大小</param>
+        /// <param name="isAsc">是否正序</param>
+        /// <returns></returns>
+        public Task<List<BsonDocument>> PagingQueryAndOrder(string collectionName, FilterDefinition<BsonDocument> filter, SortDefinition<BsonDocument> sort, int pageIndex, int pageSize)
+        {
+            int skip = (pageIndex - 1) * pageSize;
+
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+
+            return collection.Find(filter).Sort(sort).Skip(skip).Limit(pageSize).ToListAsync();
+        }
+        #endregion
+
+        #region 查询记录条数（bson文档）
+        /// <summary>
+        /// 查询记录条数（bson文档）
+        /// </summary>
+        /// <param name="collectionName">文档名称</param>
+        /// <param name="filter">查询条件</param>
+        /// <returns></returns>
+        public long GetCount(string collectionName, FilterDefinition<BsonDocument> filter)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+
+            return collection.Count(filter);
+        }
+
+
+        /// <summary>
+        /// 查询记录条数（泛型）
+        /// </summary>
+        /// <typeparam name="T">类型</typeparam>
+        /// <param name="expre">查询条件</param>
+        /// <returns></returns>
+        public long GetCountWithoutBaseEntity<T>(Expression<Func<T, bool>> expre)
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            return collection.Count(expre);
+        }
+        #endregion
+
+
+        /// <summary>
+        /// 查询多条数据（泛型）,数据库中字段必须与实体对应
+        /// </summary>
+        /// <typeparam name="T">泛型</typeparam>
+        /// <param name="collectionName">collection名称</param>
+        /// <param name="filter">查询表达式</param>
+        /// <param name="projection">需要查询的字段，NULL默认查询全部</param>
+        /// <param name="sort">排序表达式</param>
+        /// <param name="pageIndex">页码</param>
+        /// <param name="pageSize">每页大小</param>
+        /// <param name="readCount">总条数</param>
+        /// <param name="usePage">是否分页</param>
+        /// <returns></returns>
+        public Task<List<T>> Read<T>(FilterDefinition<T> filter, ProjectionDefinition<T, T> projection, SortDefinition<T> sort, int? pageIndex, int? pageSize, out int readCount, bool usePage = true) where T : new()
+        {
+            string collectionName = GetCollectionName<T>();
+
+            if (filter == null)
+                filter = Builders<T>.Filter.Empty;
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            if (usePage)
+            {
+                readCount = (int)collection.CountAsync(filter).Result;
+
+                pageIndex = pageIndex ?? 1;
+
+                pageSize = pageSize ?? 10;
+
+                int skip = (pageIndex.Value - 1) * pageSize.Value;
+
+                if (projection == null)
+                {
+                    if (sort == null)
+                        return collection.Find(filter).Skip(skip).Limit(pageSize).ToListAsync();
+                    else
+                        return collection.Find(filter).Sort(sort).Skip(skip).Limit(pageSize).ToListAsync();
+                }
+                else
+                {
+                    if (sort == null)
+                        return collection.Find(filter).Project(projection).Skip(skip).Limit(pageSize).ToListAsync();
+                    else
+                        return collection.Find(filter).Project(projection).Sort(sort).Skip(skip).Limit(pageSize).ToListAsync();
+                }
+            }
+            else
+            {
+                readCount = 0;
+
+                if (sort == null)
+                    return collection.Find(filter).ToListAsync();
+                else
+                    return collection.Find(filter).Sort(sort).ToListAsync();
+            }
+        }
+
+        #endregion
+
+
+        #region MapReduce
+        public List<T> MepReduce<T>(BsonJavaScript map, BsonJavaScript reduce) where T : BaseEntity
+        {
+            string collectionName = GetCollectionName<T>();
+
+            var collection = _database.GetCollection<T>(collectionName);
+
+            return collection.MapReduce<T>(map, reduce).ToList<T>();
+        }
+
+
+        public List<T> MepReduce<T>(BsonJavaScript map, BsonJavaScript reduce, string collectionName)
+        {
+            var collection = _database.GetCollection<T>(collectionName);
+            return collection.MapReduce<T>(map, reduce).ToList<T>();
+        }
+
+
+        public List<TR> MepReduce<TR>(BsonJavaScript map, BsonJavaScript reduce, BsonJavaScript finalize, string collectionName)
+        {
+            var collection = _database.GetCollection<TR>(collectionName);
+            var options = new MapReduceOptions<TR, TR>();
+            options.Finalize = finalize;
+            return collection.MapReduce<TR>(map, reduce, options).ToList<TR>();
+        }
+
+        public List<TR> MepReduce<TR, TD>(BsonJavaScript map, BsonJavaScript reduce, string collectionName, BsonJavaScript finalize = null, FilterDefinition<TD> filter = null)
+        {
+            var collection = _database.GetCollection<TD>(collectionName);
+            var options = new MapReduceOptions<TD, TR>();
+            options.Finalize = finalize;
+            options.Filter = filter;
+            return collection.MapReduce<TR>(map, reduce, options).ToList<TR>();
+        }
+
+        #endregion
+        #region Common
+
+        #region 获取实体类对应的集合名称
+        /// <summary>
+        /// 获取实体类对应的集合名称
+        /// </summary>
+        /// <typeparam name="T">实体类型</typeparam>
+        /// <returns></returns>
+        public static string GetCollectionName<T>()
+        {
+            Type t = typeof(T);
+            return t.Name.ToLower();
+        }
+        #endregion
+
+        #region 对象转BSON文档
+        /// <summary>
+        /// 对象转BSON
+        /// </summary>
+        /// <param name="sourceObj">要转换的对象</param>
+        /// <param name="objTypeName">实体对应的名称</param>
+        /// <returns>bson文档</returns>
+        public static BsonDocument ObjectToBson(object sourceObj, out string objTypeName)
+        {
+            var properties = sourceObj.GetType().GetProperties();
+            objTypeName = sourceObj.GetType().Name.ToLower();
+            if (properties != null && properties.Count() > 0)
+            {
+                BsonDocument bson = new BsonDocument();
+                foreach (var p in properties)
+                {
+                    if (p != null && p.CanWrite)
+                    {
+                        string name = p.Name;
+                        var value = p.GetValue(sourceObj, null);
+                        bson.Add(new BsonElement(name, BsonValue.Create(value)));
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+                return bson;
+            }
+            else
+            {
+                return null;
+            }
+        }
+        #endregion
+
+        #region 对象集合转BSON文档集合
+        /// <summary>
+        /// 对象转BSON
+        /// </summary>
+        /// <param name="sourceList">要转换的对象集合</param>
+        /// <param name="objTypeName">实体对应的名称</param>
+        /// <returns>bson文档</returns>
+        public static List<BsonDocument> ObjectListToBsonList<T>(List<T> sourceList, out string objTypeName)
+        {
+            List<BsonDocument> bsonList = new List<BsonDocument>();
+            if (sourceList != null && sourceList.Count > 0)
+            {
+                objTypeName = sourceList.FirstOrDefault().GetType().Name.ToLower();
+                foreach (var item in sourceList)
+                {
+                    var properties = item.GetType().GetProperties();
+
+                    if (properties != null && properties.Count() > 0)
+                    {
+                        BsonDocument bson = new BsonDocument();
+                        foreach (var p in properties)
+                        {
+                            if (p != null && p.CanWrite)
+                            {
+                                string name = p.Name;
+                                var value = p.GetValue(item, null);
+                                bson.Add(new BsonElement(name, BsonValue.Create(value)));
+                            }
+                            else
+                            {
+                                continue;
+                            }
+                        }
+                        bsonList.Add(bson);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+            }
+            else
+            {
+                objTypeName = string.Empty;
+            }
+            return bsonList;
+        }
+        #endregion
+
+        #region 对象转update对象
+        /// <summary>
+        /// 对象转update对象
+        /// </summary>
+        /// <param name="sourceObj">要转换的对象</param>
+        /// <param name="objTypeName">对象类型</param>
+        /// <param name="objId">objectID</param>
+        /// <returns></returns>
+        public static UpdateDocument ObjectToUpdateBson(object sourceObj, out string objTypeName, out string objId)
+        {
+            var properties = sourceObj.GetType().GetProperties();
+            objTypeName = sourceObj.GetType().Name.ToLower();
+            objId = string.Empty;
+            if (properties != null && properties.Count() > 0)
+            {
+                UpdateDocument bson = new UpdateDocument();
+                foreach (var p in properties)
+                {
+                    if (p != null && p.CanWrite)
+                    {
+                        string name = p.Name;
+                        var value = p.GetValue(sourceObj, null);
+                        if (name == "_id")
+                        {
+                            objId = value.ToString();
+                        }
+                        bson.Add(new BsonElement(name, BsonValue.Create(value)));
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+                return bson;
+            }
+            else
+            {
+                return null;
+            }
+        }
+        #endregion
+
+        #region 对象转update对象
+        /// <summary>
+        /// 对象转update对象
+        /// </summary>
+        /// <param name="sourceObjList">要转换的对象集合</param>
+        /// <param name="objTypeName">对象类型</param>
+        /// <returns></returns>
+        public static List<UpdateDocument> ObjectListToUpdateBsonList<T>(List<T> sourceObjList, out string objTypeName)
+        {
+            List<UpdateDocument> list = new List<UpdateDocument>();
+            if (sourceObjList != null && sourceObjList.Count > 0)
+            {
+                objTypeName = sourceObjList.FirstOrDefault().GetType().Name.ToLower();
+                foreach (var item in sourceObjList)
+                {
+                    var properties = item.GetType().GetProperties();
+
+                    if (properties != null && properties.Count() > 0)
+                    {
+                        UpdateDocument bson = new UpdateDocument();
+                        foreach (var p in properties)
+                        {
+                            if (p != null && p.CanWrite)
+                            {
+                                string name = p.Name;
+                                var value = p.GetValue(item, null);
+                                bson.Add(new BsonElement(name, BsonValue.Create(value)));
+                            }
+                            else
+                            {
+                                continue;
+                            }
+                        }
+                        list.Add(bson);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+            }
+            else
+            {
+                objTypeName = string.Empty;
+            }
+            return list;
+        }
+        #endregion
+
+        #region JSON字符串转Bson文档
+        /// <summary>
+        /// JSON字符串转Bson文档
+        /// </summary>
+        /// <param name="json">要转换的JSON字符串</param>
+        /// <returns>bson文档,失败返回NULL</returns>
+        public static BsonDocument JsonToBson(string json)
+        {
+            try
+            {
+                return BsonDocument.Parse(json);
+            }
+            catch (Exception ex)
+            {
+                return null;
+            }
+        }
+        #endregion
+
+        #endregion
+
+        #region 聚合
+        /// <summary>
+        /// 聚合
+        /// </summary>
+        /// <param name="collectionName">集合名称</param>
+        /// <param name="pipeline">管道信息</param>
+        /// <returns></returns>
+        public List<BsonDocument> Aggregate(string collectionName, PipelineStagePipelineDefinition<BsonDocument, BsonDocument> pipeline)
+        {
+            var collection = _database.GetCollection<BsonDocument>(collectionName);
+            var cursor = collection.Aggregate(pipeline);
+            return cursor.ToList();
+        }
+        #endregion
+    }
+}

ApiLog.Act/Filters/RequestLogAttribute.cs

+using ApiLog.Act.DAL.Mongo;
+using ApiLog.Act.Models.Log;
+using ApiLog.Act.Tools;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http.Controllers;
+using System.Web.Http.Filters;
+
+namespace ApiLog.Act.Filters
+{
+    /// <summary>
+    /// 进入数据日志处理-过滤器
+    /// </summary>
+
+    public class RequestLogAttribute : System.Web.Http.Filters.ActionFilterAttribute
+    {
+        #region 初始化
+
+        /// <summary>
+        /// 接口日志服务
+        /// </summary>
+        private static APILogsMongRepository apiLogDal = new APILogsMongRepository();
+
+        #endregion
+
+        /// <summary>
+        /// 进入处理
+        /// </summary>
+        /// <param name="actionContext"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public override async Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
+        {
+            #region 获取传入的数据
+
+            var jsonData = "";
+
+            try
+            {
+                if (System.Web.HttpContext.Current.Request.ContentType != null && System.Web.HttpContext.Current.Request.ContentType != "")
+                {
+                    var contentType = System.Web.HttpContext.Current.Request.ContentType.ToLower();
+                    if ((contentType.Contains("application/x-www-form-urlencoded")
+                        || contentType.Contains("multipart/form-data"))
+                        && System.Web.HttpContext.Current.Request.ContentLength > 0)
+                    {
+                        var bodyinfo = new Dictionary<string, string>();
+                        foreach (string key in System.Web.HttpContext.Current.Request.Form)
+                        {
+                            bodyinfo.Add(key, System.Web.HttpContext.Current.Request.Form.GetValues(key)[0]);
+                        }
+                        jsonData = Newtonsoft.Json.JsonConvert.SerializeObject(bodyinfo);
+                    }
+                    else if (contentType.Contains("application/json"))
+                    {
+                        if (actionContext.ActionArguments.Count > 1)
+                            jsonData = "[";
+                        foreach (var item in actionContext.ActionArguments)
+                        {
+                            if (actionContext.ActionArguments.Count > 1)
+                                jsonData += Newtonsoft.Json.JsonConvert.SerializeObject(item.Value) + ",";
+                            else
+                                jsonData = Newtonsoft.Json.JsonConvert.SerializeObject(item.Value);
+                            continue;
+                        }
+                        if (actionContext.ActionArguments.Count > 1)
+                            jsonData = jsonData.Substring(0, (jsonData.Length - 1)) + "]";
+
+                    }
+                    if (System.Web.HttpContext.Current.Request.Path.ToLower().IndexOf("ocr_result") > -1)
+                    {
+                        long big = Encoding.Default.GetByteCount(jsonData);
+                        if (big > 40720)
+                            jsonData = "";
+                    }
+                }
+
+                #endregion
+
+                #region 新增接口日志
+
+                //获取全局日志追踪ID
+                var globalLogTraceID = string.Empty;
+                if (System.Web.HttpContext.Current.Request.Headers.GetValues(nameof(APILogConfig.PoJun_GlobalLogTraceID)) != null)
+                    globalLogTraceID = System.Web.HttpContext.Current.Request.Headers.GetValues(nameof(APILogConfig.PoJun_GlobalLogTraceID)).FirstOrDefault();
+
+                //获取全局日志级别
+                int globalLogLevel = 0;
+                if (System.Web.HttpContext.Current.Request.Headers.GetValues(nameof(APILogConfig.PoJun_GlobalLogLevel)) != null)
+                    globalLogLevel = Convert.ToInt32(System.Web.HttpContext.Current.Request.Headers.GetValues(nameof(APILogConfig.PoJun_GlobalLogLevel)).FirstOrDefault());
+                else
+                    globalLogLevel++;
+
+                //获取日志ID
+                var logTraceID = IdHelp.GetGuidBy32();
+                var requestTime = DateTime.Now;
+
+                var logParam = new AddRequestLogParam();
+                logParam.APIName = System.Web.HttpContext.Current.Request.Path;
+                //这里存储的是客户端的IP+端口
+                logParam.ClientHost = $"{System.Web.HttpContext.Current.Request.UserHostAddress}";
+                var result = new Dictionary<string, string>();
+                var headers = System.Web.HttpContext.Current.Request.Headers;
+                foreach (string key in headers.Keys)
+                {
+                    result.Add(key, headers.GetValues(key)[0]);
+                }
+                logParam.Headers = Newtonsoft.Json.JsonConvert.SerializeObject(result);
+                //logParam.Headers = Newtonsoft.Json.JsonConvert.SerializeObject(System.Web.HttpContext.Current.Request.Headers);
+                logParam.Level = globalLogLevel;
+                if (logParam.APIName.ToLower().IndexOf("uploadfile") > -1)  //如果上传文件流就清空
+                    jsonData = "";
+                logParam.RequestBody = jsonData;
+                //这里存储的当前服务器的IP+端口+接口地址+url参数
+                logParam.ServerHost = $"{System.Web.HttpContext.Current.Request.Url.AbsoluteUri}";
+                logParam.SystemID = SysUtil.GetSystemId();
+                logParam.TraceID = logTraceID;
+                //如果全局日志追踪ID为空则使用本次日志追踪ID为全局日志追踪ID
+                logParam.GlobalTraceID = string.IsNullOrEmpty(globalLogTraceID) ? logTraceID : globalLogTraceID;
+                logParam.ParentTraceID = globalLogTraceID;
+                logParam.RequestTime = requestTime;
+
+                //新增日志
+                await apiLogDal.AddRequestLogAsync(logParam);
+
+                if (KafkaConfig.GetInstance().IsEnable)
+                {
+                    ////开启异步新线程把日志信息推送到kafka
+                    //Task task = new Task(async () =>
+                    //{
+                    //    var kafkaLog = new KafkaLog();
+                    //    kafkaLog.Body = Newtonsoft.Json.JsonConvert.SerializeObject(logParam);
+                    //    kafkaLog.Type = 1;
+                    //    await kafkaProducer.SendAsync(KafkaConfig.GetInstance().BrokerUrl, KafkaConfig.GetInstance().Topic, Newtonsoft.Json.JsonConvert.SerializeObject(kafkaLog));
+                    //});
+                    //task.Start();//执行
+                }
+
+                #endregion
+
+                #region 向后传输数据
+
+                //把日志ID写入
+                System.Web.HttpContext.Current.Request.Headers.Add(nameof(APILogConfig.PoJun_LogTraceID), logTraceID);
+                //把接口请求时间写入
+                System.Web.HttpContext.Current.Request.Headers.Add(nameof(APILogConfig.RequestTime), requestTime.ToString("yyyy-MM-dd HH:mm:ss.fff"));
+                //把全局日志级别写入
+                System.Web.HttpContext.Current.Request.Headers.Remove(nameof(APILogConfig.PoJun_GlobalLogLevel));
+                System.Web.HttpContext.Current.Request.Headers.Add(nameof(APILogConfig.PoJun_GlobalLogLevel), globalLogLevel.ToString());
+                //如果全局日志追踪ID为空则使用本次日志追踪ID为全局日志追踪ID
+                if (string.IsNullOrEmpty(globalLogTraceID))
+                {
+                    System.Web.HttpContext.Current.Request.Headers.Add(nameof(APILogConfig.PoJun_GlobalLogTraceID), logTraceID);
+                }
+
+                #endregion
+
+                await base.OnActionExecutingAsync(actionContext, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                jsonData = $"参数获取失败报错！StackTrace:{ex.StackTrace} | Message:{ex.Message} | Source:{ex.Source}";
+            }
+        }
+    }
+}

ApiLog.Act/Filters/ResponseLogAttribute.cs

+using ApiLog.Act.DAL.Mongo;
+using ApiLog.Act.Models.Log;
+using ApiLog.Act.Tools;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http.Filters;
+
+namespace ApiLog.Act.Filters
+{
+    /// <summary>
+    /// 返回数据日志处理
+    /// </summary>
+    public class ResponseLogAttribute : System.Web.Http.Filters.ActionFilterAttribute
+    {
+        #region 初始化
+
+        /// <summary>
+        /// 接口日志服务
+        /// </summary>
+        private static APILogsMongRepository apiLogDal = new APILogsMongRepository();
+
+
+
+        #endregion
+
+        /// <summary>
+        /// 新增返回日志
+        /// </summary>
+        /// <param name="actionExecutedContext"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public override async Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
+        {
+            #region 新增接口返回日志
+
+            var logTraceID = System.Web.HttpContext.Current.Request.Headers.Get(nameof(APILogConfig.PoJun_LogTraceID));
+            if (logTraceID != null)
+            {
+                var _requestTime = Convert.ToDateTime(System.Web.HttpContext.Current.Request.Headers.Get(nameof(APILogConfig.RequestTime)));
+                var logParam = new AddResponseLogParam();
+                logParam.IsError = false;
+
+                if (actionExecutedContext.Response != null && System.Web.HttpContext.Current.Request.Path.ToLower().IndexOf("upload/showfile") <0)
+                {
+                    try
+                    {
+                        logParam.ResponseBody = await actionExecutedContext.Response.Content.ReadAsStringAsync();
+                    }
+                    catch (Exception ex)
+                    {
+                        logParam.ResponseBody = $"参数获取失败报错！StackTrace:{ex.StackTrace} | Message:{ex.Message} | Source:{ex.Source}";
+                    }
+                }
+                else
+                {
+                    if (actionExecutedContext.Exception != null)
+                    {
+                        logParam.ErrorBody = $"StackTrace:{actionExecutedContext.Exception.StackTrace} | Message:{actionExecutedContext.Exception.Message} | Source:{actionExecutedContext.Exception.Source}";
+                        logParam.IsError = true;
+                    }
+                }
+
+                var _globalTraceID = System.Web.HttpContext.Current.Request.Headers.Get(nameof(APILogConfig.PoJun_GlobalLogTraceID));
+                logParam.GlobalTraceID = _globalTraceID;
+                logParam.ParentTraceID = logTraceID.ToString();
+                logParam.ResponseTime = DateTime.Now;
+                logParam.TimeCost = Convert.ToInt32((logParam.ResponseTime - Convert.ToDateTime(_requestTime)).TotalMilliseconds);
+                await Task.Run(() =>
+                {
+                    apiLogDal.AddResponseLog(logParam);
+                });
+            }
+
+            #endregion
+
+            await base.OnActionExecutedAsync(actionExecutedContext, cancellationToken);
+        }
+    }
+}

ApiLog.Act/Models/LogModel/Entity/BaseEntity.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson;
+
+namespace ApiLog.Act.Models.Log.Entity
+{
+    /// <summary>
+    /// 基类
+    /// </summary>
+    public class BaseEntity
+    {
+        /// <summary>
+        /// mongoDB 主键
+        /// </summary>
+        [BsonId]
+        public string _id { get; set; }
+
+        /// <summary>
+        /// 创建人
+        /// </summary>
+        public string CreateUser { get; set; }
+        /// <summary>
+        /// 创建时间
+        /// </summary>
+        [BsonDateTimeOptions(Kind = DateTimeKind.Local, Representation = BsonType.DateTime)]
+        public DateTime CreateTime { get; set; }
+
+        /// <summary>
+        /// 是否删除
+        /// </summary>
+        public bool IsDeleted { get; set; }
+
+        /// <summary>
+        /// 时间戳
+        /// </summary>
+        public long Timestamp { get; set; }
+    }
+}

ApiLog.Act/Models/LogModel/Entity/KafkaLog.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ApiLog.Act.Models.Log
+{
+    /// <summary>
+    /// Kafka日志
+    /// </summary>
+    public class KafkaLog
+    {
+        /// <summary>
+        /// kafka日志内容 1:代表请求 2：代表返回结果
+        /// </summary>
+        public int Type { get; set; }
+
+        /// <summary>
+        /// 日志内容
+        /// </summary>
+        public string Body { get; set; }
+    }
+}

ApiLog.Act/Models/LogModel/Model/AddRequestLogModel.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ApiLog.Act.Models.Log
+{
+    /// <summary>
+    /// 【新增请求日志】返回结果
+    /// </summary>
+    public class AddRequestLogModel
+    {
+        /// <summary>
+        /// 追踪ID【请求进入时生成的日志ID】
+        /// </summary>
+        public string TraceID { get; set; }
+
+        /// <summary>
+        /// 请求时间
+        /// </summary>
+        public DateTime RequestTime { get; set; }
+    }
+}

ApiLog.Act/Models/LogModel/Param/AddRequestLogParam.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ApiLog.Act.Models.Log
+{
+    /// <summary>
+    /// 【新增请求日志】参数
+    /// </summary>
+    public class AddRequestLogParam
+    {
+        /// <summary>
+        /// 追踪ID【请求进入时生成的日志ID】[自动设置不需要赋值]
+        /// </summary>
+        public string TraceID { get; set; }
+
+        /// <summary>
+        /// 全局唯一追踪ID[自动设置不需要赋值]
+        /// </summary>
+        public string GlobalTraceID { get; set; }
+
+        /// <summary>
+        /// 父追踪ID[自动设置不需要赋值]
+        /// </summary>
+        public string ParentTraceID { get; set; }
+
+        /// <summary>
+        /// 系统ID[自动设置不需要赋值]
+        /// </summary>
+        public string SystemID { get; set; }
+
+        /// <summary>
+        /// 接口名称
+        /// </summary>
+        public string APIName { get; set; }
+
+        /// <summary>
+        /// 客户端的域名或IP[自动设置不需要赋值]
+        /// </summary>
+        public string ClientHost { get; set; }
+
+        /// <summary>
+        /// 服务器的域名或IP
+        /// </summary>
+        public string ServerHost { get; set; }
+
+        /// <summary>
+        /// 等级ID（从1开始）[自动设置不需要赋值]
+        /// </summary>
+        public int Level { get; set; }
+
+        /// <summary>
+        /// 请求内容
+        /// </summary>
+        public string RequestBody { get; set; }
+
+        /// <summary>
+        /// 请求时间
+        /// </summary>
+        public DateTime RequestTime { get; set; }
+
+        /// <summary>
+        /// 请求头
+        /// </summary>
+        public string Headers { get; set; }
+    }
+}

ApiLog.Act/Models/LogModel/Param/AddResponseLogParam.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ApiLog.Act.Models.Log
+{
+    /// <summary>
+    /// 【新增响应日志】参数
+    /// </summary>
+    public class AddResponseLogParam
+    {
+        /// <summary>
+        /// 全局唯一追踪ID[自动设置不需要赋值]
+        /// </summary>
+        public string GlobalTraceID { get; set; }
+
+        /// <summary>
+        /// 父追踪ID[自动设置不需要赋值]
+        /// </summary>
+        public string ParentTraceID { get; set; }
+
+        /// <summary>
+        /// 响应时间
+        /// </summary>
+        public DateTime ResponseTime { get; set; }
+
+        /// <summary>
+        /// 响应内容
+        /// </summary>
+        public string ResponseBody { get; set; }
+
+        /// <summary>
+        /// 错误内容
+        /// </summary>
+        public string ErrorBody { get; set; }
+
+        /// <summary>
+        /// 请求耗时（毫秒）
+        /// </summary>
+        public int TimeCost { get; set; }
+
+        /// <summary>
+        /// 是否为报错日志
+        /// </summary>
+        public bool IsError { get; set; } = false;
+    }
+}

ApiLog.Act/Models/Mongo/APIWebLogs.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ApiLog.Act.Models.Mongo
+{
+    public class APIWebLogs:PushAPILogs
+    {
+    }
+
+    public class SearchAPIWebLogs : PushAPILogs
+    {
+        /// <summary>
+        /// 查询开始时间
+        /// </summary>
+        public DateTime BeginDate { get; set; }
+
+        /// <summary>
+        /// 查询结束时间
+        /// </summary>
+        public DateTime EndDate { get; set; }
+
+        /// <summary>
+        /// 页数
+        /// </summary>
+        public int pageIndex { get; set; } = 1;
+
+        /// <summary>
+        /// 每页数量
+        /// </summary>
+        public int PageSize { get; set; }
+
+
+    }
+
+
+    public class SearchLogsPaggingAsyncOutput
+    {
+        public int Count { get; set; }
+
+        public List<APIWebLogs> aPIWebLogs { get; set; }
+    }
+
+}

ApiLog.Act/Models/Mongo/PushAPILogs.cs

+using MongoDB.Bson.Serialization.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ApiLog.Act.Models.Mongo
+{
+    /// <summary>
+    /// 接口日志
+    /// </summary>
+    [BsonIgnoreExtraElements]
+    public class PushAPILogs
+    {
+        #region 初始化
+
+        /// <summary>
+        /// 父追踪ID（简写）
+        /// </summary>
+        public const string PTID = "PTID";
+
+        #endregion
+
+        /// <summary>
+        /// 日志追踪ID
+        /// </summary>
+        [BsonId]
+        public string ID { get; set; }
+
+        /// <summary>
+        /// 全局唯一追踪ID
+        /// </summary>
+        public string GlobalTraceID { get; set; }
+
+        /// <summary>
+        /// 父追踪ID
+        /// </summary>
+        [BsonElement(PushAPILogs.PTID)]
+        public string ParentTraceID { get; set; }
+
+        /// <summary>
+        /// 系统ID
+        /// </summary>
+        public string SystemID { get; set; }
+
+        /// <summary>
+        /// 接口名称
+        /// </summary>
+        public string APIName { get; set; }
+
+        /// <summary>
+        /// 客户端的域名或IP
+        /// </summary>
+        public string ClientHost { get; set; }
+
+        /// <summary>
+        /// 服务器的域名或IP
+        /// </summary>
+        public string ServerHost { get; set; }
+
+        /// <summary>
+        /// 等级ID（从1开始）
+        /// </summary>
+        public int Level { get; set; }
+
+        /// <summary>
+        /// 请求时间
+        /// </summary>
+        [BsonDateTimeOptions(Kind = DateTimeKind.Local)]
+        public DateTime RequestTime { get; set; }
+
+        /// <summary>
+        /// [响应/错误]时间
+        /// </summary>
+        [BsonDateTimeOptions(Kind = DateTimeKind.Local)]
+        public DateTime ResponseTime { get; set; }
+
+        /// <summary>
+        /// 请求耗时（毫秒）
+        /// </summary>
+        public int TimeCost { get; set; }
+
+        /// <summary>
+        /// 请求内容
+        /// </summary>
+        public string RequestBody { get; set; }
+
+        /// <summary>
+        /// 响应内容
+        /// </summary>
+        public string ResponseBody { get; set; }
+
+        /// <summary>
+        /// 错误内容
+        /// </summary>
+        public string ErrorBody { get; set; }
+
+        /// <summary>
+        /// 请求头
+        /// </summary>
+        public string Headers { get; set; }
+
+        /// <summary>
+        /// 是否为报错日志
+        /// </summary>
+        public bool IsError { get; set; } = false;
+    }
+}

ApiLog.Act/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("ApiLog.Act")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ApiLog.Act")]
+[assembly: AssemblyCopyright("Copyright ©  2022")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("42144d88-4a3c-407a-9cac-70907e482821")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

ApiLog.Act/Tools/APILogConfig.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ApiLog.Act.Tools
+{
+    /// <summary>
+    /// 接口日志配置
+    /// </summary>
+    public class APILogConfig
+    {
+        /// <summary>
+        /// 传入数据
+        /// </summary>
+        public static readonly string PoJun_JsonData = string.Empty;
+
+        /// <summary>
+        /// 日志追踪ID(第一次新增日志的主键ID)【单系统专用】
+        /// </summary>
+        public static readonly string PoJun_LogTraceID = string.Empty;
+
+        /// <summary>
+        /// 全局日志追踪ID（日志调用链专用）
+        /// </summary>
+        public static readonly string PoJun_GlobalLogTraceID = string.Empty;
+
+        /// <summary>
+        /// 全局日志级别
+        /// </summary>
+        public static readonly string PoJun_GlobalLogLevel = string.Empty;
+
+        /// <summary>
+        /// 接口请求时间
+        /// </summary>
+        public static readonly string RequestTime = string.Empty;
+    }
+}

ApiLog.Act/Tools/IdHelp.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ApiLog.Act.Tools
+{
+    public class IdHelp
+    {
+        public static string GetGuidBy32()
+        {
+            return Guid.NewGuid().ToString().Replace("-", "");
+        }
+    }
+}

ApiLog.Act/Tools/KafkaConfig.cs

+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Text;
+
+namespace ApiLog.Act.Tools
+{
+    /// <summary>
+    /// kafka配置信息
+    /// </summary>
+    public class KafkaConfig
+    {
+        #region 初始化
+
+        /// <summary>
+        /// 初始化
+        /// </summary>
+        /// <returns></returns>
+        public static KafkaConfig GetInstance()
+        {
+            KafkaConfig kafkaConfig = new KafkaConfig();
+            kafkaConfig.IsEnable = false;
+            return kafkaConfig;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// 是否启用kafka
+        /// </summary>
+        public bool IsEnable { get; set; }
+
+        /// <summary>
+        /// kafka后台IP+端口
+        /// </summary>
+        public string BrokerUrl { get; set; }
+
+        /// <summary>
+        /// topic Name
+        /// </summary>
+        public string Topic { get; set; }
+
+        /// <summary>
+        /// group Id
+        /// </summary>
+        public string GroupId { get; set; }
+    }
+}

ApiLog.Act/Tools/SysUtil.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Configuration;
+
+namespace ApiLog.Act.Tools
+{
+    /// <summary>
+    /// 系统帮助类
+    /// </summary>
+    public static class SysUtil
+    {
+        #region 日志追踪ID(第一次新增日志的主键ID)【单系统专用】
+
+        /// <summary>
+        /// 日志追踪ID(第一次新增日志的主键ID)【单系统专用】
+        /// </summary>
+        /// <returns></returns>
+        public static string GetTraceId()
+        {
+            if (System.Web.HttpContext.Current == null || System.Web.HttpContext.Current.Request == null || System.Web.HttpContext.Current.Request.Headers == null)
+                return null;
+            return System.Web.HttpContext.Current.Request.Headers.Get(nameof(APILogConfig.PoJun_LogTraceID));
+        }
+
+        #endregion
+
+        #region 全局日志追踪ID（日志调用链专用）
+
+        /// <summary>
+        /// 全局日志追踪ID（日志调用链专用）
+        /// </summary>
+        /// <returns></returns>
+        public static string GlobalTraceId()
+        {
+            if (System.Web.HttpContext.Current == null || System.Web.HttpContext.Current.Request == null || System.Web.HttpContext.Current.Request.Headers == null)
+                return null;
+            return System.Web.HttpContext.Current.Request.Headers.Get(nameof(APILogConfig.PoJun_GlobalLogTraceID));
+        }
+
+        #endregion
+
+        #region 获取系统ID
+
+        /// <summary>
+        /// 获取系统ID
+        /// </summary>
+        /// <returns></returns>
+        public static string GetSystemId()
+        {
+            var sysId = ConfigurationManager.AppSettings["SystemID"];
+            if (sysId == null)
+                return "";
+            else
+                return sysId.ToString();
+        }
+
+        #endregion
+    }
+}

ApiLog.Act/app.config

+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
\ No newline at end of file

ApiLog.Act/packages.config

+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="mongocsharpdriver" version="2.2.4" targetFramework="net45" />
+  <package id="MongoDB.Bson" version="2.2.4" targetFramework="net45" />
+  <package id="MongoDB.Driver" version="2.2.4" targetFramework="net45" />
+  <package id="MongoDB.Driver.Core" version="2.2.4" targetFramework="net45" />
+</packages>
\ No newline at end of file

DapperORM/ORMExtention/ProviderFactory.cs

@@ -55,9 +55,16 @@ namespace DapperORM.ORMExtention
         {
             //如果还没有加载，则加载该DbProviderFactory
             if (!_ProviderFactoies.ContainsKey(providerType))
+            {
+                try
                 {
                     _ProviderFactoies.Add(providerType, ImportDbProviderFactory(providerType));
                 }
+                catch (Exception ex)
+                {
+                    return _ProviderFactoies[providerType];
+                }
+            }
             return _ProviderFactoies[providerType];
         }
 

PushPf.Api/App_Start/WebApiConfig.cs

@@ -34,6 +34,9 @@ namespace PushPf.Api
             {
                 DateTimeFormat = "yyyy-MM-dd HH:mm:ss"
             });
+
+            config.Filters.Add(new ApiLog.Act.Filters.RequestLogAttribute());
+            config.Filters.Add(new ApiLog.Act.Filters.ResponseLogAttribute());
         }
     }
 }

PushPf.Api/PushPf.Api.csproj

@@ -17,7 +17,7 @@
     <AssemblyName>PushPf.Api</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <MvcBuildViews>false</MvcBuildViews>
-    <UseIISExpress>true</UseIISExpress>
+    <UseIISExpress>false</UseIISExpress>
     <IISExpressSSLPort />
     <IISExpressAnonymousAuthentication />
     <IISExpressWindowsAuthentication />
@@ -201,6 +201,10 @@
     <Content Include="Scripts\_references.js" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\ApiLog.Act\ApiLog.Act.csproj">
+      <Project>{42144d88-4a3c-407a-9cac-70907e482821}</Project>
+      <Name>ApiLog.Act</Name>
+    </ProjectReference>
     <ProjectReference Include="..\PushApi.Act\PushApi.Act.csproj">
       <Project>{474D1182-7D75-466E-8574-137491176F7F}</Project>
       <Name>PushApi.Act</Name>
@@ -233,7 +237,7 @@
           <AutoAssignPort>True</AutoAssignPort>
           <DevelopmentServerPort>61158</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:61158/</IISUrl>
+          <IISUrl>http://localhost/PushPf.Api</IISUrl>
           <NTLMAuthentication>False</NTLMAuthentication>
           <UseCustomServer>False</UseCustomServer>
           <CustomServerUrl>

PushPf.Api/Web.config

@@ -5,9 +5,10 @@
   -->
 <configuration>
   <connectionStrings>
-    <add name="WriteConnStr" connectionString="Server=192.168.0.39;Database=db_ashermed_push;Uid=root;Pwd=root;" />
-    <add name="ReadConnStr" connectionString="Server=192.168.0.39;Database=db_ashermed_push;Uid=root;Pwd=root;" />
-
+	  <add name="WriteConnStr" connectionString="Server=192.168.0.49;Database=db_ashermed_push;Uid=user;Pwd=Asher1234;"/>
+	  <add name="ReadConnStr" connectionString="Server=192.168.0.49;Database=db_ashermed_push;Uid=user;Pwd=Asher1234;"/>
+	  <add name="PushPlatformContext" connectionString="Server=192.168.0.49;Database=db_ashermed_push;Uid=user;Pwd=Asher1234;"/>
+	  <add name="mongo_edc_log" connectionString="mongodb://iis_Trialdem:WezpeW1ajDvBGnz@101.132.228.78:3717/ASHermed_91Trialdem_Logs?slaveOk=true" />
     <!--<add name="WriteConnStr" connectionString="Server=101.132.234.102;Database=db_ashermed_push;Uid=iis;Pwd=iis;"/>
     <add name="ReadConnStr" connectionString="Server=101.132.234.102;Database=db_ashermed_push;Uid=iis;Pwd=iis;"/>-->
   </connectionStrings>
@@ -24,6 +25,9 @@
     <add key="webpages:Enabled" value="false" />
     <add key="ClientValidationEnabled" value="true" />
     <add key="UnobtrusiveJavaScriptEnabled" value="true" />
+
+	  <add key="WechatTokenUrl" value="https://tools.ashermed.com/Wechat/Token/"/>
+	  <add key="IsProd" value="0"/>
   </appSettings>
   <system.web>
     <compilation debug="true" targetFramework="4.5" />

PushPlatform.Background.sln

 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31910.168
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PushPlatform.Background", "PushPlatform.Background\PushPlatform.Background.csproj", "{CA9CD20B-A754-466E-B93B-31CD259FD997}"
 EndProject
@@ -41,6 +41,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PushApi.Act", "PushApi.Act\
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PushTask.exe", "PushTask.exe\PushTask.exe.csproj", "{42E56BCA-D4E4-4EFC-AA7C-4A536EDD35FB}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ApiLog.Act", "ApiLog.Act\ApiLog.Act.csproj", "{42144D88-4A3C-407A-9CAC-70907E482821}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -107,6 +109,10 @@ Global
 		{42E56BCA-D4E4-4EFC-AA7C-4A536EDD35FB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{42E56BCA-D4E4-4EFC-AA7C-4A536EDD35FB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{42E56BCA-D4E4-4EFC-AA7C-4A536EDD35FB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{42144D88-4A3C-407A-9CAC-70907E482821}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{42144D88-4A3C-407A-9CAC-70907E482821}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{42144D88-4A3C-407A-9CAC-70907E482821}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{42144D88-4A3C-407A-9CAC-70907E482821}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -116,5 +122,9 @@ Global
 		{0B25D618-2334-4810-99F2-6F75345C7A14} = {9C71C7FD-12AB-408D-B4A3-077C22E60D72}
 		{4D340BC0-0D02-4738-AEEE-F31EDF4F604D} = {9C71C7FD-12AB-408D-B4A3-077C22E60D72}
 		{474D1182-7D75-466E-8574-137491176F7F} = {9C71C7FD-12AB-408D-B4A3-077C22E60D72}
+		{42144D88-4A3C-407A-9CAC-70907E482821} = {9C71C7FD-12AB-408D-B4A3-077C22E60D72}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {98D5ACDD-11D6-43EC-AF25-B7EE06CC5BDD}
 	EndGlobalSection
 EndGlobal