1 /// <summary>

 2     /// 基本验证Attribtue，用以WebApi请求的权限处理

 3     /// </summary>

 4     public class BasicAuthenticationAttribute : ActionFilterAttribute

 5     {

 6         private static Uni2uni.Framework.Cache.ICache cache = CacheFactory.Redis(RedisDb.User);

 7

 8         /// <summary>

 9         /// 检查用户是否有该WebApi请求执行的权限

10         /// </summary>

11         /// <param name="actionContext"></param>

12         public override void OnActionExecuting(HttpActionContext actionContext)

13         {

14             if (actionContext.Request.Headers.Contains("Set-Cookie"))

15             {

16                 var accessToken = actionContext.Request.Headers.GetValues("Set-Cookie");

17                 Dictionary<string, string> item = new Dictionary<string, string>();

18                 accessToken.FirstOrDefault().ToString().Split('&').Each(i =>

19                 {

20                     var itemLine = i.Split('=');

21                     item.Add(itemLine[0], itemLine[1]);

22                 });

23                 //解密用户token值，看有没有登录

24                 string tokenValue = System.Web.HttpUtility.UrlDecode(item["access_token"]);

25                 if (ValidateToken(tokenValue))

26                 {

27                     base.OnActionExecuting(actionContext);

28                 }

29                 else

30                 {

31                     actionContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized);

32                     actionContext.Response.Content = new StringContent("The request has no token or toke id expired,is invalid !",

33                                                           Encoding.UTF8, "text/plain");

34                 }

35             }

36             else

37             {

38                 //检查web.config配置是否要求权限校验

39                 bool isRquired = (WebConfigurationManager.AppSettings["WebApiAuthenticatedFlag"].ToString() == "true");

40                 if (isRquired)

41                 {

42                     //如果请求Header不包含token，则判断是否是匿名调用

43                     var attr = actionContext.ActionDescriptor.GetCustomAttributes<AllowAnonymousAttribute>().OfType<AllowAnonymousAttribute>();

44                     bool isAnonymous = attr.Any(a => a is AllowAnonymousAttribute);

45

46                     //是匿名用户，则继续执行；非匿名用户，抛出“未授权访问”信息

47                     if (isAnonymous)

48                     {

49                         base.OnActionExecuting(actionContext);

50                     }

51                     else

52                     {

53                         actionContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized);

54                         actionContext.Response.Content = new StringContent("The request is Unauthorized,is nto allow!",

55                                                         Encoding.UTF8, "text/plain");

56                     }

57                 }

58                 else

59                 {

60                     base.OnActionExecuting(actionContext);

61                 }

62             }

63         }

64

65         /// <summary>

66         /// 验证是否登录授权

67         /// </summary>

68         /// <param name="token"></param>

69         /// <returns></returns>

70         public bool ValidateToken(string token)

71         {

72             if (!string.IsNullOrEmpty(token))

73             {

74                 var model = cache.Get<LoginMember>(token);

75                 Logger.Error("2:请求中的。。。:model:" + model == null ? "不存在" : model.UserName);

76                 return model != null ? true : false;

77             }

78             return false;

79         }

80     }

   [BasicAuthentication]

    public abstract class ApiControllerBase : ApiController

    {

        #region  Common Pager

        /// <summary>

        ///  给结果集扩展一个分页

        /// </summary>

        /// <typeparam name="T">实体</typeparam>

        /// <param name="_defaultSetting">页面设置</param>

        /// <param name="options">筛选条件集合</param>

        /// <param name="_list">待分页集合</param>

        /// <returns></returns>

        public PageResult<TEntity> GetPager<TEntity>(ODataQueryOptions<TEntity> options, IEnumerable<TEntity> _list, int PageSizeCount = 6) where TEntity : class

        {

            ODataQuerySettings settings = new ODataQuerySettings

            {

                PageSize = PageSizeCount

            };

            IQueryable results = options.ApplyTo(_list.AsQueryable(), settings);

            Request.GetInlineCount();

            return new PageResult<TEntity>(

                results as IEnumerable<TEntity>,

                Request.GetNextPageLink(),

                Request.GetInlineCount());

        }

        #endregion

        #region Common Upload

        /// <summary>

        /// 通用上传图片-操作

        /// </summary>

        /// <typeparam name="T">上传实体</typeparam>

        /// <param name="dirPath">上传路劲</param>

        /// <param name="fileNameAction">文件名自定义扩展</param>

        /// <param name="Entity">实体名字</param>

        /// <returns>图片上传是否成功</returns>

        [NonAction]

        public Hashtable CommonUpload<T>(string dirPath, Action<string> fileNameAction, out T Entity) where T : class

        {

            var queryp = Request.GetQueryNameValuePairs(); //获得查询字符串的键值集合

            Entity = GetUploadEntity<T>(queryp); //实体赋值操作

            // 检查是否是 multipart/form-data

            if (!Request.Content.IsMimeMultipartContent("form-data"))

                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);

            //文件保存目录路径

            string SaveTempPath = dirPath;

            String dirTempPath = HttpContext.Current.Server.MapPath(SaveTempPath);

            Logger.Error("文件路径:" + dirTempPath);

            // 设置上传目录

            var provider = new MultipartFormDataStreamProvider(dirTempPath);

            //Logger.Error("queryp参数:" + param);

            var task = Request.Content.ReadAsMultipartAsync(provider).

                ContinueWith<Hashtable>(o =>

                {

                    Hashtable hash = new Hashtable();

                    hash["error"] = 1;

                    hash["errmsg"] = "上传出错";

                    var file = provider.FileData[0];//provider.FormData

                    string orfilename = file.Headers.ContentDisposition.FileName.TrimStart('"').TrimEnd('"');

                    FileInfo fileinfo = new FileInfo(file.LocalFileName);

                    Logger.Error("最大文件大小:" + fileinfo.Length);

                    Logger.Error("最大格式:" + orfilename);

                    //最大文件大小

                    int maxSize = 10000000;

                    if (fileinfo.Length <= 0)

                    {

                        hash["error"] = 1;

                        hash["errmsg"] = "请选择上传文件。";

                    }

                    else if (fileinfo.Length > maxSize)

                    {

                        hash["error"] = 1;

                        hash["errmsg"] = "上传文件大小超过限制。";

                    }

                    else

                    {

                        string fileExt = orfilename.Substring(orfilename.LastIndexOf('.'));

                        //定义允许上传的文件扩展名

                        String fileTypes = "gif,jpg,jpeg,png,bmp";

                        if (String.IsNullOrEmpty(fileExt) || Array.IndexOf(fileTypes.Split(','), fileExt.Substring(1).ToLower()) == -1)

                        {

                            hash["error"] = 1;

                            hash["errmsg"] = "上传文件扩展名是不允许的扩展名。";

                        }

                        else

                        {

                            //String ymd = DateTime.Now.ToString("yyyyMMdd", System.Globalization.DateTimeFormatInfo.InvariantInfo);

                            //String newFileName = DateTime.Now.ToString("yyyyMMddHHmmss_ffff", System.Globalization.DateTimeFormatInfo.InvariantInfo);

                            //String finalFileName = newFileName + fileExt;

                            string excute_FileName = string.Empty;

                            fileNameAction = (i) => { excute_FileName = i; };

                            fileinfo.CopyTo(Path.Combine(dirTempPath, excute_FileName), true);

                            fileinfo.Delete();

                            hash["error"] = 0;

                            hash["errmsg"] = "上传成功";

                            hash["filePathUrl"] = excute_FileName;

                        }

                    }

                    return hash;

                });

            return null;

        }

        /// <summary>

        /// 反射动态的实体赋值-操作

        /// </summary>

        /// <typeparam name="Entity"></typeparam>

        /// <param name="queryp"></param>

        /// <returns></returns>

        [NonAction]

        public Entity GetUploadEntity<Entity>(IEnumerable<KeyValuePair<string, string>> queryp) where Entity : class

        {

            var entity = typeof(Entity);

            Object model = entity.Assembly.CreateInstance(entity.FullName, true);

            var props = entity.GetProperties(BindingFlags.Instance | BindingFlags.Public);

            foreach (PropertyInfo propertyInfo in typeof(Entity).GetProperties())

            {

                queryp.Each(i =>

                {

                    if (i.Key.Equals(propertyInfo.Name.ToString()))

                    {

                        propertyInfo.SetValue(model, i.Value, null);

                    }

                });

            }

            return (Entity)model;

        }

        #endregion

    }