页面历史

importPackage(Packages.java.io);
importPackage(Packages.java.lang);
importPackage(Packages.java.util);
importPackage(Packages.smartbi.usermanager);
importPackage(Packages.smartbi.sdk);
importPackage(Packages.smartbi.sdk.service.user);
importPackage(Packages.smartbi.sdk.service.datasource);
 
/**
 * 从外部数据库中定时同步用户、机构信息到知识库中从外部数据库中定时同步用户、机构、角色信息到知识库中。
 * 
 * needTopGroup变量用来控制是否创建一个"顶级机构"。
 * 		如果needTopGroup为true，则会创建一个名称为topGroupName的机构，同步通过的机构都放到它下面。
 * 代码说明：		如果needTopGroup为false，则不会创建顶级机构，而同步过来的机构全部放到默认的"根组"下面。
 */
var needTopGroup = true;
var topGroupName = 1）该同步代码默认会在"根组"下创建一个"顶级机构"，所有同步过来的机构皆是其子机构
 *      2）用户可以属于多个机构，多个机构名称之间用 # 号分割YourTopGroupName";
/**
 * 数据源的ID值。后面sqlGroup、sqlRole、sqlUser等SQL语句都在该数据源下执行。
 */
var datasrcId = "DS.YourDatasourceId";
/**
 * 该SQL语句获取第三方系统中的机构信息。<br/>
 * 注意！可以根据第三方系统中机构表修改下面的SQL语句，但输出字段的个数、顺序，必须和下面的一模一样，否则会出错。 
 * 		orgName ：机构名称
 * 		orgAlias ：机构别名 
 * 		orgParentName ：父机构名称 
 * 		isUse ：是否有效
 */
var usrManagerServicesqlGroup = new UserManagerService(connector);
var datasrcService = new DataSourceService(connector);
 
//
// 创建"顶级机构"
// 下面这段代码不能删除，如果不需要"顶级机构"可以将needTopGroup设置为false   
//
var needTopGroup = true; // 是否创建一个"顶级机构"
var topGroup = usrManagerService.getDepartmentById("DEPARTMENT");
if (needTopGroup) {
   "select orgName, orgAlias, orgParentName, isUse from org";
/**
 * 该SQL语句获取第三方系统中的角色信息。<br/>
 * 注意！可以根据第三方系统中角色表修改下面的SQL语句，但输出字段的个数、顺序，必须和下面的一模一样，否则会出错。 
 * 		roleName ：角色名称
 * 		roleAlias ：角色别名 
 * 		orgName ：机构名称，所创建的角色放在该机构下
 */
var sqlRole = "select roleName, roleAlias, orgName from roles";
/**
 * 该SQL语句获取第三方系统中的用户信息。 <br/>
 * 注意！可以根据第三方系统中用户表修改下面的SQL语句，但输出字段的个数、顺序，必须和下面的一模一样，否则会出错。 
 * 		userName ：用户名称
 * 		userAlias ：用户别名 
 * 		orgName ：机构名称，如果一个用户属于多个机构，则orgName字段值是多个机构名称用#拼接在一起，如：org1#org2#org3 
 * 		isUse ：是否有效
 * 		userPwd ：用户密码 
 * 		roleName ：角色名称，如果一个用户拥有多个角色，则roleName字段值是多个角色名称用#拼接在一起，如：role1#role2#role3
 */
var sqlUser = "select userName, userAlias, orgName, isUse, userPwd, roleName from orgUser  where  userName not in ('admin','scheduleAdmin','service')"; //同步用户需要时需要排除掉smartbi中内置用户，内置用户有"'admin','scheduleAdmin','service'"
/**
 * 是否删除已经赋予的角色。
 * 		如果为true，则之前给用户赋予的角色全部删除；
 * 		如果为false，则之前赋予的角色全部保存，同步时给用户追加新角色。
 */
var removeAllAssignedRoles = true;
 
/**
 * 开始同步机构、角色、用户等信息。
 * 
 * 如果本项目上不需要同步角色，可以将synchronizeRoleFromOtherDb代码行注释掉。
 * 
 */
var topGroup = getTopGroup(needTopGroup, topGroupName);
synchronizeGroupFromOtherDb(datasrcId, sqlGroup, topGroup);
synchronizeRoleFromOtherDb(datasrcId, sqlRole, topGroup);
synchronizeUserFromOtherDb(datasrcId, sqlUser, topGroup, removeAllAssignedRoles);
System.out.print("\n\n==============同步完成！===============");
 
/**
 * 创建"顶级机构"。
 * 
 * @param needTopGroup
 *            是否创建一个"顶级机构"。如果该变量为false，则同步过来的机构全部放到"根组"下面。
 * @param topGroupName
 *            如果needTopGroup为true，则会创建一个名称为topGroupName的机构，同步通过的机构都放到它下面。
 * @returns 返回创建的顶级机构对象。
 */
function getTopGroup(needTopGroup, topGroupName) {
	var usrManagerService = new UserManagerService(connector);
 
	var topGroup = usrManagerService.getDepartmentByNamegetDepartmentById("YourTopGroupNameDEPARTMENT"); //需要建立的顶级机构名称 根组
	if (needTopGroup  if (!topGroup&& topGroupName) {
		topGroup = usrManagerService.getDepartmentByName(topGroupName);
		if (!topGroup) {
  			var groupId = usrManagerService.createDepartment("DEPARTMENT", "YourTopGroupName"topGroupName, "YourTopGroupName"topGroupName, "", "");   // 在根组下建立顶级机构
        			topGroup = usrManagerService.getDepartmentById(groupId);
		}
	}
	return topGroup;
}
}
 
/**
 * 同步机构：获取第三方系统中的机构信息。
 * 
 * @param dsId
 *           // //数据源ID值。
同步机构：获取第三方系统中的机构信息 //* var@param sqlGroup = "select orgName, orgAlias, orgParentName, isUse, orgLevel from org order by orgLevel"; // 该SQL语句获取第三方系统中的机构信息

 *            用来同步机构的SQL语句。
 * @param topGroup
 *            顶级机构。
 */
function synchronizeGroupFromOtherDb(dsId, sqlGroup, topGroup) {
	var usrManagerService = new UserManagerService(connector);
	var datasrcService = new DataSourceService(connector);
 
	var gridDataGroup = datasrcService.executeNoCacheable("DS.northwind"dsId, sqlGroup);
	for (var i = 0; i < gridDataGroup.getRowsCount(); i++) {
    		var orgName       = gridDataGroup.get(i, 0).getValue();
    		var orgAlias      = gridDataGroup.get(i, 1).getValue();
    		var orgParentName = gridDataGroup.get(i, 2).getValue();
    		var isUse         = gridDataGroup.get(i, 3).getValue();
    		System.out.println("=====正在同步机构：名称/别名/父机构父机构名称/是否生效：" + orgName + "/" + orgAlias + "/" + orgParentName + "/"
				+ isUse);
 
  		// 判断机构是否已经同步
    查找父机构
		var groupparentGroup = usrManagerService.getDepartmentByName(orgNameorgParentName);
    		if (!groupparentGroup) {
//如果不存在则创建
  			parentGroup = topGroup;
		}
 
		// 根据机构名称判断是否存在
 		var parentGroupgroup = usrManagerService.getDepartmentByName(orgParentNameorgName);
        		if (!parentGroupgroup) {
			//            parentGroup = topGroup;
        如果不存在则创建
			usrManagerService.createDepartment(parentGroup.getId(), orgName, orgAlias, "", "");
    		} else {
			//如果存在则判断父机构是否正确
        var parentGroup = usrManagerService.getDepartmentByName(orgParentName);
         如果存在则判断父机构是否正确
			if (parentGroup && (parentGroup.getId() != usrManagerService.getParentDepartment(group.getId()).getId())) {
            				usrManagerService.moveDepartment(group.getId(), parentGroup.getId());
			}
		}
	}
}
 
/**
 * 同步角色：获取第三方系统中的角色信息。
 * 
 * @param dsId
 *            数据源ID值。
 * @param sqlRole
 *     }       用来同步角色的SQL语句。
 * @param topGroup
 *          } } 顶级机构。
 //
// 同步角色：获取第三方系统中的角色信息，orgName的意思是表示这个角色是建立在哪个组下的
//
var sqlRole = "select roleName, roleAlias, orgName from roles"; // 该SQL语句获取第三方系统中的机构信息
*/
function synchronizeRoleFromOtherDb(dsId, sqlRole, topGroup) {
	var usrManagerService = new UserManagerService(connector);
	var datasrcService = new DataSourceService(connector);
 
	var gridDataRole = datasrcService.executeNoCacheable("DS.northwind"dsId, sqlRole);
	for (var i = 0; i < gridDataRole.getRowsCount(); i++) {
    		var roleName  = gridDataRole.get(i, 0).getValue();
    		var roleAlias = gridDataRole.get(i, 1).getValue();
    		var orgName   = gridDataRole.get(i, 2).getValue();
    		System.out.println("=====正在同步角色：名称/别名/父机构：父机构名称：" + roleName + "/" + roleAlias + "/" + orgName);
 
		// 查找父机构
		var group = topGroup;
    usrManagerService.getDepartmentByName(orgName || "NonEmptyOrgName");
		if (orgName!group) {
			group = topGroup;
		}
 
		// 判断角色是否已经同步
		var grouprole = usrManagerService.getDepartmentByNamegetRoleByName2(orgNameroleName);
		if (group!role) {
			// 如果不存在则创建
			usrManagerService.createRole(roleName,      	orgName = roleAlias, "", group.getId());
		} else {
			orgName// = topGroup如果存在则更新其信息
			usrManagerService.updateRole(role.getId(), roleAlias, "");
		}
	}
}
 
/**
 * 同步用户：获取第三方系统中的用户信息。
 // 判断角色是否已经同步* 
 * @param dsId
 *            var数据源ID值。
role = usrManagerService.getRoleByName2(roleName);
* @param sqlUser
 *  if (!role) { //如果不存在则创建       用来同步用户的SQL语句。
 usrManagerService.createRole(roleName, roleAlias, "", orgName);
* @param topGroup
 *    } else { //如果存在则判断父机构是否正确     顶级机构。
 *  usrManagerService.updateRole(role.getId(), roleAlias, "");@param removeAllAssignedRoles
 *     } }  // // 同步用户：获取第三方系统中的用户信息 // var是否删除已经赋予的角色。如果为false，则之前的角色全部保存，同步只是追加新角色。
sqlUser =*/
"select userNamefunction synchronizeUserFromOtherDb(dsId, userAliassqlUser, orgName, isUse, userPwd, roleName from orgUser"; // 该SQL语句获取第三方系统中的用户信息
topGroup, removeAllAssignedRoles) {
	var usrManagerService = new UserManagerService(connector);
	var datasrcService = new DataSourceService(connector);
 
	var gridDataUser = datasrcService.executeNoCacheable("DS.northwind"dsId, sqlUser);
	for (var i = 0; i < gridDataUser.getRowsCount(); i++) {
    		var userName  = gridDataUser.get(i, 0).getValue();
    		var userAlias = gridDataUser.get(i, 1).getValue();
    		var orgName   = gridDataUser.get(i, 2).getValue();
    		var isUse     = gridDataUser.get(i, 3).getValue();
    		var userPwd   = gridDataUser.get(i, 4).getValue();
    		var roleName  = gridDataUser.get(i, 5).getValue();
    		System.out.println("=====正在同步用户：名称/别名/所属机构所属机构名称/是否生效/密码：密码/角色名称：" + userName + "/" + userAlias + "/" + orgName + "/"
				+ isUse + "/" + userPwd + "/" + roleName);
 
  		// 获取用户所属机构ID是否生效
		isUse = (""  var usrOrgNameList+ isUse).toLowerCase();
		isUse = (orgNameisUse === "0" || isUse === "false").split("#") || !isUse) ? false : true;
 
		// 获取用户所属机构ID
		var usrOrgIdList = [];
		var usrOrgNameList = (orgName || "").split("#");
		for (var j = 0; j < usrOrgNameList.length; j++) {
        			var parentGroup = usrManagerService.getDepartmentByName(usrOrgNameList[j] || "NonEmptyOrgName");
        			if (parentGroup) {
				usrOrgIdList.push(parentGroup.getId());
      			}
    		}
		// 如果未找到父机构，则将该用户放到topGroup下面
  		if (usrOrgIdList.length < 1) 
        {
			usrOrgIdList.push(topGroup.getId());
		}
 
 		// 判断用户是否已经同步
    		var user = usrManagerService.getUserByName(userName);
    		if (!user) {
        // "123456" 是初始密码
        			usrManagerService.createUser(usrOrgIdList[0], userName, userAlias, "", "123456"userPwd, ((isUse) ? true: false));
        ;
			user = usrManagerService.getUserByName(userName);
    		}
    		// 设置用户所属机构
    		usrManagerService.assignDepartmentsToUser(user.getId(), usrOrgIdList);
 
  		// 设置用户角色
		var usrRoleIdList = [];
		var usrRoleNameList = (roleName  || "").split("#");
    var usrRoleIdList = [];
    		for (var jk = 0; jk < usrRoleNameList.length; jk++) {
        			var userRole = usrManagerService.getRoleByName2(usrRoleNameList[jk]);
			if (userRole) {
				usrRoleIdList.push(userRole.getId());
			}
   		}
		if (userRole!removeAllAssignedRoles) {
			usrRoleIdList.push(userRole// 是否保留旧角色
			var oldAssignedRoles = usrManagerService.getAssignedRolesOfUser(user.getId());
			for (var m = 0; m < oldAssignedRoles.size(); m++) }{
				var oldRoleId =  }
    oldAssignedRoles.get(m).getId();
				if (usrRoleIdList.join("###").indexOf(oldRoleId) < 0)
					usrRoleIdList.push(oldRoleId);
			}
		}
		usrManagerService.assignRolesToUser(user.getId(), usrRoleIdList);
 
   
		// 更新用户别名、描述等信息
    更新用户别名、描述等信息。updateUser方法会将传入的明文密码，MD5后存入smartbi知识库
		// updateUser方法会将传入的明文密码，MD5后存入smartbi知识库
    //usrManagerService.updateUser(user.getId(), userAlias, "", userPwd,
((isUse) ? true: false)		// isUse);
    		//
    		// 或者，调用updateUserByEncryptedPassword方法同步密码
    或者，调用updateUserByEncryptedPassword方法（修改用户信息设置加密后的密码）同步密码
		// 在第三方系统密码的前面添加标识："0" + MD5; "1" + DES; "2" + 明文密码
    		//如果第三方系统中用户密码是以MD5加密的方式储存的，则需要在密码前加 如果第三方系统中用户密码是以MD5加密的方式储存的，调用updateUserByEncryptedPassword方法时需要在密码前加"0"，方可正常登陆
    ，登录Smartbi时输入加密前的密码
		//如果第三方系统中用户密码是以DES加密的方式储存的，则需要在密码前加 如果第三方系统中用户密码是以DES加密的方式储存的，调用updateUserByEncryptedPassword方法时需要在密码前加"1"，方可正常登陆
    ，登录Smartbi时输入加密前的密码
		//如果第三方系统中用户密码是明文存储的，则需要在密码前加 如果第三方系统中用户密码是明文存储的，调用updateUserByEncryptedPassword方法时需要在密码前加"2"，方可正常登陆
    ，登录Smartbi时输入不含2的明文才可成功登录
		var encryptedPwd = "0" + userPwd;
    		usrManagerService.updateUserByEncryptedPassword(user.getId(), userAlias, "", encryptedPwd, ((isUse) ? true: false));
	}
 
//
// 同步完成！
//
System.out.print("\n\n\n\n\n========================================");} 

注意：请参考代码中的注视，修改其中的必要信息，比如下面这些。

请参考代码中的注释，修改其中的必要信息，比如下面这些。

• var needTopGroup ：是否需要顶级机构。
• var topGroupName ：顶级机构名称。
• var datasrcId ：数据源的ID值。需要在“定制管理 -> 数据管理 -> 数据源”中新建关系数据源，所有的SQL需要在该数据源上执行。
• 该计划任务对用户的同步时，同步的是该用户的所属默认组。若同一个用户存在多条记录，则同步到Smartbi中该用户的所属默认组为最后执行的一条记录。不能同步用户属于多个组的情况。var sqlGroup ：用来同步机构的SQL语句。
• var sqlRole ：用来同步角色的SQL语句。
• var sqlUser ：原来同步用户的SQL语句。
• var removeAllAssignedRoles ：同步时是否删除已有角色。