精华内容
下载资源
问答
  • 为了保证Windows系统的安全稳定,很多用户都是使用NTFS文件系统,因此共享文件夹的...下面笔者就以“CCE”共享文件夹为例,介绍如何合理设置“cceuser”用户对“CCE”共享文件夹的访问权限,以此来增强共享文件夹的安全
  • 增强包是一个.iso镜像文件 ,放在VBox安装目录。 2:在VBox设置宿主机和Linux共享的文件夹,并且到虚拟机挂载共享文件夹。之后reboot重启,搞定。 安装增强工具 1:首先导入虚拟光盘 2:两种方式安装这个...

    在VBox中Ubuntu共享文件夹的设置

    前期准备

    1:确保在VBox中的Linux虚拟机已经安装了增强包。增强包是一个.iso镜像文件 ,放在VBox安装目录中。
    2:在VBox中设置宿主机和Linux共享的文件夹,并且到虚拟机中挂载共享文件夹。之后reboot重启,搞定。

    安装增强工具

    1:首先导入虚拟光盘
    2:两种方式安装这个Addition.iso 如下:

    第一种方法
    按照提示一直往后点就行了
    第二种方法:通过命令的方式去安装

    进入/media/用户名/ ←文件夹,就可以看到增强包目录VBox_GAs_5.2.12,cd进入后,执行
    sudo./VBOxLinuxAdditions.run
    等待安装完成。如果成功安装才能进行下一步共享文件夹的设置操作。

    共享文件夹的设置

    首先在宿主机创建一个英文名字的共享文件夹,路径不要有中文。
    D:/share
    然后添加这个文件夹?
    先关闭虚拟机,然后如下操作,然后开启虚拟机就发现文件夹设置完成了。
    在这里插入图片描述

    想用命令挂载的可以去搜索一下其他帖子,但是报的mount erro很烦人,解决方法是直接sudo apt-get update 更新一波,然后sudo apt-get install gcc。

    权限问题:
    共享文件夹添加成功后会发现没有权限进入。
    这个是要把你的当前用户添加到vboxsf用户组中。

    sudo adduser 你当前的用户名 vboxsf
    reboot
    重启后就可以访问共享文件夹了。
    快去尝试一下吧。

    在这里插入图片描述

    展开全文
  • txt文件的每一行都存一张图片的名字(带尾缀),从另一个存有全部图片的文件筛选txt存在的图片。 # -*- coding: UTF-8 -*- # !/usr/bin/env python import sys #导入sys模块 import re #导入re模块 from PIL ...

    txt文件的每一行都存一张图片的名字(带尾缀),从另一个存有全部图片的文件中筛选txt中存在的图片。

    # -*- coding: UTF-8 -*- 
    # !/usr/bin/env python
    import sys    #导入sys模块
    import re     #导入re模块
    from PIL import Image  #PIL是python的第三方图像处理库
    
    sys.path.append('F:\\beifen')   #对于模块和自己写的脚本不在同一个目录下,在脚本开头加sys.path.append(‘引用模块的地址’):
    import numpy as np    
    data = []
    for line in open("F:\\beifen\Main/test1.txt", "r"):  # 设置文件对象并读取每一行文件
        data.append(line)
    for a in data:
        im = Image.open('F:\\beifen\JPEGImages/{}.jpg'.format(a[:-1]))  # 打开改路径下的line3记录的的文件名
        im.save('F:\\beifen\ImageSets\Layout/{}.jpg'.format(a[:-1]))  # 把文件夹中指定的文件名称的图片另存到该路径下
        im.close()
    
     #!/usr/bin/python        #只对 Linux/Unix 用户适用,用来指定本脚本用什么解释器来执行。
                              #有这句的,加上执行权限后,可以直接用 ./ 执行,不然会出错,因为找不到 python 解释器。
                              #这句话是告诉操作系统执行这个脚本的时候,调用 /usr/bin 下的 python 解释器。
                              #相当于写死了 python 路径。
    #!/usr/bin/env python     #这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这       
                              #一行的时候,首先会到 env 设置里查找 python 的安装路径,再调用对应路径下的解释器程序完成操作。
                             #会去环境设置寻找 python 目录,可以增强代码的可移植性,推荐这种写法。
    

    sys模块:包含了与Python解释器和它的环境有关的函数。

    re模块:正则表达式是一个特殊的字符序列,能方便的检查一个字符串是否与某种模式匹配。re模块使得python拥有全部的正则表达式功能。
    通过使用正则表达式,可以:
    测试字符串内的模式。—— 例如,可以测试输入字符串,以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
    替换文本。—— 可以使用正则表达式来识别文档中的特定文本,完全删除该文本或者用其他文本替换它。
    基于模式匹配从字符串中提取子字符串。—— 可以查找文档内或输入域内特定的文本。

    from PIL import Image  # PIL(Python Image Library)是python的第三方图像处理库。
                           # Image类是PIL中的核心类,你有很多种方式来对它进行初始化,
                           #比如从文件中加载一张图像,处理其他形式的图像,或者是从头创造一张图像等。
    
    展开全文
  • 文件夹权限分为可读、可写、管理、没有权限四种。有管理权限则有可读、可写权限。设置了没有权限,则不能设置可读、可写、管理权限。如果不设置没有权限,默认文件夹有可读权限权限设置,只能级往下设置...

           文件夹权限分为可读、可写、管理、没有权限四种。有管理权限则有可读、可写权限。设置了没有权限,则不能设置可读、可写、管理权限。如果不设置没有权限,默认文件夹有可读权限。

           权限设置,只能一级一级往下设置,不能从下往上设置。设置中,不允许出现冲突情况(上级目录没有权限,下级目录有权限)。

           权限是继承的,子目录自动拥有父级目录的权限。

           本目录设置权限前,查询所有下级目录是否设置过权限,如果设置过,则不允许设置权限。

    情形一:目录B角色甲有权限,其他角色没设置过权限。那么下级目录就不允许再设置任何权限,即不允许再给甲设置下级目录没有权限。如果下级某个目录设置甲没有权限那么所有人都看不了该目录,没有意义。

    情形二:目录B设置了甲乙丙三个角色有权限,子目录B1可以设置甲没有权限,可以设置目录B2乙没有权限,那么B2目录的下级目录就不能设置乙有权限。

    情形三:目录B丙没有权限,甲乙有权限。下级目录B1可以设置甲乙没有权限,所有下级目录都不能设置丙有权限。

    实现:

    一、文件目录表结构设计: 

    文件夹目录信息表: 

    CREATE TABLE `disk_file` (
      `id` varchar(50) NOT NULL,
      `createtime` datetime DEFAULT NULL,
      `createuserid` varchar(50) DEFAULT NULL,
      `createusername` varchar(50) DEFAULT NULL,
      `filemd5` varchar(200) DEFAULT NULL,
      `filename` varchar(255) DEFAULT NULL,
      `filesize` bigint(20) NOT NULL,
      `filesuffix` varchar(20) DEFAULT NULL,
      `filetype` int(11) DEFAULT NULL,
      `imgsize` varchar(50) DEFAULT NULL,
      `pid` varchar(50) DEFAULT NULL,
      `thumbnailurl` varchar(200) DEFAULT NULL,
      `typecode` varchar(50) DEFAULT NULL,
      PRIMARY KEY (`id`),
      UNIQUE KEY `UKfjg8ov86e52cc1vw2g4cahpu7` (`createuserid`,`pid`,`filetype`,`filename`),
      KEY `IDX7h8ca5qp48qow851woryvg8q` (`pid`),
      KEY `IDX9j6hnchh4o79nofxhjgy0lc29` (`filename`),
      KEY `IDXlhtq88mi2kvwxihin21rvvm9b` (`typecode`),
      KEY `IDXb244b04v1wu3ftqfqjt7wodks` (`filesuffix`),
      KEY `IDXq0mhp53s6a40gh5w93bqmx5jp` (`filetype`),
      KEY `IDXc7snngp84h66d6f64u0l0hb56` (`createuserid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;
    
    

    文件夹权限数据表: 

    CREATE TABLE `disk_file_folder_privilege` (
      `id` varchar(32) NOT NULL COMMENT '主键',
      `user_id` varchar(32) DEFAULT NULL COMMENT '用户id',
      `role_id` varchar(32) DEFAULT NULL,
      `present_catalog` varchar(32) DEFAULT NULL COMMENT '当前文件夹目录',
      `whole_catalog` varchar(512) DEFAULT NULL COMMENT '完整文件夹目录',
      `readable` char(1) DEFAULT NULL COMMENT '可读:1',
      `writable` char(1) DEFAULT NULL COMMENT '可写:1',
      `manage` char(1) DEFAULT NULL COMMENT '管理:1',
      `no_auth` char(1) DEFAULT NULL COMMENT '没有权限',
      `create_time` varchar(32) DEFAULT NULL,
      `update_time` varchar(32) DEFAULT NULL,
      `creater` varchar(32) DEFAULT NULL,
      `updater` varchar(32) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='文件夹权限';
    
    

    二、保存文件夹目录权限

    import cn.datainvest.common.page.Page;
    import cn.datainvest.common.utils.lang.DateTimeUtil;
    import cn.datainvest.core.constant.Constant;
    import cn.datainvest.core.mapper.BaseGeneratedMapper;
    import cn.datainvest.core.result.ServiceResult;
    import cn.datainvest.core.result.ServiceResultHelper;
    import cn.datainvest.core.service.AbstractBaseAOService;
    import cn.datainvest.dms.system.auth.AuthUtil;
    import cn.datainvest.dms.system.dao.customized.DiskFileFolderPrivilegeCustomizedMapper;
    import cn.datainvest.dms.system.dao.gen.DiskFileFolderPrivilegeGeneratedMapper;
    import cn.datainvest.dms.system.dto.request.DiskFileFolderPrivilegeForm;
    import cn.datainvest.dms.system.dto.request.DiskFileFolderPrivilegeRequest;
    import cn.datainvest.dms.system.entity.customized.DiskFileAO;
    import cn.datainvest.dms.system.entity.customized.DiskFileFolderPrivilegeAO;
    import cn.datainvest.dms.system.entity.customized.UserAO;
    import cn.datainvest.dms.system.entity.gen.DiskFileFolderPrivilegeCriteria;
    import cn.datainvest.dms.system.service.IDiskFileFolderPrivilegeService;
    import cn.datainvest.dms.system.service.IDiskFileService;
    import cn.datainvest.dms.system.service.IRoleService;
    import com.github.pagehelper.PageHelper;
    import com.github.pagehelper.PageInfo;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.util.CollectionUtils;
    import org.springframework.util.StringUtils;
    
    import javax.annotation.Resource;
    import java.util.*;
    
    @Service
    public class DiskFileFolderPrivilegeService extends AbstractBaseAOService<DiskFileFolderPrivilegeAO, DiskFileFolderPrivilegeCriteria> implements IDiskFileFolderPrivilegeService {
    
        @Resource
        private IDiskFileService diskFileService;
    
        @Resource
        private IRoleService roleService;
    
        @Resource
        private DiskFileFolderPrivilegeGeneratedMapper diskFileFolderPrivilegeGeneratedMapper;
    
        @Resource
        private DiskFileFolderPrivilegeCustomizedMapper diskFileFolderPrivilegeCustomizedMapper;
    
        @Override
        protected BaseGeneratedMapper<DiskFileFolderPrivilegeAO, DiskFileFolderPrivilegeCriteria> getGeneratedMapper() {
            return diskFileFolderPrivilegeGeneratedMapper;
        }
    
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> list(DiskFileFolderPrivilegeRequest request) {
            ServiceResult<List<DiskFileFolderPrivilegeAO>> ret = new ServiceResult<>();
            PageHelper.startPage(request.getPageNo(), request.getPageSize());
            List<DiskFileFolderPrivilegeAO> privilegeAOList = diskFileFolderPrivilegeCustomizedMapper.listByCondition(request);
            ret.setData(privilegeAOList);
            ret.setSucceed(true);
            ret.setAdditionalProperties("page", Page.obtainPage(new PageInfo<>(privilegeAOList)));
            return ret;
        }
    
    
        /**
         * 保存文件夹目录权限
         *
         * @param form
         * @return
         */
        @Transactional(rollbackFor = Exception.class)
        @Override
        public ServiceResult<Boolean> save(DiskFileFolderPrivilegeForm form) {
            List<String> roleIds = Arrays.asList(form.getRoleIds());
            if (CollectionUtils.isEmpty(roleIds)) {
                return ServiceResultHelper.genResultWithFaild("角色不能为空", -1);
            }
            if (StringUtils.isEmpty(form.getFileId())) {
                return ServiceResultHelper.genResultWithFaild("请选择文件夹目录", -1);
            }
            DiskFileAO diskFile = diskFileService.selectByPrimaryKey(form.getFileId()).getData();
            if (diskFile == null) {
                return ServiceResultHelper.genResultWithFaild("文件夹目录不存在", -1);
            }
            if (!Constant.INVALID_FLG.equals(diskFile.getFiletype())) {
                return ServiceResultHelper.genResultWithFaild("请选择文件夹目录", -1);
            }
            if (StringUtils.isEmpty(form.getReadable())
                    && StringUtils.isEmpty(form.getWritable())
                    && StringUtils.isEmpty(form.getManage())
                    && StringUtils.isEmpty(form.getNoAuth())) {
                return ServiceResultHelper.genResultWithFaild("请设置文件夹目录权限", -1);
            }
            UserAO user = AuthUtil.getCurrentUser();
            //1.判断是否是设置父级目录权限:子级文件夹目录已经设置过权限则不允许设置
            List<DiskFileAO> childList = diskFileService.listChildNodes(null, form.getFileId());
            if (!CollectionUtils.isEmpty(childList)) {
                for (DiskFileAO file : childList) {
                    List<DiskFileFolderPrivilegeAO> privilegeList = listPrivilegeIn(file.getId(), roleIds).getData();
                    if (!CollectionUtils.isEmpty(privilegeList)) {
                        return ServiceResultHelper.genResultWithFaild("子级文件夹目录已经设置过权限", -1);
                    }
                }
            }
            //2.查询其他角色是否设置过父级权限
            //获取直接父级
            DiskFileAO parent = diskFileService.getParentByChildId(form.getFileId()).getData();
            if (parent != null) {
                boolean hasPrivilege = hasPrivilegeIn(parent.getId(), roleIds);
                // 查询其他角色是否设置过父级目录的权限
                boolean hasPrivilegeOtherRoles = hasPrivilegeOtherRoles(parent.getId(), roleIds);
                //查询所有父级
                List<String> allParent = diskFileService.getAllParent(parent.getId());
                boolean isExist = existParent(allParent, roleIds);
                //如果父级目录配置过权限
                if (isExist) {
                    //并且被配为没有权限,那么子级目录不能配置为有读/写/管理权限
                    if (!hasPrivilege && StringUtils.isEmpty(form.getNoAuth())) {
                        return ServiceResultHelper.genResultWithFaild("父级文件夹目录没有权限,该文件夹目录不能配置读/写/管理权限", -1);
                    }
                    //其他角色没有设置过父级目录权限,并且父级为有权限,下级目录不允许再设置任何权限
                    if (hasPrivilege && !hasPrivilegeOtherRoles) {
                        return ServiceResultHelper.genResultWithFaild("不允许设置该文件夹目录权限", -1);
                    }
                }
            }
            List<DiskFileFolderPrivilegeAO> result = new ArrayList<>();
            for (String roleId : roleIds) {
                DiskFileFolderPrivilegeAO tmp = new DiskFileFolderPrivilegeAO();
                tmp.setRoleId(roleId);
                tmp.setCreater(user.getUserName());
                tmp.setCreateTime(DateTimeUtil.formatDateTime(new Date()));
                tmp.setPresentCatalog(form.getFileId());//当前文件夹目录
                tmp.setNoAuth(form.getNoAuth());
                if (StringUtils.isEmpty(form.getNoAuth())) {
                    tmp.setReadable(Constant.VALID_FLG.toString());
                }
                //设置所选文件夹的可写,管理权限
                if (Constant.VALID_FLG.toString().equals(form.getWritable())) {
                    tmp.setWritable(form.getWritable());
                }
                if (Constant.VALID_FLG.toString().equals(form.getManage())) {
                    tmp.setWritable(Constant.VALID_FLG.toString());
                    tmp.setManage(form.getManage());
                }
                result.add(tmp);
            }
            //先删除之前设置的权限
            deleteByFolderCatalog(form.getFileId(), roleIds);
            //编辑时删除原始数据
            if (!StringUtils.isEmpty(form.getFolderPrivilegeId())) {
                deleteById(form.getFolderPrivilegeId());
            }
            if (!CollectionUtils.isEmpty(result)) {
                insertBatch(result);
            }
            return ServiceResultHelper.genResultWithSuccess();
        }
    
    
        /**
         * 删除已存在的权限,需要比较权限的大小
         * 子级目录不覆盖父级目录的权限
         *
         * @param fileId
         * @return
         */
        public ServiceResult deleteByFolderCatalog(String fileId, List<String> roleIds) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            DiskFileFolderPrivilegeCriteria.Criteria c = criteria.createCriteria();
            if (StringUtils.isEmpty(fileId)) {
                return ServiceResultHelper.genResultWithFaild("文件夹目录不能为空", -1);
            }
    
            c.andRoleIdIn(roleIds);
            c.andPresentCatalogEqualTo(fileId);
            return deleteByCriteria(criteria);
        }
    
    
        /**
         * 查询其他角色是否设置过父级目录的权限
         *
         * @param fileId
         * @param roleIds
         * @return
         */
        public boolean hasPrivilegeOtherRoles(String fileId, List<String> roleIds) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andPresentCatalogEqualTo(fileId).andRoleIdNotIn(roleIds)
                    .andNoAuthIsNull();
            List<DiskFileFolderPrivilegeAO> data = selectByCriteria(criteria).getData();
            if (!CollectionUtils.isEmpty(data)) {
                return true;
            }
            return false;
        }
    
    
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listPrivilegeIn(String fileId,
                                                                              List<String> roleIds) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andPresentCatalogEqualTo(fileId).andRoleIdIn(roleIds);
            return selectByCriteria(criteria);
        }
    
    
        /**
         * 查询没有权限的数据
         *
         * @param roleIds
         * @return
         */
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listNoPrivileges(List<String> roleIds) {
            return ServiceResultHelper.genResultWithSuccess(diskFileFolderPrivilegeCustomizedMapper.listNoPrivileges(roleIds));
        }
    
    
        /**
         * 目录是否有权限
         *
         * @param fileId
         * @param roleIds
         * @return
         */
        public boolean hasPrivilegeIn(String fileId, List<String> roleIds) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andPresentCatalogEqualTo(fileId).andRoleIdIn(roleIds)
                    .andNoAuthIsNull();
            List<DiskFileFolderPrivilegeAO> list = selectByCriteria(criteria).getData();
            if (!CollectionUtils.isEmpty(list)) {
                return true;
            }
            return false;
        }
    
    
        /**
         * 获取目录权限列表
         *
         * @param fileId
         * @param roleIds
         * @return
         */
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listPrivileges(String fileId, List<String> roleIds) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andPresentCatalogEqualTo(fileId).andRoleIdIn(roleIds);
            return selectByCriteria(criteria);
        }
    
    
        /***
         * 是否存在父级目录
         *
         * @param fileIds
         * @param roleIds
         * @return
         */
        public boolean existParent(List<String> fileIds, List<String> roleIds) {
            if (CollectionUtils.isEmpty(fileIds)) {
                return false;
            }
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andPresentCatalogIn(fileIds).andRoleIdIn(roleIds);
            List<DiskFileFolderPrivilegeAO> list = selectByCriteria(criteria).getData();
            if (!CollectionUtils.isEmpty(list)) {
                return true;
            }
            return false;
        }
    
    
        /**
         * 根据角色集合查询文件夹目录权限
         */
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listByRoleId(List<String> roleIds) {
            return ServiceResultHelper.genResultWithSuccess(diskFileFolderPrivilegeCustomizedMapper.listByRoleId(roleIds));
        }
    
    
        /**
         * 查询文件夹目录权限
         */
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listByUserId(String userId) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andUserIdEqualTo(userId);
            return selectByCriteria(criteria);
        }
    
        @Override
        public int insertBatch(List<DiskFileFolderPrivilegeAO> privilegeAOList) {
            return diskFileFolderPrivilegeCustomizedMapper.insertBatch(privilegeAOList);
        }
    
    
        /**
         * 查询目录
         *
         * @param fileId
         * @return
         */
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listRoleFilePrivileges(String fileId,
                                                                                     List<String> roleIds) {
            DiskFileFolderPrivilegeCriteria criteria = new DiskFileFolderPrivilegeCriteria();
            criteria.createCriteria().andPresentCatalogEqualTo(fileId).andRoleIdIn(roleIds);
            return selectByCriteria(criteria);
        }
    
    
        /**
         * 获取文件夹的权限数据
         *
         * @param pid
         * @param roleIds
         * @return
         */
        @Override
        public ServiceResult<List<DiskFileFolderPrivilegeAO>> listFolderPrivileges(String pid, List<String> roleIds) {
            List<DiskFileFolderPrivilegeAO> privilegeList = null;
            List<DiskFileFolderPrivilegeAO> data = listPrivileges(pid, roleIds).getData();
            if (!CollectionUtils.isEmpty(data)) {
                privilegeList = data;
            } else {
                //查询所有父级
                List<String> allParentFileIds = diskFileService.getAllParent(pid);
                Collections.reverse(allParentFileIds);
                if (!CollectionUtils.isEmpty(allParentFileIds)) {
                    for (String parentId : allParentFileIds) {
                        privilegeList = listRoleFilePrivileges(parentId, roleIds).getData();
                        if (!CollectionUtils.isEmpty(privilegeList)) {
                            break;
                        }
                    }
                }
            }
            return ServiceResultHelper.genResultWithSuccess(privilegeList);
        }
    
    
        /**
         * 根据文件夹id获取权限
         *
         * @param fileId
         * @return
         */
        @Override
        public ServiceResult<DiskFileFolderPrivilegeAO> getFolderPrivilegeByFileId(String fileId) {
            UserAO user = AuthUtil.getCurrentUser();
            DiskFileFolderPrivilegeAO result = new DiskFileFolderPrivilegeAO();
            if (user.isSuperAdmin()) {
                result.setPresentCatalog(fileId);
                result.setReadable("1");
                result.setWritable("1");
                result.setManage("1");
            } else {
                List<String> roleIds = roleService.getRoleIdsByUserId(user.getId()).getData();
                boolean readable = false;
                boolean writeable = false;
                boolean manage = false;
                boolean noAuth = false;
                if (CollectionUtils.isEmpty(roleIds)) {
                    return ServiceResultHelper.genResultWithFaild("没有查询到用户的角色信息", -1);
                }
                List<DiskFileFolderPrivilegeAO> privilegeList = listFolderPrivileges(fileId, roleIds).getData();
                if (!CollectionUtils.isEmpty(privilegeList)) {
                    for (DiskFileFolderPrivilegeAO privilege : privilegeList) {
                        if (!readable) {
                            if (!StringUtils.isEmpty(privilege.getReadable())) {
                                readable = true;
                            }
                        }
                        if (!writeable) {
                            if (!StringUtils.isEmpty(privilege.getWritable())) {
                                writeable = true;
                            }
                        }
                        if (!manage) {
                            if (!StringUtils.isEmpty(privilege.getManage())) {
                                manage = true;
                            }
                        }
                        if (!noAuth) {
                            if (!StringUtils.isEmpty(privilege.getNoAuth())) {
                                noAuth = true;
                            }
                        }
                    }
                    result.setPresentCatalog(fileId);
                    result.setReadable(readable ? "1" : null);
                    result.setWritable(writeable ? "1" : null);
                    result.setManage(manage ? "1" : null);
                    result.setNoAuth(noAuth ? "1" : null);
                } else {
                    return ServiceResultHelper.genResultWithSuccess();
                }
            }
            return ServiceResultHelper.genResultWithSuccess(result);
        }
    }
    

    DiskFileService:

    
        /**
         * 根据子级查询父级
         *
         * @param childId 子id
         * @return
         */
        @Override
        public ServiceResult<DiskFileAO> getParentByChildId(String childId) {
            DiskFileAO file = selectByPrimaryKey(childId).getData();
            if (file != null) {
                return selectByPrimaryKey(file.getPid());
            }
            return ServiceResultHelper.genResultWithFaild();
        }
    
    
    
       /**
         * 获取所有父级
         *
         * @param fileId
         * @return
         */
        @Override
        public List<String> getAllParent(String fileId) {
            List<DiskFileAO> fileList = selectByCriteria(null).getData();
            List<DiskFileAO> parentList = new ArrayList<>();
    
            if (!CollectionUtils.isEmpty(fileList)) {
                //查询所有父级
                getAllParentListWithChild(fileList, fileId, fileId, parentList);
            }
    
            List<String> parentFileIds = new ArrayList<>();
            if (!CollectionUtils.isEmpty(parentList)) {
                parentList.stream().forEach(o -> parentFileIds.add(o.getId()));
            }
            return parentFileIds;
        }
    
        /**
         * 根据子级查询所有父级
         *
         * @param allList    所有文件
         * @param childId    子级id
         * @param parentList 最终返回的子级+所有父级的集合
         * @return
         */
        @Override
        public List<DiskFileAO> getAllParentListWithChild(List<DiskFileAO> allList, String childId,
                                                          String notContain, List<DiskFileAO> parentList) {
            if (!CollectionUtils.isEmpty(allList)) {
                for (DiskFileAO resource : allList) {
                    // 判断是否存在父节点
                    if (resource.getId().equals(childId)) {
                        // 递归遍历上一级
                        getAllParentListWithChild(allList, resource.getPid(), notContain, parentList);
                        if (!parentList.contains(resource) && !resource.getId().equals(notContain)) {
                            parentList.add(resource);
                        }
                    }
                }
                return parentList;
            }
            return null;
        }
    
    
        @Override
        public List<DiskFileAO> listChildNodes(DiskFileRequest request, String pid) {
            List<DiskFileAO> fileList = listByCondition(request);
            List<DiskFileAO> childNodes = new ArrayList<>();
            if (!CollectionUtils.isEmpty(fileList)) {
                DiskFileAO parent = null;
                for (DiskFileAO file : fileList) {
                    if (file.getId().equals(pid)) {
                        parent = file;
                        break;
                    }
                }
                //递归获取所有子节点
                if (parent != null) {
                    getAllChildNodes(parent, fileList, childNodes);
                }
            }
            return childNodes;
        }
    
    
        /**
         * 获取某个父节点下面的所有子节点
         *
         * @return
         */
        public static <T extends BaseTreeAO> List<T> getAllChildNodes(T parentNode, List<T> list, List<T> childNodes) {
            for (T node : list) {
                //遍历出父id等于参数的id,add进子节点集合
                if (StringUtils.isNotEmpty(node.getPid()) && node.getPid().equals(parentNode.getId())) {
                    //递归遍历下一级
                    getAllChildNodes(node, list, childNodes);
                    childNodes.add(node);
                }
            }
            return childNodes;
        }
    

    三、根据权限取出文件夹目录

     @Override
        public ServiceResult<List<DiskFileAO>> findPageList(DiskFileRequest request) {
            List<DiskFileAO> fileList = listByParentId(request.getPid(), request.isContainFolder()).getData();
            List<RoleAO> roles = roleService.getRolesByUserName(AuthUtil.getCurrentUser().getUserName()).getData();
            List<String> roleIds = new ArrayList<>();
            List<String> fileIds = new ArrayList<>();
            roles.stream().forEach(o -> roleIds.add(o.getId()));
            fileList.stream().forEach(o -> fileIds.add(o.getId()));
            request.setRoleIds(roleIds);
            request.setFileIds(fileIds);
            ServiceResult<List<DiskFileAO>> ret = new ServiceResult<>();
            PageHelper.startPage(request.getPageNo(), request.getPageSize());
            StringBuilder orderBy=new StringBuilder();
            //order by 排序处理,防止sql注入
            if(!StringUtils.isEmpty(request.getOrderfield())){
                orderBy.append(request.getOrderfield()).append(" ").append(request.getOrdertype());
            }else{
                orderBy.append("createtime").append(" ").append("desc");
            }
            PageHelper.orderBy(orderBy.toString());
            List<DiskFileAO> fileListBeanList = diskFileCustomizedMapper.findAllList(request);
            ret.setData(fileListBeanList);
            ret.setSucceed(true);
            ret.setAdditionalProperties("page", Page.obtainPage(new PageInfo<>(fileListBeanList)));
            return ret;
        }

    mybatis sql配置:

     <select id="findAllList"  resultMap="CustomResultMap"
              parameterType="cn.datainvest.dms.system.dto.request.DiskFileRequest">
          SELECT
                  t2.id,
                  t2.filename,
                  t2.filesize,
                  t2.filetype,
                  t2.filemd5,
                  t2.filesuffix,
                  t2.createtime,
                  t2.pid,
                  t2.typecode,
                  t2.regulation_title,
                  t2.regulation_publish_time,
                  t2.regulation_impl_time, t2.regulation_issue_1, t2.regulation_issue_2, t2.regulation_issue_3,
                  t2.regulation_classify, t2.regulation_file_type, t2.regulation_type, t2.regulation_number, t2.regulation_input_time,
                  t2.regulation_status, t2.regulation_remark,
                  dts.icon AS fileicon
          FROM
          (
            <choose>
                  <when test="isSuperAdmin != null and isSuperAdmin != '' and isSuperAdmin == 'false'">
                      SELECT
                            *
                      FROM
                            disk_file
                      <where>
                          <include refid="fileScopeWhere" />
                          AND id NOT IN
                            (
                              SELECT
                                    present_catalog
                              FROM
                                    `disk_file_folder_privilege`
                              <where>
                                  <if test="roleIds != null and roleIds.size()>0 ">
                                      AND role_id in
                                      <foreach collection="roleIds" item="item" index="index" open="(" separator="," close=")" >
                                          #{item,jdbcType=VARCHAR}
                                      </foreach>
                                  </if>
                                  AND no_auth is not null AND no_auth &lt;&gt; ''
                              </where>
                            )
                      </where>
                  </when>
              <otherwise> <!--超级管理员查看所有-->
                  SELECT
                         *
                  FROM
                        disk_file
                  <where>
                      <if test="isContainFolder == false">
                          AND filetype &lt;&gt; 0
                      </if>
                      <if test="pid != null and pid != '' ">
                          AND pid = #{pid, jdbcType=VARCHAR}
                      </if>
                  </where>
              </otherwise>
            </choose>
          ) t2
          LEFT JOIN
                  disk_type_suffix dts
                  ON dts.suffix = t2.filesuffix
                  AND dts.typecode = t2.typecode
        <where>
            <if test="typecode != null and typecode != '' and typecode != 'all' and typecode != 'ALL' ">
                AND t2.typecode = #{typecode, jdbcType=VARCHAR}
            </if>
            <if test="filesuffix != null and filesuffix != '' ">
                AND t2.filesuffix = #{filesuffix, jdbcType=VARCHAR}
            </if>
            <if test="filename != null and filename != ''">
                AND t2.filename LIKE CONCAT('%', #{filename, jdbcType=VARCHAR},'%')
            </if>
        </where>
      </select>
    

    四、判断文件夹是否有可写、管理权限

    1.上传文件到文件夹时判断有没有可写、管理权限

    @ApiOperation(value = "切块上传", notes = "切块上传")
        @ApiImplicitParams({
                @ApiImplicitParam(name = "file", value = "切块", dataType = "file", paramType = "form", required = true),
        })
        @PostMapping("/uploadChunk")
        @FolderPrivilege(value = {"writable", "manage"}, logical = Logical.OR)
        public Object uploadChunk(@RequestParam("file")MultipartFile file, ChunkPojo chunkPojo) throws Exception {
            UserAO user = AuthUtil.getCurrentUser();
            //判断切块是否为空
            if (file == null) {
                return ServiceResultHelper.genResultWithFaild("切块不能为空", -1);
            }
            //参数设置
            Chunk chunk = new Chunk();
            BeanUtils.copyProperties(chunkPojo, chunk);
            chunk.setUserid(user.getId());
            chunk.setUsername(user.getUserName());
            chunk.setBytes(file.getBytes());
            //4.调用切块上传接口
            return diskFileService.uploadChunk(chunk);
        }
    

    使用注解方式: 

    package cn.datainvest.dms.system.folderPrivilege;
    
    import org.apache.shiro.authz.annotation.Logical;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface FolderPrivilege {
        String[] value();
    
        Logical logical() default Logical.AND;
    }
    

     aop获取文件夹权限并从注解中获取权限验证:

    package cn.datainvest.dms.system.folderPrivilege;
    
    import cn.datainvest.common.exception.BaseException;
    import cn.datainvest.dms.system.auth.AuthUtil;
    import cn.datainvest.dms.system.entity.customized.DiskFileFolderPrivilegeAO;
    import cn.datainvest.dms.system.entity.customized.UserAO;
    import cn.datainvest.dms.system.service.IDiskFileFolderPrivilegeService;
    import cn.datainvest.dms.system.service.IDiskFileService;
    import cn.datainvest.dms.system.service.IRoleService;
    import org.apache.shiro.authz.annotation.Logical;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    import org.springframework.util.StringUtils;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletRequest;
    import java.util.List;
    
    /**
     * @author yangfeng
     * @date 2019年9月10日
     */
    @Aspect
    @Component
    public class FolderPrivilegeAspect {
    
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        @Resource
        private IDiskFileService diskFileService;
    
        @Resource
        private IRoleService roleService;
    
        @Resource
        private IDiskFileFolderPrivilegeService diskFileFolderPrivilegeService;
    
        public FolderPrivilegeAspect() {
        }
    
        /**
         * 定义切入点对象表达式 execution
         * 注解参数 logOperation
         */
        private static final String pointCutExpression = "execution(@FolderPrivilege * *(..)) && @annotation(folderPrivilege)";
    
        /**
         * 切入点声明
         *
         * @param folderPrivilege
         */
        @Pointcut(pointCutExpression)
        public void handlePointCut(FolderPrivilege folderPrivilege) {
        }
    
        /**
         * Before 增强。对handlePointCut进行before增强
         *
         * @param joinPoint       被通知的对象的对象、参数。。。
         * @param folderPrivilege 注解参数提取action Name
         */
        @Before(value = "handlePointCut(folderPrivilege)")
        public void handleBefore(JoinPoint joinPoint, FolderPrivilege folderPrivilege) {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            if (request != null) {
                String[] privileges = folderPrivilege.value();
                Logical logical = folderPrivilege.logical();
                String pid = request.getParameter("pid");
                UserAO user = AuthUtil.getCurrentUser();
                if (!user.isSuperAdmin()) {
                    boolean privileged = false;
                    if (!StringUtils.isEmpty(pid)) {
                        List<String> roleIds = roleService.getRoleIdsByUserId(user.getId()).getData();
    
                        //获取文件夹的权限数据
                        List<DiskFileFolderPrivilegeAO> privilegeList = diskFileFolderPrivilegeService.listFolderPrivileges(pid, roleIds).getData();
    
                        if (!CollectionUtils.isEmpty(privilegeList)) {
                            for (DiskFileFolderPrivilegeAO privilege : privilegeList) {
                                if (privileges != null && privileges.length > 0) {
                                    if (logical == null) {
                                        if (FolderPrivilegeType.WRITABLE.getCode().equals(privileges[0])
                                                && !StringUtils.isEmpty(privilege.getWritable())) {
                                            privileged = true;
                                            break;
                                        } else if (FolderPrivilegeType.MANAGE.getCode().equals(privileges[0])
                                                && !StringUtils.isEmpty(privilege.getManage())) {
                                            privileged = true;
                                            break;
                                        }
                                    } else if (Logical.OR.equals(logical)) {
                                        for (String p : privileges) {
                                            if (FolderPrivilegeType.WRITABLE.getCode().equals(p)
                                                    && !StringUtils.isEmpty(privilege.getWritable())) {
                                                privileged = true;
                                                break;
                                            }
                                            if (FolderPrivilegeType.MANAGE.getCode().equals(p)
                                                    && !StringUtils.isEmpty(privilege.getManage())) {
                                                privileged = true;
                                                break;
                                            }
                                        }
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    if (!privileged) {
                        throw new BaseException(-1, "没有操作权限");
                    }
                }
            }
        }
    
    
    }
    
    

    2.删除文件或文件夹时判断有没有管理权限

    
        /**
         * 检查文件是否有管理权限
         *
         * @param ids 文件id
         */
        public void checkManagePrivilege(List<String> ids) {
            UserAO user = AuthUtil.getCurrentUser();
            List<String> roleIds = roleService.getRoleIdsByUserId(user.getId()).getData();
            if (CollectionUtils.isEmpty(roleIds)) {
                throw new BaseException(-1, "没有查询到用户的角色信息");
            }
            if (!CollectionUtils.isEmpty(ids)) {
                for (String id : ids) {
                    List<DiskFileFolderPrivilegeAO> privilegeList = diskFileFolderPrivilegeService
                            .listFolderPrivileges(id, roleIds).getData();
                    DiskFileAO file = selectByPrimaryKey(id).getData();
                    if (file != null) {
                        if (!hasManagePrivilege(privilegeList)) {
                            throw new BaseException(-1, file.getFilename() + ":没有删除权限");
                        }
                    }
                }
            }
        }
    
    
        /**
         * 是否有管理权限
         *
         * @param privilegeList
         * @return
         */
        public boolean hasManagePrivilege(List<DiskFileFolderPrivilegeAO> privilegeList) {
            boolean result = false;
            if (!CollectionUtils.isEmpty(privilegeList)) {
                for (DiskFileFolderPrivilegeAO privilege : privilegeList) {
                    if (!StringUtils.isEmpty(privilege.getManage())) {
                        result = true;
                        break;
                    }
                }
            }
            return result;
        }

       至此,文件夹权限保存,根据权限获取文件夹,判断文件夹可写、管理权限完成。

    展开全文
  • 为大家分享全新的ImageRanger Pro Edition for Mac,这是款专业的图片管理软件,ImageRanger mac版可以轻松帮助用户组织和管理Mac上的所有图片,另外ImageRanger图片管理软件还支持快速查找和删除重复项、裁剪、...

    为大家分享全新的ImageRanger Pro Edition for Mac,这是一款专业的图片管理软件,ImageRanger mac版可以轻松帮助用户组织和管理Mac上的所有图片,另外ImageRanger图片管理软件还支持快速查找和删除重复项、裁剪、手动排序、调整图片大小、打印等实用的功能,喜欢这款ImageRanger Pro Edition mac版的朋友赶紧来试试吧!

    6aa4526baf113f5e0022fc3fe1486e1b.png

    ImageRanger Pro Edition for mac官方介绍

    ImageRanger是一个用于管理本地照片集的强大工具。用户界面旨在帮助您以最少的点击次数执行常规照片组织任务。没有更多耗时的复制和粘贴,现在大多数任务只需一两次点击即可完成。

    ImageRanger支持各种图像数据格式,包括尼康,佳能和富士相机的RAW文件。

    使用ImageRanger,您可以收集有关存储在硬盘驱动器上的所有图像的信息。

    您可以轻松管理数千张照片,查找和删除重复文件,或自动组织新文件夹结构中的照片。

    8597e766109e8647e456e6a2a049c36c.png

    https://mac.orsoon.com/Mac/169048.html

    imageranger mac版功能特色

    轻松管理您的100K照片。
    ImageRanger会为您的Mac或存储驱动器上的照片编制索引,以便您可以:
    · 快速加载数千张图片
    · 查找肖像,面孔
    · 排序和过滤
    · 查找重复项和删除副本
    · 按年份,位置组织文件夹
    · 裁剪,快速调整大小
    · 手动对多个文件夹中的集合进行排序
    · 从其他插图中排序图像,剪贴画
    · 寻找低质量的图像,提高图像对比度
    · 执行一般照片管理任务
    · 打印数百张照片

    7165c4439aa7a71e3a15c963b6fa849e.png

    NAS和USB驱动器支持
    ImageRanger可以索引NAS和存储驱动器上的数据。这样,您可以在收藏中轻松找到重要的照片。

    内置人脸识别
    在您的照片上标记朋友和家人一次,以帮助自动面部识别以便稍后再次找到它们。

    排序和过滤很容易
    您可以通过多种方式对图像进行排序和过滤。创建手动排序的幻灯片,按内容,面孔,评级等进行过滤。

    亮度。对比。锐度。
    自动更正您的图像
    使用ImageRanger,可以一次将自动增强功能应用于多个图像。手动微调可以选择图像的暗区或亮区,并应用各种校正设置。
    所有必要的编辑控件(亮度,对比度,清晰度,饱和度)都是在用户友好的界面中设计的,具有UNDO功能,可以随时纠正任何不幸事件。
    您甚至可以让ImageRanger自动查找和分类所有质量较差的图像,以方便您使用。对于高级用户,强大的批处理功能允许在处理仅相关照片时对整个文件夹执行工作。

    f50c03a17874bde6cb5eba374d088e10.png

    图像索引
    ImageRanger只需要遍历您的照片集一次,您可以随时搜索,排序和过滤图像。

    人脸识别
    ImageRanger甚至可以在大人物肖像和照片集中检测面部,让您标记面部并快速查找特定人物的图像。

    NAS和USB驱动器支持
    ImageRanger索引可以直接记录在远程文件夹中。这样,您就可以使用以前构建的索引在任何其他计算机上快速搜索和排序照片。

    重复删除
    ImageRanger向您显示重复图像的数量,并允许您删除多余的内容。

    手动排序
    在浏览图像时排除或仅包含您需要的文件夹。或者,ImageRanger可以读取整个存储驱动器。

    安排到文件夹
    可选择将所有照片导入新的文件夹结构,按捕获时间和位置进行组织。

    集合
    保存并加载以前找到的图像集,以确保通过手动排序快速恢复重要的幻灯片。

    GPS过滤
    通过内置GPS位置,您的图像将自动按捕获的城市进行排序。你可以找到距离地球上任何一点5米的所有照片。

    展开全文
  • 修改文件或文件夹所有者:takeown 修改文件或文件夹的NTFS权限:cacls 修改文件或文件夹的NTFS权限加强版:xcacls 这命令需 要下载 转载于:https://blog.51cto.com/zhcxl/726739...
  • DOS修改文件夹权限

    2009-07-18 09:52:00
    这是一个在Windows 2000/XP/Server 2003操作系统下都可以使用的命令,作用是显示或者修改文件的访问控制表,在命令可以使用通配符指定多个文件,也可以在命令指定多个用户。命令语法 如下: Cacls filename [/...
  • 上一节学习了文件的权限,这节课主要学习Linux文件夹权限,它们是不一样的。 1、文件夹的三种权限:r、w、x r --可以ls x --可以cd rx --可以cd ls wx --可以cd touch rm vi(other self files) wxt --可以cd...
  • 最近打算自己编译一下FFmpeg,于是装了Ubantu虚拟机,打算把Window10上的文件夹共享Ubantu,顿操作后发现木有权限[/丑大了]!!!这怎么忍!! 解决 网上顿找,发现解决办法如下:(如果你想看原文,点这里...
  • 我们可以在这里为不同级别的用户设置相应的访问控制权限,包括完全控制、修改、读取和运行、列出文件夹目录、读取、写入、特别的权限等,你只需要在 “允许”和“拒绝”下简单勾选即可,点击“高级”按钮还可以设置...
  • 细心的你会发现居然夹有权限运行。例如: drwxrwxr-x 11 cl cl 4096 9 25 14:22 ./ drwxr-xr-x 49 cl cl 4096 10月 10 16:00 ../ drwxrwxr-x 5 cl cl 4096 9月 23 10:58 algorithm/ drwxrwxr-x 2 cl cl 40...
  • 下面笔者就以“CCE”共享文件夹为例,介绍如何合理设置“cceuser”用户对“CCE”共享文件夹的访问权限,以此来增强共享文件夹的安全。 1. 共享权限设置 在资源管理器,右键点击“CCE”共享文件夹,选择
  • 初写随笔,如有不对请高手多指点 ...方法 调用命令行实现创建本地用户和指定权限 1.创建本地用户 语法: net user [UserName [Password | *] [options] [/domain] net user [UserName {Passwor...
  • 1、打开虚拟机的 Ubuntu 系统; 2、安装“增强工具” 设备 -> 安装增强工具 3、设置“共享文件夹” 控制 -> 设置 -> 添加共享文件夹 ->选择“共享文件夹路径”,设置“共享文件夹名称”, ...
  • 文件及文件夹设置密码

    千次阅读 2013-07-30 15:16:51
    如果要不用任何软件来对文件夹进行加密,方法也很多啊,我这里向你介绍种吧 1.进入要进行加密保护的文件夹中,在空白处单击鼠标右键,选择“自定义文件夹...”选项 2.单击“下一步”选择“自定义”并在复选框...
  • 设置共享文件夹之后,windows和linux上的文件互传十分方便。 当然了,网上有很多这样的教程。 但是昨天老师上课讲了种,个人感觉十分方便。 之后,在设置里面,添加共享文件夹,如下图:勾选自动挂载。 然后...
  • 一、Cacls.exe命令的使用这是一个在Windows 2000/XP/Server 2003操作系统下都可以使用的命令,作用是显示或者修改文件的访问控制表,在命令可以使用通配符指定多个文件,也可以在命令指定多个用户。命令语法如下...
  • 粘贴有用,但是无法访问共享文件夹,且启动时会有报错条目,界面无法自适应,永远是固定大小,你可能会看到以下报错信息。 例如: VBoxClient: Failed to get display change request, rc=VERR_IO_BAD_LENGTH 或是...
  • 最近因为虚拟机系统崩掉了,重新搭建了新的系统,发现复制共享文件夹后总是提示权限不够的问题,还引发了新的问题,导致/etc/profile 以及.bashrc设置的环境变量在该目录下每次新开终端都需要source,弄得很心烦。...
  • 这是一个在Windows 2000/XP/Server 2003操作系统下都可以使用的命令,作用是显示或者修改文件的访问控制表,在命令可以使用通配符指定多个文件,也可以在命令指定多个用户。命令语法 如下: Cacls filename [/...
  • 在虚拟机窗口的菜单选择“设备 – 安装增强功能…”之后,打开文件管理器,在左侧可以看到 VBOXADDITIONS_5.0.18_106667,点击它,就能显示出增强功能的安装文件。这些文件的路径其实为 /media/cdrom0。打开终端,...
  • C# Winform对文件夹权限判断及处理

    千次阅读 2016-07-14 17:53:51
    我们可以看到这个配置一个 requestedExecutionLevel 项,这个项用于配置当前应用请求的执行权限级别。这个项有3个值可供选择,如下表所示:   Value Description Comment ...
  • 越来越多的用户开始选择NTFS文件系统,NTFS的好处自然是大大增强了系统的安全性,在“安全”标签页下,我们可以在这里为不同级别的用户设置相应的访问控制权限,包括完全控制、修改、读取和运行、列出文件夹目录、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,546
精华内容 11,018
关键字:

给一个文件夹中所有子文件夹增强权限