业务层、数据权限、数据事务、通用基类、分页逻辑

// 最后一个参数是 bizScope，指定的 office_user 对应角色里选择的业务范围字典编码
SqlMap sqlMap = empUser.getSqlMap(); // v5.3.0 之前版本
SqlMap sqlMap = empUser.sqlMap(); // v5.3.0+ 及之后版本
sqlMap.getDataScope().addFilter("dsfOffice",
	"Office", "e.office_code", "a.create_by", ctrlPermi, "office_user");

// 可查看哪些部门数据，第二个参数：指定菜单中的 “权限标识” 
sqlMap.getDataScope().addFilterByPermission("dsfOffice", "sys:empUser:view",
        "Office", "e.office_code", "a.create_by", ctrlPermi);
// 可查看哪些用户数据，第二个参数：指定菜单中的 “权限标识” 
sqlMap.getDataScope().addFilterByPermission("dsfOffice", "sys:empUser:view",
        "User", "a.user_code", ctrlPermi);

/**
 * 添加数据权限过滤条件
 */
public void addDataScopeFilter(T entity){
	SqlMap sqlMap = entity.getSqlMap(); // v5.3.0 之前版本
	SqlMap sqlMap = entity.sqlMap();    // v5.3.0+ 及之后版本

	// 举例1：公司数据权限过滤，v5.11.0及以前版本，需在实体类@Table注解添加extWhereKeys="dsf"
	sqlMap.getDataScope().addFilter("dsf", "Company",
			"a.company_code", DataScope.CTRL_PERMI_HAVE);

	// 举例2：部门数据权限过滤，v5.11.0及以前版本，需在实体类@Table注解添加extWhereKeys="dsf"
	sqlMap.getDataScope().addFilter("dsf", "Office",
			"a.office_code", DataScope.CTRL_PERMI_HAVE);

	// 举例3：角色数据权限过滤，v5.11.0及以前版本，需在实体类@Table注解添加extWhereKeys="dsf"
	sqlMap.getDataScope().addFilter("dsf", "Role",
			"a.role_code", DataScope.CTRL_PERMI_HAVE);

	// 举例4：用户、员工（自己创建的）数据权限根据部门过滤，v5.11.0及以前版本，需在实体类@Table注解添加extWhereKeys="dsfOffice"
	sqlMap.getDataScope().addFilter("dsfOffice", "Office", 
			"e.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);

	// 举例5：用户、员工（自己创建的）数据权限根据公司过滤，v5.11.0及以前版本，需在实体类@Table注解添加extWhereKeys="dsfCompany"
	sqlMap.getDataScope().addFilter("dsfCompany", "Company", 
			"e.company_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);
	
}

@RequiresPermissions("user")
@RequestMapping(value = "listData")
@ResponseBody
public Page<EmpUser> listData(EmpUser empUser, HttpServletRequest request, HttpServletResponse response) {
	empUser.setPage(new Page<>(request, response));
	empUserService.addDataScopeFilter(empUser); 	// 调用数据权限过滤方法（重点）
	Page<EmpUser> page = empUserService.findPage(empUser);
	return page;
}

public void addDataScopeFilter(T entity){
	SqlMap sqlMap = entity.getSqlMap(); // v5.3.0 之前版本
	SqlMap sqlMap = entity.sqlMap();    // v5.3.0+ 及之后版本

	// 添加数据权限过滤条件
	sqlMap.getDataScope().addFilter("dsfOffice", "Office", 
			"e.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);

	// 添加自定义权限过滤条件（或者包含所有的部门经理）
	sqlMap.getDataScope().addFilter("dsfOffice",
		"EXISTS (SELECT 1 FROM js_sys_user_role WHERE user_code=a.user_code and role_code='dept')");
		
	// 若不需要此数据权限了，也可以进行根据 key 进行清理权限数据
	sqlMap.getDataScope().clearFilter("dsfOffice");

}

public void addDataScopeFilter(T entity){
	SqlMap sqlMap = entity.getSqlMap(); // v5.3.0 之前版本
	SqlMap sqlMap = entity.sqlMap();    // v5.3.0+ 及之后版本

	// 添加数据权限过滤条件
	sqlMap.getDataScope().apiMode().addFilter("dsfOffice", "Office", 
			"e.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);

}

/**
 * 添加到数据范围过滤条件
 * @param mapKey 数据权限的唯一标识（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）
 *      注：v5.11.0 及以前版本它是 sqlMap 的键值，举例：如设置 “dsf” 数据范围过滤，则：<br>
 * 		    EXISTS 方式对应：sqlMap.dsf；在 @Table 的 extWhereKeys=“dsf” 中引用<br>
 * 	        JOIN 方式（加Form和Where后缀）对应：sqlMap.dsfFrom 和 sqlMap.dsfWhere
 * @param user 用户对象 userCode、roleList（roleCode、dataScope、bizScope）
 * @param roleList 角色列表 roleCode、dataScope、bizScope v5.10.1
 * @param ctrlTypes 控制类型，多个用“,”隔开，多个是“or”关系，举例：<br>
 *		控制角色（根据角色过滤数据权限）：Role<br>
 *		控制部门（根据部门过滤数据权限）：Office<br>
 *		控制公司（根据公司过滤数据权限）：Company<br>
 *		控制用户（根据用户过滤数据权限）：User<br>
 *	    控制更多自定义类型，可在 role.extendDataScopes 中 自定义
 * @param bizCtrlDataFields 业务表对应过滤表别名和加权字段，多个使用“,”分隔。<br>
 * 		长度必须与 ctrlTypes 保持一致，举例：<br>
 * 		业务表控制角色：a.role_code<br>
 * 		业务表控制部门：a.office_code<br>
 * 		业务表控制公司：a.company_code<br>
 * 	    更多过滤数据字段，根据你的业务表字段填写参数
 * @param bizCtrlUserField 业务表对应过滤表别名和用户字段，用于过滤只可以查看本人数据。<br>
 * 		不设置的话，如果没有范围权限，则查不到任何数据，举例：<br>
 * 		业务表：a.create_by<br>
 * 	    更多用户过滤数据字段，根据你的业务表字段填写参数
 * @param ctrlPermi 拥有的数据权限：DataScope.CTRL_PERMI_HAVE、可管理的数据权限：DataScope.CTRL_PERMI_HAVE
 * @param bizScope 业务范围（根据指定的 bizScope 过滤角色的数据范围配置），多个用“,”隔开  v4.1.6
 * @param apiMode 是否 API 方式实现（适应 Cloud 环境，基础用户表与业务数据表跨库的情况）v5.11.1+ 版本已移除，
 *                使用函数替代，如：empUser.sqlMap().apiMode().getDataScope().addFilter("dsf", ...);
 * @see ## // 示例：<br>
 * 	1）在Service中调用如下两种方式：<br>
 * 		// 添加数据权限过滤条件（控制角色，查询有权的角色数据）<br>
 * 		entity.sqlMap().getDataScope().addFilter("dsf", "Role", <br>
 * 	 			"a.role_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 		// 添加数据权限过滤条件（控制部门，查询有权的部门数据）<br>
 * 		entity.sqlMap().getDataScope().addFilter("dsf", "Office", <br>
 * 				"a.office_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 		// 添加数据权限过滤条件（控制公司，查询有权的公司数据）<br>
 * 		entity.sqlMap().getDataScope().addFilter("dsf", "Company", <br>
 * 				"a.company_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 		// 添加数据权限过滤条件（如果没有部门权限，则控制当前用户）<br>
 * 		entity.sqlMap().getDataScope().addFilter("dsf", "Office", <br>
 * 				"a.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);<br>
 * 		// 添加数据权限过滤条件（控制用户，只查询指定的用户数据）<br>
 * 		entity.sqlMap().getDataScope().addFilter("dsf", "User", <br>
 * 				"a.user_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 	2）v5.11.1+ 及以后版本，可省略 a) 和 b) 的步骤，新版本会自动追到对于 SQL 语句中。
 * 		a）在 \@Table 注解中调用如下：（注意 dsf 您可以随意命名，只要与 mapKey 参数名称匹配即可）<br>
 * 			采用 EXISTS 或 API 方式调用   ： \@Table(extWhereKeys="dsf")<br>
 * 			采用 JOIN 方式调用（加Form和Where后缀） ： \@Table(extFromKeys="dsfFrom", extWhereKeys="dsfWhere")
 * 		b）MyBatis Mapper 中调用如下两种方式：<br>
 * 			采用 EXISTS 或 API 方式调用   ： 将  ${sqlMap.dsf} 放在Where语句里<br>
 * 			采用 JOIN 方式调用（加Form和Where后缀）： 将  ${sqlMap.dsfFrom} 放在From后 ，将  ${sqlMap.dsfWhere} 放在Where语句里
 */
public QueryDataScope addFilter(String mapKey, User user, List<Role> roleList, String ctrlTypes,
			String bizCtrlDataFields, String bizCtrlUserField, String ctrlPermi, String bizScope);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 */
public QueryDataScope addFilter(String mapKey, String ctrlTypes,
        String bizCtrlDataFields, String ctrlPermi);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：控制用户字段
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 */
public QueryDataScope addFilter(String mapKey, String ctrlTypes,
        String bizCtrlDataFields, String bizCtrlUserField, String ctrlPermi);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：控制用户字段、业务范围
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 */
public QueryDataScope addFilter(String mapKey, String ctrlTypes, String bizCtrlDataFields, 
        String bizCtrlUserField, String ctrlPermi, String bizScope);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：用户对象、控制用户字段、业务范围
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 */
public QueryDataScope addFilter(String mapKey, User user, String ctrlTypes, String bizCtrlDataFields,
        String bizCtrlUserField, String ctrlPermi, String bizScope);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）v5.11.0
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 * @param permission 菜单权限标识（根据菜单中指定的权限标识，查询菜单关联的数据权限配置进行生成SQL）
 */
public QueryDataScope addFilterByPermission(String mapKey, String permission) {

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：菜单权限标识 v5.10.1
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 * @param permission 菜单权限标识（根据菜单中指定的权限标识，查询菜单关联的数据权限配置进行生成SQL）
 */
public QueryDataScope addFilterByPermission(String mapKey, String permission, String ctrlTypes,
        String bizCtrlDataFields, String ctrlPermi);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：菜单权限标识、控制用户字段 v5.10.1
 * 详见：{@link QueryDataScope#addFilterByPermission(String, User, List, String, String, String, String, String)}
 * @param permission 菜单权限标识（根据菜单中指定的权限标识，查询菜单关联的数据权限配置进行生成SQL）
 */
public QueryDataScope addFilterByPermission(String mapKey, String permission, String ctrlTypes, String bizCtrlDataFields,
        String bizCtrlUserField, String ctrlPermi);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：用户对象、菜单权限标识、控制用户字段 v5.10.1
 * 详见：{@link QueryDataScope#addFilterByPermission(String, User, List, String, String, String, String, String)}
 * @param permission 菜单权限标识（根据菜单中指定的权限标识，查询菜单关联的数据权限配置进行生成SQL）
 */
public QueryDataScope addFilterByPermission(String mapKey, User user, String permission, String ctrlTypes, String bizCtrlDataFields,
        String bizCtrlUserField, String ctrlPermi);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）加：用户对象、角色列表、菜单权限标识、控制用户字段 v5.10.1
 * 详见：{@link QueryDataScope#addFilter(String, User, List, String, String, String, String, String)}
 * @param permission 菜单权限标识（根据菜单中指定的权限标识，查询菜单关联的数据权限配置进行生成SQL）
 */
public QueryDataScope addFilterByPermission(String mapKey, User user, List<Role> roleList, String permission, String ctrlTypes, String bizCtrlDataFields,
			String bizCtrlUserField, String ctrlPermi);

/**
 * 添加到数据范围过滤条件（如果之前 mapKey 已经存在，则使用 OR 增加到该条件）
 * @param mapKey sqlMap的键值，举例：如设置“dsf”数据范围过滤，则：exists方式对应：sqlMap.dsf
 * @param sqlWhere 具体的Where子句。
 */
public QueryDataScope addFilter(String mapKey, String sqlWhere);

/**
 * 清理数据范围过滤条件
 * @param mapKey 要清理的数据过滤条件
 */
public QueryDataScope clearFilter(String mapKey);

/**
 * 启用 debug 模式，打印生成的权限 SQL v5.11.1+
 */
public QueryDataScope debug();

/**
 * 启用 apiMode 模式，使用 IN 方式过滤基础数据 v5.11.1+
 */
public QueryDataScope apiMode();

/**
 * 启用 joinMode 模式，使用联表方式，追加到 FROM 和 WHERE 后面 v5.11.1+
 */
public QueryDataScope joinMode();

/**
 * 启用角色自定义 SQL 开关，更宽松的权限过滤，但要严格控制角色管理接口权限，防止 SQL 注入 v5.11.1+
 */
public QueryDataScope ruleSql();

/**
 * 仅适用于 SqlServer，表后增加 WITH(NOLOCK) 用来读取锁表并未提交的数据数据 v5.11.1+
 */
public QueryDataScope nolock();

@Transactional(rollbackFor=CustomException.class)

try{ 
	// 出现异常
} catch (Exception e) {
	e.printStackTrace();
	// 抛出异常，使得事务回滚
	throw new RuntimeException(e);
}
// ======== 或者 ========
try{ 
	// 出现异常
} catch (Exception e) {
	e.printStackTrace();
	// 手动通知事务回滚
	TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

// 设置回滚点：
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
// 回滚到 savePoint 指定位置：
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);

@Autowired
private PlatformTransactionManager platformTransactionManager;
@Autowired
private TransactionDefinition transactionDefinition;
// 编程式事务
public void transTest(Long orderId) {
	// 开启事务
	TransactionStatus transaction = platformTransactionManager.getTransaction(transactionDefinition);
	try {
		
		// 业务处理代码，此处省略...

		// 提交事务
		platformTransactionManager.commit(transaction);
	} catch (Exception e) {
		// 回滚事务
		platformTransactionManager.rollback(transaction);
	}
}

@Controller
@RequestMapping(value = "${adminPath}/test/testData")
public class TestDataController extends BaseController {
	
	@Idempotent // 启用幂等验证，参数详见 API
	@PostMapping(value = "save")
	@ResponseBody
	public String save(@Validated TestData testData) {
		testDataService.save(testData);
		return renderResult(Global.TRUE, text("保存成功"));
	}
}

/**
 * 幂等注解
 * @author ThinkGem
 */
public @interface Idempotent {

	/**
	 * 幂等操作的唯一标识，使用 ReflectUtils 获取 BaseEntity 指定的 get 方法<br>
	 * 如果没有明确指定 key 参数，则获取 BaseEntity 的 JSON MD5 作为 Key<br>
	 * 如果没有 BaseEntity 参数，则获取所有参数的 JSON MD5 作为 Key
	 */
	String key() default "";

    /**
     * 间隔时间（单位秒）小于此时间视为频繁提交
     */
    int seconds() default 10;

    /**
     * 提示错误消息
     */
    String message() default "请不要频繁操作";

	/**
	 * 完成业务后是否移除 key（默认超时后自动移除）
	 */
	boolean removeKey() default false;
}

/**
 * 新建实体对象
 * @return
 */
protected T newEntity();

/**
 * 新建实体对象（带一个String构造参数）
 * @return
 */
protected T newEntity(String id);

/**
 * 获取单条数据
 * @param id 主键
 * @return
 */
public T get(String id);

/**
 * 获取单条数据
 * @param entity
 * @return
 */
public T get(T entity);

/**
 * 获取单条数据，如果获取不到，则实例化一个空实体
 * @param id 主键编号
 * @param isNewRecord 如果是新记录，则验证主键编号是否存在。
 * 					     如果存在抛出ValidationException异常。
 * @return
 */
public T get(String id, boolean isNewRecord);

/**
 * 获取单条数据，如果获取不到，则实例化一个空实体（多个主键情况下调用）
 * @param pkClass 主键类型数组
 * @param pkValue 主键数据值数组
 * @param isNewRecord 如果是新记录，则验证主键编号是否存在。
 * 					     如果存在抛出ValidationException异常。
 * @return
 */
public T get(Class<?>[] pkClass, Object[] pkValue, boolean isNewRecord);

/**
 * 列表查询数据
 * @param entity
 * @return
 */
public List<T> findList(T entity);

/**
 * 分页查询数据
 * @param page 分页对象
 * @param entity
 * @return
 */
public Page<T> findPage(Page<T> page, T entity);

/**
 * 查询列表总数
 * @param entity
 * @return
 */
public long findCount(T entity);

/**
 * 保存数据（插入或更新）
 * @param entity
 */
@Transactional(readOnly = false)
public void save(T entity)

/**
 * 插入数据
 * @param entity
 */
@Transactional(readOnly = false)
public void insert(T entity);

/**
 * 更新数据
 * @param entity
 */
@Transactional(readOnly = false)
public void update(T entity);

/**
 * 更新状态（级联更新子节点）
 * @param entity
 */
@Transactional(readOnly = false)
public void updateStatus(T entity);

/**
 * 删除数据
 * @param entity
 */
@Transactional(readOnly = false)
public void delete(T entity);

/**
 * 根据父节点获取子节点最后一条记录
 */
public T getLastByParentCode(T entity);

/**
 * 保存数据（插入或更新）
 * 实现自动保存字段：所有父级编号、所有排序号、是否是叶子节点、节点的层次级别等数据
 * 实现级联更新所有子节点数据：同父级自动保存字段
 */
@Transactional(readOnly = false)
public void save(T entity);

/**
 * 更新parent_codes、tree_sorts、tree_level字段值
 */
@Transactional(readOnly = false, isolation = Isolation.READ_UNCOMMITTED) // 可读取未提交数据
private void updateParentCodes(T entity);

/**
 * 更新当前节点排序号
 */
@Transactional(readOnly = false)
public void updateTreeSort(T entity);

/**
 * 更新tree_leaf字段值
 */
@Transactional(readOnly = false, isolation = Isolation.READ_UNCOMMITTED) // 可读取未提交数据
private void updateTreeLeaf(T entity);

/**
 * 修正本表树结构的所有父级编号
 * 包含：数据修复（parentCodes、treeLeaf、treeLevel）字段
 */
@Transactional(readOnly = false) // 可读取未提交数据
public void updateFixParentCodes();

/**
 * 按父级编码修正树结构的所有父级编号
 * 包含：数据修复（parentCodes、treeLeaf、treeLevel）字段
 */
@Transactional(readOnly = false) // 可读取未提交数据
public void updateFixParentCodes(String parentCode);

/**
 * 预留接口事件，更新子节点
 * @param childEntity 当前操作节点的子节点
 * @param parentEntity 当前操作节点
 */
protected void updateChildNode(T childEntity, T parentEntity);

/**
 * 更新状态（级联更新子节点）
 * @param entity
 */
@Transactional(readOnly = false)
public void updateStatus(T entity);

/**
 * 删除数据（级联删除子节点）
 * @param entity
 */
@Transactional(readOnly = false)
public void delete(T entity);

/**
 * 转换为树结构列表形式[code,childList[code,childList[...]]]<br>
 * 举例如下：<br>
 * 	List<T> sourceList = service.findList(entity);<br>
 * 	List<T> targetList = service.convertTreeList(sourceList, T.ROOT_CODE);<br>
 * @param sourceList 源数据列表
 * @param parentCode 目标数据列表的顶级节点
 * @return targetList 目标数据列表
 */
public List<T> convertTreeList(List<T> sourceList, String parentCode);

@RequestMapping(value = "listData")
public Page<Custom> listData(Custom custom, HttpServletRequest request, HttpServletResponse response){
	custom.setPage(new Page<Custom>(request, response));
	Page<Custom> page = service.findListByCodeAndName(custom);
	return page;
}

public Page<Custom> findPageByCodeAndName(Custom custom){
	Page<Custom> page = (Page<Custom>) custom.getPage();

	// 不执行Count，不查询总数。
	page.setCount(Page.COUNT_NOT_COUNT);

	// 只Count数据，不返回数据，通过 page.getCount()获取
	page.setCount(Page.COUNT_ONLY_COUNT);

	// 不分页，不执行Count，返回全部数据。
	custom.setPage(new Page(1, Page.PAGE_SIZE_NOT_PAGING, Page.COUNT_NOT_COUNT));
	// 或者
	custom.setPage(null);
	
	// 执行查询，获取当前页列表数据和Count数据
	page.setList(dao.findListByCodeAndName(custom));

	// 获取当前页数据
	System.out.println(page.getList());

	// 获取总条数
	System.out.println(page.getCount());
	return page;
}

public List<Custom> findListByCodeAndName(Custom custom);
public Long findListByCodeAndNameCount(Custom custom);

public Custom extends BaseEntity{
	private String code;
	private String name;	
}

Page<Map<String, Object>> pageMap = new Page<>(1, 20); // 该 Page 可以来自 Controller，例如上节所示。
Map<String, Object> params = MapUtils.newHashMap();
params.put("testInput", "123");
params.put("page", pageMap); // 给 Map 设置 page 参数即可自动分页
pageMap.setList(dao.findListForMap(params));
System.out.println(pageMap.getList());	// 获取当前页数据
System.out.println(pageMap.getCount()); // 获取总条数

public List<Map<String, Object>> findListForMap(Map<String, Object> params);

@RequestMapping(value = "listData")
public Page<Custom> listData(Custom custom, HttpServletRequest request, HttpServletResponse response){
	custom.setPage(new Page<Custom>(request, response));
	Page<Custom> page = service.findListByCodeAndName(custom);
	return page;
}

public Page<Custom> findPageByCodeAndName(Custom custom){
	Page<Custom> page = (Page<Custom>) custom.getPage();

	// 执行查询，获取当前页列表数据
	page.setCount(Page.COUNT_NOT_COUNT);
	page.setList(dao.findListByCodeAndName(custom));

	// 获取总条数，并初始化分页对象
	custom.setPage(null);
	page.setCount(dao.findListByCodeAndNameCount(custom));
	page.initialize();

	// 获取当前页数据
	System.out.println(page.getList());

	// 获取总条数
	System.out.println(page.getCount());
	return page;
}

public List<Custom> findListByCodeAndName(Custom custom);
public Long findListByCodeAndNameCount(Custom custom);

public Custom extends BaseEntity{
	private String code;
	private String name;	
}

@Service
@Transactional(readOnly=true)
public class UserServiceImpl extends UserServiceSupport{
	
	public UserServiceImpl() {
		super.setEntityClass(User.class);
	}
	
	/**
	 * 更新个人信息
	 */
	@Override
	@Transactional(readOnly=false)
	public void updateUserInfo(User user){
		String avatarBase64 = user.getAvatarBase64();
		if (StringUtils.isNotBlank(avatarBase64)){
			if ("EMPTY".equals(avatarBase64)){
				user.setAvatar(StringUtils.EMPTY);
			}else{
				String imageUrl = "avatar/"+user.getCorpCode()+"/"
						+user.getUserType()+"/"+user.getUserCode()
						+"."+FileUtils.getFileExtensionByImageBase64(avatarBase64);
				String fileName = Global.getUserfilesBaseDir(imageUrl);
				FileUtils.writeToFileByImageBase64(fileName, avatarBase64);
				user.setAvatar(Global.USERFILES_BASE_URL + imageUrl);
			}
		}
		super.updateUserInfo(user);
	}
	
}

@Service
@Transactional(readOnly=true)
public class RoleServiceImpl extends RoleServiceSupport {

	public RoleServiceImpl() {
		super.setEntityClass(Role.class);
	}

	@Override
	public void addDataScopeFilter(Role entity) {
		// 以下是角色列表过滤条件，覆写该方法可重写过滤条件
		User currentUser = role.getCurrentUser(); // v5.3.0 之前版本
		User currentUser = role.currentUser(); // v5.3.0+ 及之后版本
		SqlMap sqlMap = role.getSqlMap(); // v5.3.0 之前版本
		SqlMap sqlMap = role.sqlMap(); // v5.3.0+ 及之后版本
		sqlMap.getWhere().disableAutoAddCorpCodeWhere();
		sqlMap.getDataScope().addFilter("dsf", "Role", "a.role_code", ctrlPermi);
		sqlMap.getDataScope().addFilter("dsf", "a.is_sys = '"+Global.YES
					+"' OR a.create_by = '"+currentUser.getUserCode()+"'");
		if (currentUser.isAdmin()){
			sqlMap.getDataScope().addFilter("dsf", "a.is_sys = '"+Global.NO
					+"' AND a.corp_code = '"+ CorpUtils.getCurrentCorpCode()+"'");
		}
	}

	@Override
	public List<Role> findList(Role role) {
		return super.findList(role);
	}
	
}