[SqlInjectionFilter]    [Authorize]    public class DataController : ApiController    {        [AllowAnonymous]        [HttpPost]        public ApiResultInfo Login([FromBody]string[] loginInfo)        {            ApiResultInfo loginResult = null;            try            {                if (loginInfo == null || loginInfo.Length != 4)                {                    throw new Exception("���������������������");                }                using (var da = BaseUtil.CreateDataAccess())                {                    if (������������������������������)                    {                        throw new Exception("���������������������������");                    }                    else                    {                        string token = Guid.NewGuid().ToString("N");                        HttpRuntime.Cache.Insert(Constants.CacheKey_SessionTokenPrefix + token, loginInfo[0], null, Cache.NoAbsoluteExpiration, TimeSpan.FromHours(1));                                            //������������������������������������                        loginResult = ApiResultInfo.BuildOKResult(token);                    }                }            }            catch (Exception ex)            {                LogUitl.Error(ex, "Api.Data.Login", BaseUtil.SerializeToJson(loginInfo));                loginResult = ApiResultInfo.BuildErrResult("LoginErr", ex.Message);            }            return loginResult;        }        [HttpPost]        public ApiResultInfo LogOut([FromBody] string token)        {            try            {                if (!string.IsNullOrEmpty(token))                {                    if (HttpRuntime.Cache[Constants.CacheKey_SessionTokenPrefix + token] != null)                    {                        HttpRuntime.Cache.Remove(token);                    }                    using (var da = BaseUtil.CreateDataAccess())                    {                        //������������������������������                    }                }            }            catch            { }            return ApiResultInfo.BuildOKResult();        }        [HttpPost]        public ApiResultInfo GetValue([FromBody]SqlCmdInfo sqlCmd)        {            using (var da = BaseUtil.CreateDataAccess())            {                var result = da.ExecuteScalar
    
     (sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());                return ApiResultInfo.BuildOKResult(result);            }        }        [Compression]        [HttpPost]        public ApiResultInfo GetDataSet([FromBody]SqlCmdInfo sqlCmd)        {            using (var da = BaseUtil.CreateDataAccess())            {                var ds = da.ExecuteDataSet(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());                return ApiResultInfo.BuildOKResult(ds);            }        }        [Compression]        [HttpPost]        public ApiResultInfo GetDataTable([FromBody]SqlCmdInfo sqlCmd)        {            using (var da = BaseUtil.CreateDataAccess())            {                var table = da.ExecuteDataTable(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());                return ApiResultInfo.BuildOKResult(table);            }        }        [HttpPost]        public ApiResultInfo ExecuteCommand([FromBody]SqlCmdInfo sqlCmd)        {            using (var da = BaseUtil.CreateDataAccess())            {                int result = da.ExecuteCommand(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());                return ApiResultInfo.BuildOKResult(result);            }        }        [HttpPost]        public ApiResultInfo BatchExecuteCommand([FromBody] IEnumerable
     
       sqlCmds)        {            using (var da = BaseUtil.CreateDataAccess())            {                int execCount = 0;                da.UseTransaction();                foreach (var sqlCmd in sqlCmds)                {                    execCount += da.ExecuteCommand(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());                }                da.Commit();                return new ApiResultInfo(execCount > 0);            }        }        [HttpPost]        public async Task
      
        ExecuteCommandAsync([FromBody]SqlCmdInfo sqlCmd)        {            return await Task.Factory.StartNew((arg) =>             {                 var sqlCmdObj = arg as SqlCmdInfo;                 string connName = BaseUtil.GetDbConnectionName(sqlCmdObj.DbType);                 using (var da = BaseUtil.CreateDataAccess(connName))                 {                     try                     {                         int result = da.ExecuteCommand(sqlCmdObj.SqlCmdText, sqlCmdObj.GetCommandType(), sqlCmdObj.Parameters.TryToArray());                         return ApiResultInfo.BuildOKResult(result);                     }                     catch (Exception ex)                     {                         LogUitl.Error(ex, "Api.Data.ExecuteCommandAsync", BaseUtil.SerializeToJson(sqlCmdObj));                         return ApiResultInfo.BuildErrResult("ExecuteCommandAsyncErr", ex.Message,                                new Dictionary
       
         { { "StackTrace", ex.StackTrace } });                     }                 }             }, sqlCmd);        }        [HttpPost]        public IHttpActionResult SaveLog([FromBody]string[] logInfo)        {            if (logInfo == null || logInfo.Length < 3)            {                return Ok();            }            string[] saveLogInfo = new string[7];            for (int i = 1; i < logInfo.Length; i++)            {                if (saveLogInfo.Length > i + 1)                {                    saveLogInfo[i] = logInfo[i];                }            }            switch (saveLogInfo[0].ToUpperInvariant())            {                case "ERR":                    {                        LogUitl.Error(saveLogInfo[1], saveLogInfo[2], saveLogInfo[3], saveLogInfo[4], saveLogInfo[5], saveLogInfo[6]);                        break;                    }                case "WARN":                    {                        LogUitl.Warn(saveLogInfo[1], saveLogInfo[2], saveLogInfo[3], saveLogInfo[4], saveLogInfo[5], saveLogInfo[6]);                        break;                    }                case "INFO":                    {                        LogUitl.Info(saveLogInfo[1], saveLogInfo[2], saveLogInfo[3], saveLogInfo[4], saveLogInfo[5], saveLogInfo[6]);                        break;                    }            }            return Ok();        }    }
       
      
     
    

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]    public class SqlInjectionFilterAttribute : ActionFilterAttribute    {        public override void OnActionExecuting(System.Web.Http.Controllers.HttpActionContext actionContext)        {            if (actionContext.ActionArguments.ContainsKey("sqlCmd"))            {                var sqlCmd = actionContext.ActionArguments["sqlCmd"] as SqlCmdInfo;                if (BaseUtil.IsIncludeDangerSql(sqlCmd.SqlCmdText))                {                    throw new Exception("������SQL������������������������������");                }            }            base.OnActionExecuting(actionContext);        }    }

/// 
        /// ���������������������������SQL���������        /// 
        ///         /// 
    
     ������������true���������false
            public static bool IsIncludeDangerSql(string sqlCmdText)        {            if (string.IsNullOrWhiteSpace(sqlCmdText)) return false;            sqlCmdText = sqlCmdText.Replace("[", " ").Replace("]", " ");            //string dangerSqlObjs = @"sys\.columns|sys\.tables|sys\.views|sys\.objects|sys\.procedures|sys\.indexes|INFORMATION_SCHEMA\.TABLES|INFORMATION_SCHEMA\.VIEWS|INFORMATION_SCHEMA\.COLUMNS|GRANT|DENY|SP_HELP|SP_HELPTEXT";            //dangerSqlObjs += @"|object_id|syscolumns|sysobjects|sysindexes|drop\s+\w+|alter\s+\w+|create\s+\w+";            string dangerSqlObjs = @"sys\.\w+|INFORMATION_SCHEMA\.\w+|GRANT|DENY|SP_HELP|SP_HELPTEXT|sp_executesql";            dangerSqlObjs += @"|object_id|syscolumns|sysobjects|sysindexes|exec\s+\(.+\)|(create|drop|alter)\s+(database|table|index|procedure|view|trigger)\s+\w+(?!#)";            string patternStr = string.Format(@"(^|\s|,|\.)({0})(\s|,|\(|;|$)", dangerSqlObjs);            bool mathed = Regex.IsMatch(sqlCmdText, patternStr, RegexOptions.IgnoreCase);            if (mathed)            {                //TODO:������������������������������������������������                LogUitl.Warn("������������������������SQL������������������" + sqlCmdText, "IsIncludeDangerSql");            }            return mathed;        }

[Serializable]    public class SqlCmdInfo    {        public string SqlCmdText { get; set; }        public ArrayList Parameters { get; set; }        public bool IsSPCmdType { get; set; }        public int DbType { get; set; }        public CommandType GetCommandType()        {            return IsSPCmdType ? CommandType.StoredProcedure : CommandType.Text;        }    }

/// 
    /// ������������������    /// 
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]    public class CompressionAttribute : ActionFilterAttribute    {        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)        {            var content = actionExecutedContext.Response.Content;            #region ���������������������������������������            ////var acceptEncoding = actionExecutedContext.Request.Headers.AcceptEncoding.            ////    Where(x => x.Value == "gzip" || x.Value == "deflate").ToList();            ////if (acceptEncoding.HasItem() && content != null && actionExecutedContext.Request.Method != HttpMethod.Options)            ////{            ////    var first = acceptEncoding.FirstOrDefault();            ////    if (first != null)            ////    {            ////        var bytes = content.ReadAsByteArrayAsync().Result;            ////        switch (first.Value)            ////        {            ////            case "gzip":            ////                actionExecutedContext.Response.Content = new ByteArrayContent(CompressionHelper.GZipBytes(bytes));            ////                actionExecutedContext.Response.Content.Headers.Add("Content-Encoding", "gzip");            ////                break;            ////            case "deflate":            ////                actionExecutedContext.Response.Content = new ByteArrayContent(CompressionHelper.DeflateBytes(bytes));            ////                actionExecutedContext.Response.Content.Headers.Add("Content-encoding", "deflate");            ////                break;            ////        }            ////    }            ////}            #endregion            //���������������CompressionAttribute������������������GZIP������            var bytes = content.ReadAsByteArrayAsync().Result;            actionExecutedContext.Response.Content = new ByteArrayContent(CompressionHelper.GZipBytes(bytes));            actionExecutedContext.Response.Content.Headers.Add("Content-Encoding", "gzip");            base.OnActionExecuted(actionExecutedContext);        }    }    /// 
    /// ���������������    /// 
    internal static class CompressionHelper    {        public static byte[] DeflateBytes(byte[] bytes)        {            if (bytes == null || bytes.Length == 0)            {                return null;            }            using (var output = new MemoryStream())            {                using (var compressor = new DeflateStream(output, CompressionMode.Compress, false))                {                    compressor.Write(bytes, 0, bytes.Length);                }                return output.ToArray();            }        }        public static byte[] GZipBytes(byte[] bytes)        {            if (bytes == null || bytes.Length == 0)            {                return null;            }            using (var output = new MemoryStream())            {                using (var compressor = new GZipStream(output, CompressionMode.Compress, false))                {                    compressor.Write(bytes, 0, bytes.Length);                }                return output.ToArray();            }        }    }

public class RequestAuthenticationHandler : DelegatingHandler    {        private const string rsaPrivateKey = "���������������";        protected async override System.Threading.Tasks.Task
    
      SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)        {            try            {                //������TOKEN                HttpRequestHeaders headers = request.Headers;                IEnumerable
     
       tokenHeaders = null;                if (headers.TryGetValues("AccessToken", out tokenHeaders) && tokenHeaders.Any())                {                    string loginID = TokenVerification(tokenHeaders.ElementAt(0));                    if (!string.IsNullOrEmpty(loginID))                    {                        var principal = new GenericPrincipal(new GenericIdentity(loginID, "token"), null);                        Thread.CurrentPrincipal = principal;                        if (HttpContext.Current != null)                        {                            HttpContext.Current.User = principal;                        }                    }                }                IEnumerable
      
        encryptHeaders=null;                if (headers.TryGetValues("Encryption", out encryptHeaders) && encryptHeaders.Any())                {                    if (encryptHeaders.ElementAt(0) == "1")                    {                        //���������������������������                        var originContent = request.Content;                        string requestData = await request.Content.ReadAsStringAsync();                        string deContentStr = EncryptUtility.RSADecrypt(rsaPrivateKey, requestData);                        request.Content = new StringContent(deContentStr);                        request.Content.Headers.Clear();                        foreach (var header in originContent.Headers)                        {                            request.Content.Headers.Add(header.Key, header.Value);                        }                    }                }            }            catch (Exception ex)            {                LogUitl.Error(ex, "Api.RequestAuthenticationHandler");            }            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);            return response;        }        private string TokenVerification(string token)        {            if (string.IsNullOrEmpty(token))            {                return null;            }            string loginID = null;            if (HttpRuntime.Cache[Constants.CacheKey_SessionTokenPrefix + token] == null) //���������������������������DB���������������������            {                using (var da = BaseUtil.CreateDataAccess())                {                    //loginID = ������Token������������������ID������                    if (!string.IsNullOrEmpty(loginID))                    {                        HttpRuntime.Cache.Insert(Constants.CacheKey_SessionTokenPrefix + token, loginID, null, Cache.NoAbsoluteExpiration, TimeSpan.FromHours(1));                    }                }            }            else            {                loginID = HttpRuntime.Cache[Constants.CacheKey_SessionTokenPrefix + token].ToNotNullString();            }            return loginID;        }    }
      
     
    

/// 
    /// ������������������������������    /// 
    public class HandleExceptionFilterAttribute : ExceptionFilterAttribute    {        public override void OnException(HttpActionExecutedContext actionExecutedContext)        {            string ctrllerName = actionExecutedContext.ActionContext.ControllerContext.ControllerDescriptor.ControllerName;            string actionName = actionExecutedContext.ActionContext.ActionDescriptor.ActionName;            string sqlCmd = null;            if (actionExecutedContext.ActionContext.ActionArguments.ContainsKey("sqlCmd"))            {                sqlCmd = BaseUtil.SerializeToJson(actionExecutedContext.ActionContext.ActionArguments["sqlCmd"] as SqlCmdInfo);            }            //���������������������            LogUitl.Error(actionExecutedContext.Exception.Message, "Api.HandleExceptionFilterAttribute",                            string.Format("SqlCmdInfo:{0};StackTrace:{1}", sqlCmd, actionExecutedContext.Exception.StackTrace));            var errResult = new ApiResultInfo(false, sqlCmd, actionName + "Err", actionExecutedContext.Exception.Message);            errResult.ExtendedData["StackTrace"] = actionExecutedContext.Exception.StackTrace;            actionExecutedContext.Response = actionExecutedContext.ActionContext.Request.CreateResponse(HttpStatusCode.OK, errResult, "application/json");        }    }

[Serializable]    public class ApiResultInfo    {        public bool Stauts { get; set; }        public object Data { get; set; }        public string ErrCode { get; set; }        public string ErrMsg { get; set; }        public Dictionary
    
      ExtendedData { get; set; }        public ApiResultInfo()        {            this.ExtendedData = new Dictionary
     
      ();        }        public ApiResultInfo(bool status, object data = null, string errCode = null, string errMsg = null, Dictionary
      
        extData = null)        {            this.Stauts = status;            this.Data = data;            this.ErrCode = errCode;            this.ErrMsg = errMsg;            this.ExtendedData = extData;            if (this.ExtendedData == null)            {                this.ExtendedData = new Dictionary
       
        ();            }        }        /// 
        
        /// ������������������������        /// 
        /// 
                /// 
                /// 
                public static ApiResultInfo BuildOKResult(object data = null, Dictionary
        
          extData = null)        {            return new ApiResultInfo(true, data, extData: extData);        }        /// 
         
 /// ������������������������ /// 
        /// 
                 /// 
                 /// 
                 /// 
                 public static ApiResultInfo BuildErrResult(string errCode = null, string errMsg = null, Dictionary
         
           extData = null) { return new ApiResultInfo(false, errCode: errCode, errMsg: errMsg, extData: extData); } }
         
        
       
      
     
    

/// 
        /// ������������������������        /// 
        ///         ///         public static void GeneratePublicAndPrivateKey(out string publickey, out string privatekey)        {            RSACryptoServiceProvider crypt = new RSACryptoServiceProvider();            publickey = crypt.ToXmlString(false);//������            privatekey = crypt.ToXmlString(true);//������        }        /// 
        /// ������������������������        /// 
        ///         ///         /// 
            public static string RSAEncrypt(string publicKey, string rawInput)        {            if (string.IsNullOrEmpty(rawInput))            {                return string.Empty;            }            if (string.IsNullOrWhiteSpace(publicKey))            {                throw new ArgumentException("Invalid Public Key");            }            using (var rsaProvider = new RSACryptoServiceProvider())            {                var inputBytes = Encoding.UTF8.GetBytes(rawInput);//���������������������������������������                rsaProvider.FromXmlString(publicKey);//������������                int bufferSize = (rsaProvider.KeySize / 8) - 11;//������������������                var buffer = new byte[bufferSize];                using (MemoryStream inputStream = new MemoryStream(inputBytes),                     outputStream = new MemoryStream())                {                    while (true)                    { //������������                        int readSize = inputStream.Read(buffer, 0, bufferSize);                        if (readSize <= 0)                        {                            break;                        }                        var temp = new byte[readSize];                        Array.Copy(buffer, 0, temp, 0, readSize);                        var encryptedBytes = rsaProvider.Encrypt(temp, false);                        outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);                    }                    return Convert.ToBase64String(outputStream.ToArray());//������������������������������                }            }        }        /// 
        /// ������������������������        /// 
        ///         ///         /// 
            public static string RSADecrypt(string privateKey, string encryptedInput)        {            if (string.IsNullOrEmpty(encryptedInput))            {                return string.Empty;            }            if (string.IsNullOrWhiteSpace(privateKey))            {                throw new ArgumentException("Invalid Private Key");            }            using (var rsaProvider = new RSACryptoServiceProvider())            {                var inputBytes = Convert.FromBase64String(encryptedInput);                rsaProvider.FromXmlString(privateKey);                int bufferSize = rsaProvider.KeySize / 8;                var buffer = new byte[bufferSize];                using (MemoryStream inputStream = new MemoryStream(inputBytes),                     outputStream = new MemoryStream())                {                    while (true)                    {                        int readSize = inputStream.Read(buffer, 0, bufferSize);                        if (readSize <= 0)                        {                            break;                        }                        var temp = new byte[readSize];                        Array.Copy(buffer, 0, temp, 0, readSize);                        var rawBytes = rsaProvider.Decrypt(temp, false);                        outputStream.Write(rawBytes, 0, rawBytes.Length);                    }                    return Encoding.UTF8.GetString(outputStream.ToArray());                }            }        }

public static class LogUitl    {        private static NLog.Logger _Logger = null;        private const string cacheKey_NLogConfigFlag = "NLogConfigFlag";        private static Logger GetLogger()        {            if (_Logger == null || HttpRuntime.Cache[cacheKey_NLogConfigFlag] == null)            {                LoggingConfiguration config = new LoggingConfiguration();                string connSetStr = ConfigUtility.GetAppSettingValue("MongoDbConnectionSet");                MongoTarget mongoTarget = new MongoTarget();                mongoTarget.ConnectionString = EncryptUtility.Decrypt(connSetStr);                mongoTarget.DatabaseName = "KYELog";                mongoTarget.CollectionName = "KYCallCenterLog";                mongoTarget.IncludeDefaults = false;                AppendLogMongoFields(mongoTarget.Fields);                LoggingRule rule1 = new LoggingRule("*", LogLevel.Debug, mongoTarget);                config.LoggingRules.Add(rule1);                LogManager.Configuration = config;                _Logger = LogManager.GetCurrentClassLogger();                HttpRuntime.Cache.Insert(cacheKey_NLogConfigFlag, "Nlog", new System.Web.Caching.CacheDependency(HttpContext.Current.Server.MapPath("~/Web.config")));            }            return _Logger;        }        private static void AppendLogMongoFields(IList
    
      mongoFields)        {            mongoFields.Clear();            Type logPropertiesType = typeof(SysLogInfo.LogProperties);            foreach (var pro in typeof(SysLogInfo).GetProperties(BindingFlags.Public | BindingFlags.Instance))            {                if (pro.PropertyType == logPropertiesType) continue;                string layoutStr = string.Empty; //"${event-context:item=" + pro.Name + "}";                if (pro.Name.Equals("ThreadID") || pro.Name.Equals("Level") || pro.Name.Equals("MachineName"))                {                    layoutStr = "${" + pro.Name.ToLower() + "}";                }                else if (pro.Name.Equals("LogDT"))                {                    layoutStr = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}";                }                else if (pro.Name.Equals("Msg"))                {                    layoutStr = "${message}";                }                if (!string.IsNullOrEmpty(layoutStr))                {                    mongoFields.Add(new MongoField(pro.Name, layoutStr, pro.PropertyType.Name));                }            }        }        private static LogEventInfo BuildLogEventInfo(LogLevel level, string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)        {            var eventInfo = new LogEventInfo();            eventInfo.Level = level;            eventInfo.Message = msg;            eventInfo.Properties["DetailTrace"] = detailTrace ?? string.Empty;            eventInfo.Properties["Source"] = source ?? string.Empty;            eventInfo.Properties["Other1"] = other1 ?? string.Empty;            eventInfo.Properties["Other2"] = other2 ?? string.Empty;            eventInfo.Properties["Other3"] = other3 ?? string.Empty;            string uid = string.Empty;            if (HttpContext.Current.User != null)            {                uid = HttpContext.Current.User.Identity.Name;            }            eventInfo.Properties["UserID"] = uid;            return eventInfo;        }        public static void Info(string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Info, msg, source, detailTrace, other1, other2, other3);                var logger = GetLogger();                logger.Log(eventInfo);            }            catch            { }        }        public static void Warn(string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Warn, msg, source, detailTrace, other1, other2, other3);                var logger = GetLogger();                logger.Log(eventInfo);            }            catch            { }        }        public static void Error(string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Error, msg, source, detailTrace, other1, other2, other3);                var logger = GetLogger();                logger.Log(eventInfo);            }            catch            { }        }        public static void Error(Exception ex, string source, string other1 = null, string other2 = null, string other3 = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Error, ex.Message, source, ex.StackTrace, other1, other2, other3);                var logger = GetLogger();                logger.Log(eventInfo);            }            catch            { }        }    }    public class SysLogInfo    {        public DateTime LogDT { get; set; }        public int ThreadID { get; set; }        public string Level { get; set; }        public string Msg { get; set; }        public string MachineName { get; set; }        public LogProperties Properties { get; set; }        public class LogProperties        {            public string Source { get; set; }            public string DetailTrace { get; set; }            public string UserID { get; set; }            public string Other1 { get; set; }            public string Other2 { get; set; }            public string Other3 { get; set; }        }    }
    

//BaseUtil:        public static DataAccess CreateDataAccess(string connName = "DefaultConnectionString")        {            return new DataAccess(connName, EncryptUtility.Decrypt);        }        public static string SerializeToJson(object obj)        {            return JsonConvert.SerializeObject(obj);        }        public static JObject DeserializeObject(string json)        {            return JObject.Parse(json);        }        public static T DeserializeObject
    
     (string json)        {            return JsonConvert.DeserializeObject
     
      (json);        }//=====================================    /// 
      
    /// ������������������������    /// 
    public static class TypeExtension    {        /// 
      
        /// ���������������������������������������������������������������������������������������Null���        /// 
        /// 
              /// 
              public static string ToNotNullString(this object obj)        {            if (obj == null || obj == DBNull.Value)            {                return string.Empty;            }            return obj.ToString();        }        /// 
      
        /// ������������������������������        /// 
        /// 
              /// 
              public static bool HasItem(this IEnumerable
      
     
    

public static class WebApiConfig    {        public static void Register(HttpConfiguration config)        {            // Web API ���������������            // Web API ������            config.MapHttpAttributeRoutes();            config.Routes.MapHttpRoute(                name: "DefaultApi",                routeTemplate: "api/{controller}/{action}/{id}",                defaults: new { id = RouteParameter.Optional }            );            config.Filters.Add(new HandleExceptionFilterAttribute());//���������������������������������            config.MessageHandlers.Add(new RequestAuthenticationHandler());//������������TOKEN������������            GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new DefaultContractResolver { IgnoreSerializableAttribute = true };        }    }

public class DataService : BaseService    {        #region ������������        private static SqlCmdInfo BuildSqlCmdInfo(string sqlCmdText, bool isSPCmdType = false, int dbType = 0, params object[] sqlParams)        {            var sqlCmdInfo = new SqlCmdInfo()            {                SqlCmdText = sqlCmdText,                DbType = dbType,                IsSPCmdType = isSPCmdType            };            if (sqlParams != null && sqlParams.Length > 0)            {                sqlCmdInfo.Parameters = new ArrayList(sqlParams);            }            return sqlCmdInfo;        }        private static string GetRrequestApiUrl(string action)        {            string requestApiUrl = string.Format("http://{0}/api/Data/{1}", ApiHost, action);            return requestApiUrl;        }        #endregion        public static ApiResultInfo
    
      Login(string uid, string pwd, string mac, string pcName)        {            var result = WebApiUtil.GetResultFromWebApi
     
      (null, new[] { uid, pwd, mac, pcName }, GetRrequestApiUrl("Login"));            if (result.Stauts)            {                SessionToken = result.Data;            }            return result;        }        public static void LogOut()        {            WebApiUtil.GetResultFromWebApi
      
       (AddHeadersWithToken(), string.Format("{\"\":\"{0}\"}", SessionToken), GetRrequestApiUrl("LogOut"));        }        public static T GetValue
       
        (string sqlCmdText, object[] sqlParams = null, bool isSPCmdType = false, int dbType = 0)        {            var sqlCmdInfo = BuildSqlCmdInfo(sqlCmdText, isSPCmdType, dbType, sqlParams);            var result = WebApiUtil.GetResultFromWebApi
        
         (AddHeadersWithToken(), sqlCmdInfo, GetRrequestApiUrl("GetValue"));            if (result.Stauts)            {                return result.Data;            }            throw new Exception(result.ErrCode + ":" + result.ErrMsg);        }        public static DataSet GetDataSet(string sqlCmdText, object[] sqlParams = null, bool isSPCmdType = false, int dbType = 0)        {            var sqlCmdInfo = BuildSqlCmdInfo(sqlCmdText, isSPCmdType, dbType, sqlParams);            var result = WebApiUtil.GetResultFromWebApi
         
          (AddHeadersWithToken(), sqlCmdInfo, GetRrequestApiUrl("GetDataSet")); if (result.Stauts) { return result.Data; } throw new Exception(result.ErrCode + ":" + result.ErrMsg); } public static DataTable GetDataTable(string sqlCmdText, object[] sqlParams = null, bool isSPCmdType = false, int dbType = 0) { var sqlCmdInfo = BuildSqlCmdInfo(sqlCmdText, isSPCmdType, dbType, sqlParams); var result = WebApiUtil.GetResultFromWebApi
          
           (AddHeadersWithToken(), sqlCmdInfo, GetRrequestApiUrl("GetDataTable")); if (result.Stauts) { return result.Data; } throw new Exception(result.ErrCode + ":" + result.ErrMsg); } public static int ExecuteCommand(string sqlCmdText, object[] sqlParams = null, bool isSPCmdType = false, int dbType = 0) { var sqlCmdInfo = BuildSqlCmdInfo(sqlCmdText, isSPCmdType, dbType, sqlParams); var result = WebApiUtil.GetResultFromWebApi
           
            (AddHeadersWithToken(), sqlCmdInfo, GetRrequestApiUrl("ExecuteCommand")); if (result.Stauts) { return result.Data; } throw new Exception(result.ErrCode + ":" + result.ErrMsg); } public static bool BatchExecuteCommand(IEnumerable
            
              sqlCmdInfos) { var result = WebApiUtil.GetResultFromWebApi
             
              (AddHeadersWithToken(), sqlCmdInfos, GetRrequestApiUrl("BatchExecuteCommand")); if (result.Stauts) { return result.Data; } throw new Exception(result.ErrCode + ":" + result.ErrMsg); } public static void ExecuteCommandAsync(string sqlCmdText, object[] sqlParams = null, bool isSPCmdType = false, int dbType = 0, Action
              
               
              
             
            
           
          
         
        
       
      
     
    

/// 
    /// WebApi���������������    /// Author:Zuowenjun    /// Date:2017/11/3    /// 
    public static class WebApiUtil    {        private const string rsaPublicKey = "���������������";        static WebApiUtil()        {            System.Net.ServicePointManager.DefaultConnectionLimit = 512;        }        /// 
        /// ������API������        /// 
        /// 
            ///         ///         ///         ///         /// 
            public static ApiResultInfo
    
      GetResultFromWebApi
     
      (Dictionary
      
        requestHeaders, object requestMsg, string apiUrl, string requestMethod = "POST")        {            string retString = HttpRequestToString(requestHeaders, requestMsg, apiUrl, requestMethod);            return JsonConvert.DeserializeObject
       
        
         >(retString);        }        /// 
         
 /// ������Http������������������������������Url������������������������������JSON������ /// 
        /// 
                 /// 
                 /// 
                 /// 
                 /// 
                 public static JObject HttpRequestToJson(Dictionary
         
           requestHeaders, object requestMsg, string apiUrl, string requestMethod = "POST") { string retString = HttpRequestToString(requestHeaders, requestMsg, apiUrl, requestMethod); return JObject.Parse(retString); } /// 
          
 /// ������Http������������������������������Url��������������������������� /// 
 /// 
          ��������� /// 
          ������������������GetMethod��������������������������� /// 
          ������������Url /// 
          ������������ /// 
          ������������������������������������������ /// 
          
           ������������(���������������������)
           public static string HttpRequestToString(Dictionary
          
            requestHeaders, object requestMsg, string apiUrl, string requestMethod = "POST", bool isEncryptBody = true) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiUrl); request.Method = requestMethod; request.KeepAlive = false; request.Proxy = null; request.ServicePoint.UseNagleAlgorithm = false; request.AllowWriteStreamBuffering = false; request.ContentType = "application/json"; if (requestHeaders != null) { foreach (var item in requestHeaders) { request.Headers.Add(item.Key, item.Value); } } request.Headers.Set("Pragma", "no-cache"); if (requestMsg != null) { string dataStr = JsonConvert.SerializeObject(requestMsg); if (isEncryptBody) { request.Headers.Add("Encryption", "1"); dataStr = RSAEncrypt(rsaPublicKey, dataStr);//������������������ } byte[] data = Encoding.UTF8.GetBytes(dataStr); request.ContentLength = data.Length; using (Stream myRequestStream = request.GetRequestStream()) { myRequestStream.Write(data, 0, data.Length); myRequestStream.Close(); } } string retString = null; using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { retString = GetResponseBody(response); } request = null; return retString; } private static string GetResponseBody(HttpWebResponse response) { string responseBody = string.Empty; if (response.ContentEncoding.ToLower().Contains("gzip")) { using (GZipStream stream = new GZipStream(response.GetResponseStream(), CompressionMode.Decompress)) { using (StreamReader reader = new StreamReader(stream, Encoding.UTF8)) { responseBody = reader.ReadToEnd(); } } } else if (response.ContentEncoding.ToLower().Contains("deflate")) { using (DeflateStream stream = new DeflateStream( response.GetResponseStream(), CompressionMode.Decompress)) { using (StreamReader reader = new StreamReader(stream, Encoding.UTF8)) { responseBody = reader.ReadToEnd(); } } } else { using (Stream stream = response.GetResponseStream()) { using (StreamReader reader = new StreamReader(stream, Encoding.UTF8)) { responseBody = reader.ReadToEnd(); } } } return responseBody; } public static string RSAEncrypt(string publicKey, string rawInput) { if (string.IsNullOrEmpty(rawInput)) { return string.Empty; } if (string.IsNullOrWhiteSpace(publicKey)) { throw new ArgumentException("Invalid Public Key"); } using (var rsaProvider = new RSACryptoServiceProvider()) { var inputBytes = Encoding.UTF8.GetBytes(rawInput);//��������������������������������������� rsaProvider.FromXmlString(publicKey);//������������ int bufferSize = (rsaProvider.KeySize / 8) - 11;//������������������ var buffer = new byte[bufferSize]; using (MemoryStream inputStream = new MemoryStream(inputBytes), outputStream = new MemoryStream()) { while (true) { //������������ int readSize = inputStream.Read(buffer, 0, bufferSize); if (readSize <= 0) { break; } var temp = new byte[readSize]; Array.Copy(buffer, 0, temp, 0, readSize); var encryptedBytes = rsaProvider.Encrypt(temp, false); outputStream.Write(encryptedBytes, 0, encryptedBytes.Length); } return Convert.ToBase64String(outputStream.ToArray());//������������������������������ } } } }
          
         
        
       
      
     
    

[Serializable]    public class SqlCmdInfo    {        public string SqlCmdText { get; set; }        public ArrayList Parameters { get; set; }        public bool IsSPCmdType { get; set; }        public int DbType { get; set; }    }    [Serializable]    public class ApiResultInfo
    
         {        public bool Stauts { get; set; }        public T Data { get; set; }        public string ErrCode { get; set; }        public string ErrMsg { get; set; }        public Dictionary
     
       ExtendedData { get; set; }        public ApiResultInfo()        {            this.ExtendedData = new Dictionary
      
       ();        }        public ApiResultInfo(bool status, T data, string errCode = null, string errMsg = null, Dictionary
       
         extData = null)        {            this.Stauts = status;            this.Data = data;            this.ErrCode = errCode;            this.ErrMsg = errMsg;            this.ExtendedData = extData;            if (this.ExtendedData == null)            {                this.ExtendedData = new Dictionary
        
         ();            }        }    }
        
       
      
     
    

//������������DataService������������������������������������������������������������ADO.NET���������������������������������DataTable dt = DataService.GetDataTable("SQL������", new object[] { ������});DataService.ExecuteCommand("SQL������", new Object[] { ������ });