精华内容
下载资源
问答
  • 1、zTree 编辑角色相关联的的权限的时候,需要构造一颗树, 树我的做法是先添加有权限的节点,再添加剩下的节点, 这样做有一个不好的地方就是, 节点的先后顺序,跟添加的...请问怎么实现第二种方式呢,谢谢。
  • 数据库中有对应用户权限的等级可实现的功能的代码例如:10001|10002|20001|20002|20003,然后根据这些去实现权限划分下载接口中怎么实现 大佬能给个示例代码吗
  • 好多年前,还在2004年左右,看到公司的权限配置管理功能里有复制粘贴功能,当时也没注意是怎么实现的,后来当自己想实现这个功能时死活不知道如何实现才好,现在是2011年了,终于自己写了复制粘贴方法的实现,唉,7...

    好几年一直想实现的功能,今天终于做出来了,权限配置时的批量复制粘贴功能的实现,真正好用的权限配置管理开发工具

    好多年前,还在2004年左右,看到公司的权限配置管理功能里有复制粘贴功能,当时也没注意是怎么实现的,后来当自己想实现这个功能时死活不知道如何实现才好,现在是2011年了,终于自己写了复制粘贴方法的实现,唉,7年前看到的东西,7年后才有能力实现好,感觉自己的确有些菜鸟。

    2011022401.png


    2011022402.png


    有清除权限的功能可以把账户的权限成批的清理好,而且有复制粘贴功能,可以非常容易把一个角色的权限配置复制到另外一个角色里,不用反复手工操作,可以明显提高工作效率,用户用起来也会舒服很多很多,其实很多软件用起来不好用,大多是我们没给客户提供友善的操作功能,没能深入到客户的日常习惯导致的。

    2011022403.png

    把一个小软件,小工具做个彻底,有重复利用的价值,有商业化的价值,那就有他更精细化的意义了。

    希望C#.NET通用权限管理系统组件源码能给更多有需要的用户提供便捷的开发、管理、配置、规划,让开发人员早点儿回家休息。




    本文转自 jirigala 51CTO博客,原文链接:http://blog.51cto.com/2347979/1200784,如需转载请自行联系原作者
    展开全文
  • 好多都是6.0以前的,都不能用,后来获取了系统权限,还是安装不上,说只能在源生系统的手机山才能安装,但是现在手机都是定制系统,请问有什么办法能实现在6.0以上的安卓系统上实现手机关机功能吗?
  • 我有一个这样的功能需要实现:左边一个datagrid,用来显示用户组,点击datagrid每一个item(每一行用户组数据)时候,显示另一个datagrid(显示用户组权限),如果已经数据库用户组已经分配权限值的时候,右边的...
    如何实现flex中dategrid中全选、选中功能
    我有一个这样的功能需要实现:左边一个datagrid,用来显示用户组,点击datagrid每一个item(每一行用户组数据)时候,显示另一个datagrid(显示用户组权限),如果已经数据库用户组已经分配权限值的时候,右边的datagrid权限处于选中状态,如果没有分配权限,就不选中,还有做一个全选功能,如果用jsp就比较好实现,但是在flex实现起来相当之麻烦,开始用datagrid渲染,感觉好麻烦,而且自己水平有限,好像实现不出来,望各位指点指点???

    ------解决方案--------------------------------------------------------
    这要看你怎么给数据了,比如,<users><user><access></access><access></access></user><user>....</users>这样,那你左边的dataGrid绑定到这个数据,labelField设成user的名字,然后右边的dataGrid绑定到左边dataGrid的selectedItem, 然后labelField设成access的名字,做个itemRenderer,比如一个CheckBox,绑到
    是否分配权限的数据。
    全选功能,也就是对第二个dataGrid的数据,for each一次,把分配权限的数据给设定上去。
    ------解决方案--------------------------------------------------------
    在flex里,datagrid之类的列表组件是数据驱动的
    数据驱动的核心就是,改变数据就可以改变组件的显示
    因此在flex里,可以认为是最简单的操作方式,只需要对数据进行处理就可以实现选择的效果,举例来说
    在列表中的数据某一些选中,而另一些不选中,那么可以安排数据中的一个字段保存这个状态
    比如是一个用户对象,有id、name、age、sex等属性,那么可以再动态的定义一个selected,因为as是动态语言,只要不声明强类型,任意数据对象是可以动态添加属性的
    只需要用遍历,将需要被勾选的对应用户的selected属性设为true
    然后结合itemRenderer,将checkbox的selected属性赋值为data的selected值,并实现checkbox的选中后改变data的selected值,这样就完成了整个数据驱动的关联操作。
    相关的内容其实在riachina3群的共享里有个关于列表组件的教程,里面有更详细的讲解。
    展开全文
  • 好多年前,还在2004年左右,看到公司的权限配置管理功能里有复制粘贴功能,当时也没注意是怎么实现的,后来当自己想实现这个功能时死活不知道如何实现才好,现在是2011年了,终于自己写了复制粘贴方法的实现,唉,7...
       好多年前,还在2004年左右,看到公司的权限配置管理功能里有复制粘贴功能,当时也没注意是怎么实现的,后来当自己想实现这个功能时死活不知道如何实现才好,现在是2011年了,终于自己写了复制粘贴方法的实现,唉,7年前看到的东西,7年后才有能力实现好,感觉自己的确有些菜鸟。


     


    有清除权限的功能可以把账户的权限成批的清理好,而且有复制粘贴功能,可以非常容易把一个角色的权限配置复制到另外一个角色里,不用反复手工操作,可以明显提高工作效率,用户用起来也会舒服很多很多,其实很多软件用起来不好用,大多是我们没给客户提供友善的操作功能,没能深入到客户的日常习惯导致的。 

     

    把一个小软件,小工具做个彻底,有重复利用的价值,有商业化的价值,那就有他更精细化的意义了。

    希望C#.NET通用权限管理系统组件源码能给更多有需要的用户提供便捷的开发、管理、配置、规划,让开发人员早点儿回家休息。

     

     

    转载于:https://www.cnblogs.com/jirigala/archive/2011/02/24/1964204.html

    展开全文
  • 3. 需要通过注解实现权限判断,比如:@HasRole(“ADMIN”); 4. 参考@RequestBody 的原理。完成登陆用户信息注入的功能; 5. 支持多种登陆方式:账号密码、oauth2/openid 等模式; 6. 需要支持分布式环境;
  • 如果你的web应用受到恶意扫描或攻击,你会怎么处理呢?...现将在MVC下实现的一个IP访问限制功能分享一下: 1、通过路由规则配置来设置禁止IP访问 public class RouteConfig { public static void Reg...

    如果你的web应用受到恶意扫描或攻击,你会怎么处理呢?大多数时候从应用日志里可以看到恶意扫描或攻击,遇到此类情况,如有一个可以进行IP访问控制的功能就好些了。

    现将在MVC下实现的一个IP访问限制功能分享一下:

    1、通过路由规则配置来设置禁止IP访问

        public class RouteConfig
        {
            public static void RegisterRoutes(RouteCollection routes)
            {
                routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    
                //通过路由规则配置来设置禁止IP访问
                routes.MapRoute(
                    name: "Abandon",
                    url: "{controller}/{action}/{id}",
                    defaults: new { controller = "Account", action = "AbandonIP", id = UrlParameter.Optional },
                    constraints: new { customConstraint = new AbandonIPConstraint() }//自定义限制路由
                );
    
                routes.MapRoute(
                    name: "Default",
                    url: "{controller}/{action}/{id}",
                    defaults: new { controller = "Account", action = "Index", id = UrlParameter.Optional }
                );
    
                //GlobalHost.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(50);
              
            }
        }

     2、自定义限制路由的实现

        public class AbandonIPConstraint : IRouteConstraint
        {
            public bool Match(HttpContextBase httpContext, Route route, string parameterName,
             RouteValueDictionary values, RouteDirection routeDirection)
            {
                var currentIp = httpContext.Request.UserHostAddress;
                //如果当前访问用户的ip是127.0.0.1,则匹配Abandon路由,如果不是则匹配其他路由
                // return currentIp == "110.19.222.144";
                bool result = SecurityHelper.CheckIPAddress(currentIp);
                return result;
            }
        }

     3、IP检查功能

            /// <summary>
            /// 检查用户IP地址是否被限制登录系统
            /// </summary>
            /// <param name="ipAddress">IP地址</param>
            /// <returns>是否符合限制</returns>
            public static bool CheckIPAddress(string ipAddress)
            {
                bool result = false;
                var list = GetCacheAbandonIpAddressList();
                if (list != null && list.Count > 0)
                {
                    foreach (AbandonIpaddressEntity model in list)
                    {
                        //删除的或者没有启用的排除掉
                        if (model.DeletionStateCode == 1 || model.Enabled==0)
                        {
                            continue;
                        }
                        string ipAddressType = model.IpAddressType;
                        string ipAddressContent = model.IpAddressContent;
                        if (string.Equals(ipAddressType, "Single",StringComparison.OrdinalIgnoreCase))
                        {
                            // 匹配单个IP
                            result = CheckSingleIPAddress(ipAddress, ipAddressContent);
                        }
                        else if (string.Equals(ipAddressType, "Range", StringComparison.OrdinalIgnoreCase))
                        {
                            // 匹配ip地址段
                            result = CheckIPAddressWithRange(ipAddress, ipAddressContent);
                        }
                        else if (string.Equals(ipAddressType, "Mask", StringComparison.OrdinalIgnoreCase))
                        {
                            // 匹配带掩码的地址段
                            result = CheckIPAddressWithMask(ipAddress, ipAddressContent);
                        }
                        if (result)
                        {
                            break;
                        }
                    }
                }
                return result;
            }
            /// <summary>
            /// 检查是否匹配单个IP
            /// </summary>
            /// <param name="ipAddress"></param>
            /// <param name="sourceIp"></param>
            /// <returns></returns>
            public static bool CheckSingleIPAddress(string ipAddress, string sourceIp)
            {
                return ipAddress.Equals(sourceIp);
            }
    
            /// <summary>
            /// 检查是否匹配地址段
            /// </summary>
            /// <param name="ipAddress">192.168.0.8</param>
            /// <param name="ipRange">192.168.0.1-192.168.0.10</param>
            /// <returns></returns>
            public static bool CheckIPAddressWithRange(string ipAddress, string ipRange)
            {
                //先判断符合192.168.0.1-192.168.0.10 的正则表达式
                //在判断ipAddress是否有效
                string startIp = ipRange.Split('-')[0];
                string endIp = ipRange.Split('-')[1];
                //如果大于等于 startip 或者 小于等于endip
                if (CompareIp(ipAddress, startIp) == 2 && CompareIp(ipAddress, endIp) == 0 || CompareIp(ipAddress, startIp) == 1 || CompareIp(ipAddress, endIp) == 1)
                {
                    return true;
                }
                return false;
            }
    
            /// <summary>
            /// 比较两个IP地址,比较前可以先判断是否是IP地址
            /// </summary>
            /// <param name="ip1"></param>
            /// <param name="ip2"></param>
            /// <returns>1:相等;  0:ip1小于ip2 ; 2:ip1大于ip2;-1 不符合ip正则表达式 </returns>
            public static int CompareIp(string ip1, string ip2)
            {
                String[] arr1 = ip1.Split('.');
                String[] arr2 = ip2.Split('.');
                for (int i = 0; i < arr1.Length; i++)
                {
                    int a1 = int.Parse(arr1[i]);
                    int a2 = int.Parse(arr2[i]);
                    if (a1 > a2)
                    {
                        return 2;
                    }
                    else if (a1 < a2)
                    {
                        return 0;
                    }
                }
                return 1;
            }
    
            /// <summary>
            /// 检查是否匹配带通配符的IP地址
            /// </summary>
            /// <param name="ipAddress">192.168.1.1</param>
            /// <param name="ipWithMask">192.168.1.*</param>
            /// <returns></returns>
            public static bool CheckIPAddressWithMask(string ipAddress, string ipWithMask)
            {
                //先判断是否符合192.168.1.*
                //然后判断
                string[] arr1 = ipAddress.Split('.');
                string[] arr2 = ipWithMask.Split('.');
                for (int i = 0; i < arr1.Length; i++)
                {
                    if (!(arr2[i].Equals("*") || arr1[i].Equals(arr2[i])))
                    {
                        return false;
                    }
                }
                return true;
            }

    4、限制的IP做了缓存,缓存的实现大家可以自己按照具体环境去实现

            /// <summary>
            /// 移除IP缓存数据
            /// </summary>
            public static void RemoveCacheAbandonIpAddressList()
            {
                //移除
                DataCacheHelper.RemoveCache("GetCacheAbandonIpAddressList");
            }
            /// <summary>
            /// 获取缓存的数据
            /// </summary>
            /// <returns></returns>
            public static List<AbandonIpaddressEntity> GetCacheAbandonIpAddressList()
            {
                string cacheKey = "GetCacheAbandonIpAddressList";
                if (null == DataCacheHelper.GetCache(cacheKey))
                {
                    lock (Locker)
                    {
                        if (null == DataCacheHelper.GetCache(cacheKey))
                        {
                            try
                            {
                                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                                AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper);
                                List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
                                var list = manager.GetList<AbandonIpaddressEntity>(parameters);
                                DataCacheHelper.SetCache(cacheKey, list, null, DateTime.Now.AddMinutes(120), Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
                                return list;
                            }
                            catch (Exception ex)
                            {
                                LogHelper.WriteErrorLog("private List<AbandonIpaddressEntity> GetCacheAbandonIpAddressList()", ex);
                                return null;
                            }
                        }
                    }
                }
                return DataCacheHelper.GetCache(cacheKey) as List<AbandonIpaddressEntity>;
            }

    5、受限IP维护功能

        /// <summary>
        /// AbandonController
        /// 
        /// 禁止登录系统的控制器
        /// 
        /// 修改纪录
        /// 
        /// 2015-10-10 版本:1.0 SongBiao 创建文件。   /// 
        /// <author>
        ///     <name>SongBiao</name>
        ///     <date>2015-10-10</date>
        /// </author>
        /// </summary>
    
        public class AbandonController : BaseController
        {
            //
            // GET: /Abandon/
            [AjaxRequest]
            [CustomAuthorizeAttribute]
            public ActionResult Index()
            {
                return View();
            }
    
            [AjaxRequest]
            [CustomAuthorizeAttribute]
            public ActionResult ListIPAddress(Pager pager, string sort, string direction)
            {
                Hashtable result = new Hashtable();
                DataTable dt = new DataTable();
                List<KeyValuePair<string, object>> dbParameters = new List<KeyValuePair<string, object>>();
                List<string> listWhere = new List<string>();
                string conditions = string.Empty;
                string tableName = AbandonIpaddressEntity.TableName;
                string selectField = " * ";
                int totalRows = 0;
                string orderBy = sort + " " + direction;
                try
                {
                    IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                    dt = DbLogic.GetDataTableByPage(dbHelper, out totalRows, tableName, selectField, pager.pageNo, pager.pageSize, conditions, dbHelper.MakeParameters(dbParameters), orderBy);
                    pager.totalPages = totalRows;
                    result.Add("status", "true");
                    result.Add("message", "成功获取数据。");
                    result.Add("pager.pageNo", pager.pageNo);
                    result.Add("rows", dt);//DataTableHelper.DataTable2Json(dt)
                    result.Add("pager.totalRows", pager.totalPages);
                    result.Add("sort", sort);
                    result.Add("direction", direction);
                }
                catch (Exception ex)
                {
                    result.Add("status", "false");
                    result.Add("message", "系统异常:" + ex.Message);
                    result.Add("pager.pageNo", pager.pageNo);
                    result.Add("rows", dt);//DataTableHelper.DataTable2Json(dt)
                    result.Add("pager.totalRows", pager.totalPages);
                    result.Add("sort", sort);
                    result.Add("direction", direction);
                    LogHelper.OracleWarn(OperateContext.Current.UserInfo, "获取限制IP数据出现异常", ex.Message, "ListIPAddress", typeof(AbandonController), ex);
                }
                result.Add("span", (DateTime.Now - begin).TotalMilliseconds);
                return Json(result, JsonRequestBehavior.AllowGet);
            }
    
            /// <summary>
            /// IP地址是否限制
            /// </summary>
            /// <param name="ipAddress"></param>
            /// <returns></returns>
            public ActionResult CheckIPAddress(string ipAddress)
            {
                if (SecurityHelper.CheckIPAddress(ipAddress))
                {
                    return Content(ipAddress + "不允许登录系统");
                }
                else
                {
                    return Content(ipAddress + "可以登录系统");
                }
            }
    
            /// <summary>
            /// 添加受限的IP地址
            /// </summary>
            /// <returns></returns>
            public ActionResult AddIP()
            {
                return View();
            }
    
            /// <summary>
            /// 显示受限IP地址
            /// </summary>
            /// <returns></returns>
            public ActionResult ShowIP(string id)
            {
                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
                AbandonIpaddressEntity entity = manager.GetObject(id);
                //ViewBag.AbandonIpaddressEntity = entity;
                return View(entity);
            }
    
            /// <summary>
            /// 显示受限IP地址
            /// </summary>
            /// <returns></returns>
            public ActionResult EditIP(string id)
            {
                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
                AbandonIpaddressEntity entity = manager.GetObject(id);
                //ViewBag.AbandonIpaddressEntity = entity;
                return View(entity);
            }
    
            /// <summary>
            /// 添加受限的IP
            /// </summary>
            /// <param name="abandonIpaddress"></param>
            /// <returns></returns>
            [HttpPost]
            public ActionResult SaveIP(AbandonIpaddressEntity abandonIpaddress)
            {
                //Hashtable result = new Hashtable();
                BaseResult baseResult = new BaseResult();
                baseResult.Status = false;
                AbandonIpaddressEntity entity = new AbandonIpaddressEntity();
                if (string.IsNullOrWhiteSpace(abandonIpaddress.Id))
                {
                    entity.Id = Guid.NewGuid().ToString();
                    entity.DeletionStateCode = 0;
                    entity.Enabled = 1;
                }
                entity.IpAddressType = abandonIpaddress.IpAddressType;
                entity.IpAddressContent = abandonIpaddress.IpAddressContent;
                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
                //判断IP是否已受限
                var list = SecurityHelper.GetCacheAbandonIpAddressList();
                bool hasIP = false;
                AbandonIpaddressEntity hasModel = null;
                if (list != null && list.Count > 0)
                {
                    foreach (AbandonIpaddressEntity model in list)
                    {
                        string ipAddressType = model.IpAddressType;
                        string ipAddressContent = model.IpAddressContent;//IP检查是否存在
                        if (string.Equals(ipAddressContent, abandonIpaddress.IpAddressContent, StringComparison.OrdinalIgnoreCase))
                        {
                            hasIP = true;
                            hasModel = model;
                            break;
                        }
                    }
                }
                if (hasIP)
                {
                    //已存在受限的IP 不允许再添加了  更新一下状态即可
                    if (string.IsNullOrWhiteSpace(abandonIpaddress.Id))
                    {
                        hasModel.DeletionStateCode = 0;
                        hasModel.Enabled = 1;
                    }
                    else
                    {
                        hasModel.DeletionStateCode = abandonIpaddress.DeletionStateCode;
                        hasModel.Enabled = abandonIpaddress.Enabled;
                    }
                    manager.Update(hasModel);
                    baseResult.Status = true;
                    baseResult.StatusMessage = "IP已受限,不允许重复添加!";
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(abandonIpaddress.Id))
                    {
                        string result = manager.Add(entity, false, true);
                        if (!string.IsNullOrWhiteSpace(result))
                        {
                            baseResult.Status = true;
                            baseResult.StatusMessage = "添加成功。";
                        }
                        else
                        {
                            baseResult.StatusMessage = "添加失败了。";
                        }
                    }
                    else
                    {
                        //状态更新 IP类型和值 是不允许修改的
                        entity.Id = abandonIpaddress.Id;
                        entity.DeletionStateCode = abandonIpaddress.DeletionStateCode;
                        entity.Enabled = abandonIpaddress.Enabled;
                        manager.Update(entity);
                        baseResult.Status = true;
                        baseResult.StatusMessage = "更新成功。";
                    }
                }
                //操作成功 清除一下缓存
                if (baseResult.Status)
                {
                    SecurityHelper.RemoveCacheAbandonIpAddressList();
                }
                return Json(baseResult, JsonRequestBehavior.AllowGet);
            }
    
    
            /// <summary>
            /// 删除受限的IP
            /// </summary>
            /// <param name="id"></param>
            /// <returns></returns>
            public ActionResult DeleteIP(string id)
            {
                BaseResult baseResult = new BaseResult();
                baseResult.Status = false;
                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
                if (manager.Delete(id) == 1)
                {
                    baseResult.Status = true;
                    baseResult.StatusMessage = "删除成功。";
                    SecurityHelper.RemoveCacheAbandonIpAddressList();
                }
                else
                {
                    baseResult.Status = false;
                    baseResult.StatusMessage = "删除失败。";
                }
    
                return Json(baseResult, JsonRequestBehavior.AllowGet);
            }
    
            /// <summary>
            /// 批量删除受限的IP
            /// </summary>
            /// <param name="ids"></param>
            /// <returns></returns>
            public ActionResult DeleteIPBatch(string[] ids)
            {
                BaseResult baseResult = new BaseResult();
                baseResult.Status = false;
                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
                if (manager.Delete(ids) == 1)
                {
                    baseResult.Status = true;
                    baseResult.StatusMessage = "删除成功。";
                    SecurityHelper.RemoveCacheAbandonIpAddressList();
                }
                else
                {
                    baseResult.Status = false;
                    baseResult.StatusMessage = "删除失败。";
                }
                return Json(baseResult, JsonRequestBehavior.AllowGet);
            }
    
        }

    6、业务和实体底层代码使用了通用权限管理系统中的代码生成器生成;

     业务层

        /// <summary>
        /// AbabdonIpaddressManager
        /// 禁止访问系统的IP数据表
        /// 
        /// 修改纪录
        /// 
        /// 2015-10-10 版本:1.0 SongBiao 创建文件。
        /// 
        /// <author>
        ///     <name>SongBiao</name>
        ///     <date>2015-10-10</date>
        /// </author>
        /// </summary>
        public partial class AbandonIpaddressManager : BaseManager, IBaseManager
        {
            /// <summary>
            /// 构造函数
            /// </summary>
            public AbandonIpaddressManager()
            {
                if (base.dbHelper == null)
                {
                    base.dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                }
                if (string.IsNullOrEmpty(base.CurrentTableName))
                {
                    base.CurrentTableName = AbandonIpaddressEntity.TableName;
                }
                base.PrimaryKey = "Id";
            }
    
            /// <summary>
            /// 构造函数
            /// <param name="tableName">指定表名</param>
            /// </summary>
            public AbandonIpaddressManager(string tableName)
            {
                base.CurrentTableName = tableName;
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="dbHelper">数据库连接</param>
            public AbandonIpaddressManager(IDbHelper dbHelper)
                : this()
            {
                DbHelper = dbHelper;
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="userInfo">用户信息</param>
            public AbandonIpaddressManager(BaseUserInfo userInfo)
                : this()
            {
                UserInfo = userInfo;
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="userInfo">用户信息</param>
            /// <param name="tableName">指定表名</param>
            public AbandonIpaddressManager(BaseUserInfo userInfo, string tableName)
                : this(userInfo)
            {
                base.CurrentTableName = tableName;
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="dbHelper">数据库连接</param>
            /// <param name="userInfo">用户信息</param>
            public AbandonIpaddressManager(IDbHelper dbHelper, BaseUserInfo userInfo)
                : this(dbHelper)
            {
                UserInfo = userInfo;
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="dbHelper">数据库连接</param>
            /// <param name="userInfo">用户信息</param>
            /// <param name="tableName">指定表名</param>
            public AbandonIpaddressManager(IDbHelper dbHelper, BaseUserInfo userInfo, string tableName)
                : this(dbHelper, userInfo)
            {
                base.CurrentTableName = tableName;
            }
    
            /// <summary>
            /// 添加, 这里可以人工干预,提高程序的性能
            /// </summary>
            /// <param name="entity">实体</param>
            /// <param name="identity">自增量方式,表主键是否采用自增的策略</param>
            /// <param name="returnId">返回主键,不返回程序允许速度会快,主要是为了主细表批量插入数据优化用的</param>
            /// <returns>主键</returns>
            public string Add(AbandonIpaddressEntity entity, bool identity = true, bool returnId = true)
            {
                this.Identity = identity;
                this.ReturnId = returnId;
                entity.Id = this.AddObject(entity);
                return entity.Id.ToString();
            }
    
            /// <summary>
            /// 更新
            /// </summary>
            /// <param name="entity">实体</param>
            public int Update(AbandonIpaddressEntity entity)
            {
                return this.UpdateObject(entity);
            }
    
            /// <summary>
            /// 获取实体
            /// </summary>
            /// <param name="id">主键</param>
            public AbandonIpaddressEntity GetObject(string id)
            {
                return BaseEntity.Create<AbandonIpaddressEntity>(this.GetDataTable(new KeyValuePair<string, object>(this.PrimaryKey, id)));
                //return GetObject(id);
            }
    
            //public AbandonIpaddressEntity GetObject(int id)
            //{
            //    return BaseEntity.Create<AbandonIpaddressEntity>(this.GetDataTable(new KeyValuePair<string, object>(this.PrimaryKey, id)));
            //}
    
            /// <summary>
            /// 添加实体
            /// </summary>
            /// <param name="entity">实体</param>
            public string AddObject(AbandonIpaddressEntity entity)
            {
                string key = entity.Id;
                SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
                sqlBuilder.BeginInsert(this.CurrentTableName, this.PrimaryKey);
                if (!this.Identity)
                {
                    // 这里已经是指定了主键了,所以不需要返回主键了
                    sqlBuilder.ReturnId = false;
                    sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
                }
                else
                {
                    if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
                    {
                        if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
                        {
                            sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
                        }
                        if (DbHelper.CurrentDbType == CurrentDbType.DB2)
                        {
                            sqlBuilder.SetFormula(this.PrimaryKey, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
                        }
                    }
                    else
                    {
                        if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
                        {
                            BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper);
                            entity.Id = sequenceManager.Increment(this.CurrentTableName);
                            sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
                        }
                    }
                }
                this.SetObject(sqlBuilder, entity);
                if (UserInfo != null)
                {
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldCreateUserId, UserInfo.Id);
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldCreateBy, UserInfo.RealName);
                }
                else
                {
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldCreateBy, entity.CreateBy);
                }
                sqlBuilder.SetDBNow(AbandonIpaddressEntity.FieldCreateOn);
                if (UserInfo != null)
                {
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedUserId, UserInfo.Id);
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedBy, UserInfo.RealName);
                }
                sqlBuilder.SetDBNow(AbandonIpaddressEntity.FieldModifiedon);
                if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
                {
                    key = sqlBuilder.EndInsert().ToString();
                }
                else
                {
                    sqlBuilder.EndInsert();
                }
                if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
                {
                    return entity.Id.ToString();
                }
                return key;
            }
    
            /// <summary>
            /// 更新实体
            /// </summary>
            /// <param name="entity">实体</param>
            public int UpdateObject(AbandonIpaddressEntity entity)
            {
                SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
                sqlBuilder.BeginUpdate(this.CurrentTableName);
                this.SetObject(sqlBuilder, entity);
                if (UserInfo != null)
                {
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedUserId, UserInfo.Id);
                    sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedBy, UserInfo.RealName);
                }
                sqlBuilder.SetDBNow(AbandonIpaddressEntity.FieldModifiedon);
                sqlBuilder.SetWhere(this.PrimaryKey, entity.Id);
                return sqlBuilder.EndUpdate();
            }
    
            // 这个是声明扩展方法
            partial void SetObjectExpand(SQLBuilder sqlBuilder, AbandonIpaddressEntity entity);
    
            /// <summary>
            /// 设置实体
            /// </summary>
            /// <param name="entity">实体</param>
            private void SetObject(SQLBuilder sqlBuilder, AbandonIpaddressEntity entity)
            {
                SetObjectExpand(sqlBuilder, entity);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldIpaddresstype, entity.IpAddressType);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldDescription, entity.Description);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldEnabled, entity.Enabled);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldDeletionStateCode, entity.DeletionStateCode);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldIpaddresscontent, entity.IpAddressContent);
            }
    
            /// <summary>
            /// 删除实体
            /// </summary>
            /// <param name="id">主键</param>
            /// <returns>影响行数</returns>
            public int Delete(int id)
            {
                return this.Delete(new KeyValuePair<string, object>(this.PrimaryKey, id));
            }
        }
    View Code

    实体层

        /// <summary>
        /// AbabdonIpaddressEntity
        /// 禁止访问系统的IP数据表
        /// 
        /// 修改纪录
        /// 
        /// 2015-09-24 版本:1.0 SongBiao 创建文件。
        /// 
        /// <author>
        ///     <name>SongBiao</name>
        ///     <date>2015-09-24</date>
        /// </author>
        /// </summary>
        [Serializable]
        public partial class AbandonIpaddressEntity : BaseEntity
        {
            private string ipaddresstype = string.Empty;
            /// <summary>
            /// 类型:Single,Range,Mask
            /// </summary>
            public string IpAddressType
            {
                get
                {
                    return ipaddresstype;
                }
                set
                {
                    ipaddresstype = value;
                }
            }
    
            private DateTime? modifiedOn = null;
            /// <summary>
            /// 修改日期
            /// </summary>
            public DateTime? ModifiedOn
            {
                get
                {
                    return modifiedOn;
                }
                set
                {
                    modifiedOn = value;
                }
            }
    
            private string description = string.Empty;
            /// <summary>
            /// 描述信息
            /// </summary>
            public string Description
            {
                get
                {
                    return description;
                }
                set
                {
                    description = value;
                }
            }
    
            private Decimal enabled;
            /// <summary>
            /// 有效标志
            /// </summary>
            public Decimal Enabled
            {
                get
                {
                    return enabled;
                }
                set
                {
                    enabled = value;
                }
            }
    
            private string modifiedUserId = string.Empty;
            /// <summary>
            /// 修改用户主键
            /// </summary>
            public string ModifiedUserId
            {
                get
                {
                    return modifiedUserId;
                }
                set
                {
                    modifiedUserId = value;
                }
            }
    
            private string id = string.Empty;
            /// <summary>
            /// 主键
            /// </summary>
            public string Id
            {
                get
                {
                    return id;
                }
                set
                {
                    id = value;
                }
            }
    
            private string modifiedBy = string.Empty;
            /// <summary>
            /// 修改用户
            /// </summary>
            public string ModifiedBy
            {
                get
                {
                    return modifiedBy;
                }
                set
                {
                    modifiedBy = value;
                }
            }
    
            private string createBy = string.Empty;
            /// <summary>
            /// 创建用户
            /// </summary>
            public string CreateBy
            {
                get
                {
                    return createBy;
                }
                set
                {
                    createBy = value;
                }
            }
    
            private DateTime? createOn = null;
            /// <summary>
            /// 创建日期
            /// </summary>
            public DateTime? CreateOn
            {
                get
                {
                    return createOn;
                }
                set
                {
                    createOn = value;
                }
            }
    
            private Decimal? deletionStateCode = null;
            /// <summary>
            /// 删除标记
            /// </summary>
            public Decimal? DeletionStateCode
            {
                get
                {
                    return deletionStateCode;
                }
                set
                {
                    deletionStateCode = value;
                }
            }
    
            private string createUserId = string.Empty;
            /// <summary>
            /// 创建用户主键
            /// </summary>
            public string CreateUserId
            {
                get
                {
                    return createUserId;
                }
                set
                {
                    createUserId = value;
                }
            }
    
            private string ipaddresscontent = string.Empty;
            /// <summary>
            /// 具体IP内容 
            /// </summary>
            public string IpAddressContent
            {
                get
                {
                    return ipaddresscontent;
                }
                set
                {
                    ipaddresscontent = value;
                }
            }
    
            /// <summary>
            /// 从数据行读取
            /// </summary>
            /// <param name="dr">数据行</param>
            protected override BaseEntity GetFrom(IDataRow dr)
            {
                GetFromExpand(dr);
                IpAddressType = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldIpaddresstype]);
                modifiedOn = BaseBusinessLogic.ConvertToNullableDateTime(dr[AbandonIpaddressEntity.FieldModifiedon]);
                Description = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldDescription]);
                Enabled = BaseBusinessLogic.ConvertToDecimal(dr[AbandonIpaddressEntity.FieldEnabled]);
                modifiedUserId = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldModifiedUserId]);
                Id = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldId]);
                modifiedBy = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldModifiedBy]);
                createBy = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldCreateBy]);
                createOn = BaseBusinessLogic.ConvertToNullableDateTime(dr[AbandonIpaddressEntity.FieldCreateOn]);
                deletionStateCode = BaseBusinessLogic.ConvertToNullableDecimal(dr[AbandonIpaddressEntity.FieldDeletionStateCode]);
                createUserId = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldCreateUserId]);
                IpAddressContent = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldIpaddresscontent]);
                return this;
            }
    
            ///<summary>
            /// 禁止访问系统的IP数据表
            ///</summary>
            [NonSerialized]
            public static string TableName = "ABANDON_IPADDRESS";
    
            ///<summary>
            /// 类型:Single,Range,Mask
            ///</summary>
            [NonSerialized]
            public static string FieldIpaddresstype = "IPADDRESSTYPE";
    
            ///<summary>
            /// 修改日期
            ///</summary>
            [NonSerialized]
            public static string FieldModifiedon = "ModifiedOn";
    
            ///<summary>
            /// 描述信息
            ///</summary>
            [NonSerialized]
            public static string FieldDescription = "DESCRIPTION";
    
            ///<summary>
            /// 有效标志
            ///</summary>
            [NonSerialized]
            public static string FieldEnabled = "Enabled";
    
            ///<summary>
            /// 修改用户主键
            ///</summary>
            [NonSerialized]
            public static string FieldModifiedUserId = "ModifiedUserId";
    
            ///<summary>
            /// 主键
            ///</summary>
            [NonSerialized]
            public static string FieldId = "Id";
    
            ///<summary>
            /// 修改用户
            ///</summary>
            [NonSerialized]
            public static string FieldModifiedBy = "ModifiedBy";
    
            ///<summary>
            /// 创建用户
            ///</summary>
            [NonSerialized]
            public static string FieldCreateBy = "CreateBy";
    
            ///<summary>
            /// 创建日期
            ///</summary>
            [NonSerialized]
            public static string FieldCreateOn = "CreateOn";
    
            ///<summary>
            /// 删除标记
            ///</summary>
            [NonSerialized]
            public static string FieldDeletionStateCode = "DeletionStateCode";
    
            ///<summary>
            /// 创建用户主键
            ///</summary>
            [NonSerialized]
            public static string FieldCreateUserId = "CreateUserId";
    
            ///<summary>
            /// 具体IP内容 
            ///</summary>
            [NonSerialized]
            public static string FieldIpaddresscontent = "IPADDRESSCONTENT";
        }
    View Code

     

    7、IP限制功能前端展示,可根据自己的需要进行展示,可维护的IP有单个IP,IP段,掩码IP;

     

     

    8、自动添加恶意访问的IP地址,这里给出一个参考,在通用权限底层里有一个恶意访问判断方法(可以拦截攻击者注入恶意代码,可以防御诸如跨站脚本攻击(XSS)、SQL注入攻击等恶意攻击行为。)

            protected void Application_AcquireRequestState(object sender, EventArgs e)
            {
                HttpContext context = HttpContext.Current;
                string putData;
                if (SecretUtil.CookieData(out putData))
                {
                    ResponseWarnMessage(context, "Cookie数据有恶意字符!", putData);
                }
                if (Request.UrlReferrer != null)
                {
                    if (SecretUtil.Referer(out putData))
                    {
                        ResponseWarnMessage(context, "Referrer数据有恶意字符!", putData);
                    }
                }
                if (Request.RequestType.ToUpper() == "POST")
                {
                    if (SecretUtil.PostData(out putData))
                    {
                        ResponseWarnMessage(context, "Post数据有恶意字符!", putData);
                    }
                }
                if (Request.RequestType.ToUpper() == "GET")
                {
                    if (SecretUtil.GetData(out putData))
                    {
                        ResponseWarnMessage(context, "Get数据有恶意字符!", putData);
                    }
                }
            }

    在上面方法判断过程中就可以动态将恶意访问者的IP添加到限制访问列表中。

    9、受限IP表结构

    SQL脚本

    -- Create table
    create table ABANDON_IPADDRESS
    (
      ID                VARCHAR2(40),
      IPADDRESSTYPE     VARCHAR2(50),
      IPADDRESSCONTENT  VARCHAR2(200),
      DESCRIPTION       VARCHAR2(200),
      ENABLED           NUMBER(1) default 1 not null,
      DELETIONSTATECODE NUMBER(1) default 0,
      CREATEUSERID      VARCHAR2(50),
      CREATEBY          VARCHAR2(50),
      CREATEON          DATE,
      MODIFIEDON        DATE,
      MODIFIEDUSERID    VARCHAR2(50),
      MODIFIEDBY        VARCHAR2(50)
    )
    tablespace USERS
      pctfree 10
      initrans 1
      maxtrans 255
      storage
      (
        initial 64K
        next 1M
        minextents 1
        maxextents unlimited
      );
    -- Add comments to the table 
    comment on table ABANDON_IPADDRESS
      is '禁止访问系统的IP数据表';
    -- Add comments to the columns 
    comment on column ABANDON_IPADDRESS.ID
      is '主键';
    comment on column ABANDON_IPADDRESS.IPADDRESSTYPE
      is '类型:Single,Range,Mask';
    comment on column ABANDON_IPADDRESS.IPADDRESSCONTENT
      is '具体IP内容 ';
    comment on column ABANDON_IPADDRESS.DESCRIPTION
      is '描述信息';
    comment on column ABANDON_IPADDRESS.ENABLED
      is '有效标志';
    comment on column ABANDON_IPADDRESS.DELETIONSTATECODE
      is '删除标记';
    comment on column ABANDON_IPADDRESS.CREATEUSERID
      is '创建用户主键';
    comment on column ABANDON_IPADDRESS.CREATEBY
      is '创建用户';
    comment on column ABANDON_IPADDRESS.CREATEON
      is '创建日期';
    comment on column ABANDON_IPADDRESS.MODIFIEDON
      is '修改日期';
    comment on column ABANDON_IPADDRESS.MODIFIEDUSERID
      is '修改用户主键';
    comment on column ABANDON_IPADDRESS.MODIFIEDBY
      is '修改用户';

     

    展开全文
  • Shiro这个Java安全框架我一直都想学会怎么去使用,但每次依照着别人的博客尝试把它配置到自己的项目中,总是出现各种问题,导致一直没有成功。经过不懈努力,这一次终于成功了!从零搭建整个项目,并通过一个简单的...
  • c#实现权限设置

    千次阅读 2019-10-24 20:52:29
    首先思路很重要,只有思路清晰了,才知道怎么实现: (1)要有一个数据表去存放这些才能功能(定为A表),并且重要的是,这些存放在数据表A的菜单ID要和相对应功能窗体的·Tag对应这样在后边进行代码编写的时候...
  • code代表当前按钮功能的代码,在这个项目中用到了layui和vue.js做前端,当你一个用户登录的时候,获取到这个用户的角色类型,然后去数据库连表查询得到这个角色的权限菜单,根据不同的页面传入不同的参数,通过v-h...
  • django实现用户权限

    2019-04-10 22:41:49
    我们经常会有这样的需求,给不同的用户显示不同的页面,这样的功能在Django是怎么实现在的呢? 其实这个逻辑很简单,我们可以先预先设置好几个组,每个组显示的页面都不同,我们可以把用户分配到对应的组里面,具体来说: 第...
  • web方式重置域密码及后台同步domino密码的的权限控制及日志统计前面的文件咱们分别介绍了,...因为作为管理员来说重置密码是家常便饭,但是安全也是必需考虑的,怎么说呢,比如管理员故意找某些用户的问题,重置用...
  • 遇到一个问题,要实现权限管理,也就是有些按钮点击时要提示,没有权限,有很多接口,如果要是按照老的方式,就是每个方法都手写权限判断.十分浪费时间 问题的重要点 重复的工作,如何解决 项目并没有引入shiro之类的模块...
  • 在Admin后台系统有可视化界面可以进行修改,但需要手动进行修改,比较麻烦怎么才能实现在注册的时候自动给用户分配权限呢? 1.超级用户可以看见所有的应用 2.普通用户可以看见超级用户指定的应用(应用1、应用2) ...
  • 【转】MVC自定义AuthorizeAttribute实现权限管理 ... 网站的权限管理是一个很重要的功能,MVC中怎么实现对于网站的权限管理呢。  在MVC中有一个名为AuthorizeAttribute的类,我们可以创建我们自己的特性 Mem...
  • 今天讲一讲 android怎么上传文件到ftp 这个功能比较实用的,因为批量上传文件http post 用上传限制的。(特别是大文件) 1、先说说例子文件结构 2、一个简单的界面 3、例子项目文件 这两个权限是必须的  ”...
  • 这篇文章我想了很久不太知道该怎么去写,因为AOP(面向切面编程)在Android上的实践早有人写过,但可能是出于畏难或不了解其应用场景抑或其他什么原因,大家似乎都对它不太感冒。所以今天我以一些Android上的实例,...
  • 因为,后端管理牵扯到不同工作人员的职责和权限,所以,对于后台管理系统来说,不同的人员登录进入到系统后,看到的菜单(功能)是不一样的,这就是所谓的后台管理系统的权限。 一、后台管理系统的权限怎么弄(前端...
  • 最近一直在重构系统,看到我们原来的代码里,对于数据权限实现居然是在查询语句里写死的。 正感慨这祖传代码怎么这么坑,领导就让我重新设计权限模块。这.... 好吧,反正都在重构代码,直接推翻重来也不算填坑。...
  • 本文实例为大家分享了Android实现拍照和录制视频功能的具体代码,供大家参考,具体内容如下 文档中的Camera 要使用Camera,首先我们先看一下文档中是怎么介绍的。相对于其他绝大多数类,文档对Camera的介绍还是比较...
  • 微信摇一摇功能实现

    千次阅读 2015-01-14 15:36:29
    最近学习了一些微信常见的部分功能,然后觉得摇一摇这个相对来说比较独特的功能来说,其中的编程思想还是挺巧妙的,我们需要的一方面设置好用户权限,一方面要配置好JAVA文件,实例如下: 包名还是老样子,你想怎么...
  • 怎么获得MIUI12系统的root权限

    万次阅读 2019-01-05 16:21:58
    大家都知道,android手机有ROOT权限,一旦手机拥有root相关权限,能够实现更强的功能,打个比方大家部门的营销部门,使用某些营销应用都需要在ROOT权限下执行,如果手机没办法获的root的权限,则不能正常使用具体的...
  • 最近做一个网站想要实现用微博登录,并且自动关注网站官方微博的功能,其实之前我实现过这个功能,但是 忘记了,怎么都想不起来,于是百度了半天,关于这个的介绍很少,于是查看微博开放平台的文档,找了半天找到了...
  • 平日里空了就收集一些权限设置页面或者参考别人是怎么实现权限配置的,其实收集多了也很有意思的,体会体会别人的设计、别人的意图,也是件其乐无穷的事情。  下面我们看看,其中某一个人的权限设置页面如下图: ...
  • 怎么解决的然后这5个每四年减半,创造实例时有朋友建议代码怎么实现.  综上对敏感字段密,#include string.h html LogcatKernel: KernelLinux信息.而是1个hash值范围4.3 LDA模型,内核使用us
  • 上个章节中提到,要在网关层实现统一的认证操作,本篇就直接带你在网关层增加一个公共鉴权功能,来实现简单的认证,采用轻量级解决方案 JWT 的方式来完成。 为什么选 JWT JSON Web Token(缩写 JWT)是比较流行的轻...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 764
精华内容 305
关键字:

权限功能怎么实现