Java Authorization.setGroupId方法代码示例

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public void testQueryWithGroupAuthorizationRevokedReadPermission() {
  // given
  // given user gets all permissions on any process definition
  Authorization authorization = createGrantAuthorization(PROCESS_DEFINITION, ANY);
  authorization.setGroupId(groupId);
  authorization.addPermission(ALL);
  saveAuthorization(authorization);

  authorization = createRevokeAuthorization(PROCESS_DEFINITION, ONE_TASK_PROCESS_KEY);
  authorization.setGroupId(groupId);
  authorization.removePermission(READ);
  saveAuthorization(authorization);

  // when
  ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();

  // then
  verifyQueryResults(query, 1);

  ProcessDefinition definition = query.singleResult();
  assertNotNull(definition);
  assertEquals(TWO_TASKS_PROCESS_KEY, definition.getKey());
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public void testCreateAuthorizationWithGroupId() {

    TestResource resource1 = new TestResource("resource1",100);

    // initially, no authorization exists:
    assertEquals(0, authorizationService.createAuthorizationQuery().count());

    // simple create / delete with userId
    Authorization authorization = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
    authorization.setGroupId("aGroupId");
    authorization.setResource(resource1);

    // save the authorization
    authorizationService.saveAuthorization(authorization);
    // authorization exists
    assertEquals(1, authorizationService.createAuthorizationQuery().count());
    // delete the authorization
    authorizationService.deleteAuthorization(authorization.getId());
    // it's gone
    assertEquals(0, authorizationService.createAuthorizationQuery().count());

  }
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public static void update(AuthorizationDto dto, Authorization dbAuthorization) {

    dbAuthorization.setGroupId(dto.getGroupId());
    dbAuthorization.setUserId(dto.getUserId());
    dbAuthorization.setResourceId(dto.getResourceId());

    // update optional fields

    if(dto.getResourceType() != null) {
      dbAuthorization.setResourceType(dto.getResourceType());
    }

    if(dto.getPermissions() != null) {
      dbAuthorization.setPermissions(PermissionConverter.getPermissionsForNames(dto.getPermissions()));
    }

  }
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
private void addAuthorizationGroup(AuthorizationService authorizationService,
                                   Resource resource, String resourceId,
                                   String groupId, Permission[] permissions) {
    Authorization newAuthorization = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
    newAuthorization.setGroupId(groupId);
    newAuthorization.setResource(resource);
    newAuthorization.setResourceId(resourceId);
    for (Permission permission : permissions) {
        newAuthorization.addPermission(permission);
    }
    authorizationService.saveAuthorization(newAuthorization);
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
private void adjustAuthorizations(){
	// create admin group if necessary
	if (identityService.createGroupQuery().groupId(Groups.CAMUNDA_ADMIN).count() == 0) {
		Group camundaAdminGroup = identityService.newGroup(Groups.CAMUNDA_ADMIN);
		camundaAdminGroup.setName("camunda BPM Administrators");
		camundaAdminGroup.setType(Groups.GROUP_TYPE_SYSTEM);
		identityService.saveGroup(camundaAdminGroup);
	}

	// create ADMIN authorizations on all built-in resources
	for (Resource resource : Resources.values()) {
		if (authorizationService.createAuthorizationQuery()
				.groupIdIn(Groups.CAMUNDA_ADMIN).resourceType(resource)
				.resourceId(ANY).count() == 0) {
			AuthorizationEntity userAdminAuth = new AuthorizationEntity(
					AUTH_TYPE_GRANT);
			userAdminAuth.setGroupId(Groups.CAMUNDA_ADMIN);
			userAdminAuth.setResource(resource);
			userAdminAuth.setResourceId(ANY);
			userAdminAuth.addPermission(ALL);
			authorizationService.saveAuthorization(userAdminAuth);
		}
	}

	// Task-List
	Authorization bvisTasklistAuth = authorizationService
			.createNewAuthorization(AUTH_TYPE_GRANT);
	bvisTasklistAuth.setGroupId("bvis");
	bvisTasklistAuth.addPermission(ACCESS);
	bvisTasklistAuth.setResourceId("tasklist");
	bvisTasklistAuth.setResource(APPLICATION);
	authorizationService.saveAuthorization(bvisTasklistAuth);
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
private void grantAuthorizationWithPermissions(Group adminGroup) {
    Authorization authorization = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
    authorization.setGroupId(adminGroup.getId());
    authorization.setResource(Resources.USER);
    authorization.addPermission(org.camunda.bpm.engine.authorization.Permissions.ALL);
    authorizationService.saveAuthorization(authorization);
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
protected void createGroupGrantAuthorization(Resource resource, String resourceId, String groupId, Permission... permissions) {
  Authorization authorization = createGrantAuthorization(resource, resourceId);
  authorization.setGroupId(groupId);
  for (Permission permission : permissions) {
    authorization.addPermission(permission);
  }
  saveAuthorization(authorization);
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
protected void createGrantAuthorizationGroup(Resource resource, String resourceId, String groupId, Permission... permissions) {
  Authorization authorization = createGrantAuthorization(resource, resourceId);
  authorization.setGroupId(groupId);
  for (Permission permission : permissions) {
    authorization.addPermission(permission);
  }
  saveAuthorization(authorization);
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public void testGrantAuthorizationType() {
  Authorization grantAuthorization = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
  // I can set userId = null
  grantAuthorization.setUserId(null);
  // I can set userId = ANY
  grantAuthorization.setUserId(ANY);
  // I can set anything else:
  grantAuthorization.setUserId("something");
  // I can set groupId = null
  grantAuthorization.setGroupId(null);
  // I can set anything else:
  grantAuthorization.setGroupId("something");
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public void testRevokeAuthorizationType() {
  Authorization revokeAuthorization = authorizationService.createNewAuthorization(AUTH_TYPE_REVOKE);
  // I can set userId = null
  revokeAuthorization.setUserId(null);
  // I can set userId = ANY
  revokeAuthorization.setUserId(ANY);
  // I can set anything else:
  revokeAuthorization.setUserId("something");
  // I can set groupId = null
  revokeAuthorization.setGroupId(null);
  // I can set anything else:
  revokeAuthorization.setGroupId("something");
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public void testUserOverrideGroupOverrideGlobalAuthorizationCheck() {
  TestResource resource1 = new TestResource("resource1",100);

  // create global authorization which grants all permissions to all users  (on resource1):
  Authorization globalGrant = authorizationService.createNewAuthorization(AUTH_TYPE_GLOBAL);
  globalGrant.setResource(resource1);
  globalGrant.setResourceId(ANY);
  globalGrant.addPermission(ALL);
  authorizationService.saveAuthorization(globalGrant);

  // revoke READ for group "sales"
  Authorization groupRevoke = authorizationService.createNewAuthorization(AUTH_TYPE_REVOKE);
  groupRevoke.setGroupId("sales");
  groupRevoke.setResource(resource1);
  groupRevoke.setResourceId(ANY);
  groupRevoke.removePermission(READ);
  authorizationService.saveAuthorization(groupRevoke);

  // add READ for jonny
  Authorization userGrant = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
  userGrant.setUserId("jonny");
  userGrant.setResource(resource1);
  userGrant.setResourceId(ANY);
  userGrant.addPermission(READ);
  authorizationService.saveAuthorization(userGrant);

  List<String> jonnysGroups = Arrays.asList("sales", "marketing");
  List<String> someOneElsesGroups = Collections.singletonList("marketing");

  // jonny can read
  assertTrue(authorizationService.isUserAuthorized("jonny", jonnysGroups, READ, resource1));
  assertTrue(authorizationService.isUserAuthorized("jonny", null, READ, resource1));

  // someone else in the same groups cannot
  assertFalse(authorizationService.isUserAuthorized("someone else", jonnysGroups, READ, resource1));

  // someone else in different groups can
  assertTrue(authorizationService.isUserAuthorized("someone else", someOneElsesGroups, READ, resource1));
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
protected void createAuthorization(String userId, String groupId, Resource resourceType, String resourceId, Permission... permissions) {

    Authorization authorization = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
    authorization.setUserId(userId);
    authorization.setGroupId(groupId);
    authorization.setResource(resourceType);
    authorization.setResourceId(resourceId);

    for (Permission permission : permissions) {
      authorization.addPermission(permission);
    }

    authorizationService.saveAuthorization(authorization);
  }
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public static void update(AuthorizationCreateDto dto, Authorization dbAuthorization) {
  
  dbAuthorization.setGroupId(dto.getGroupId());
  dbAuthorization.setUserId(dto.getUserId());
  dbAuthorization.setResourceType(dto.getResourceType());
  dbAuthorization.setResourceId(dto.getResourceId());
  dbAuthorization.setPermissions(PermissionConverter.getPermissionsForNames(dto.getPermissions()));
  
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
protected void grouptGrant(String groupId, Resource resource, Permission... perms) {

    AuthorizationService authorizationService = engine.getAuthorizationService();
    Authorization groupGrant = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
    groupGrant.setResource(resource);
    groupGrant.setResourceId(ANY);
    for (Permission permission : perms) {
      groupGrant.addPermission(permission);
    }
    groupGrant.setGroupId(groupId);
    authorizationService.saveAuthorization(groupGrant);
  }
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
public static void createDefaultUser(ProcessEngine engine) {
  // and add default user to Camunda to be ready-to-go
  if (engine.getIdentityService().createUserQuery().userId("demo").count() == 0) {
    User user = engine.getIdentityService().newUser("demo");
    user.setFirstName("Demo");
    user.setLastName("Demo");
    user.setPassword("demo");
    user.setEmail("[email protected]");
    engine.getIdentityService().saveUser(user);

    Group group = engine.getIdentityService().newGroup(Groups.CAMUNDA_ADMIN);
    group.setName("Administrators");
    group.setType(Groups.GROUP_TYPE_SYSTEM);
    engine.getIdentityService().saveGroup(group);

    for (Resource resource : Resources.values()) {
      Authorization auth = engine.getAuthorizationService().createNewAuthorization(AUTH_TYPE_GRANT);
      auth.setGroupId(Groups.CAMUNDA_ADMIN);
      auth.addPermission(ALL);
      auth.setResourceId(ANY);
      auth.setResource(resource);
      engine.getAuthorizationService().saveAuthorization(auth);
    }

    engine.getIdentityService().createMembership("demo", Groups.CAMUNDA_ADMIN);
  }

  // create default "all tasks" filter
  if (engine.getFilterService().createFilterQuery().filterName("Alle").count() == 0) {

    Map<String, Object> filterProperties = new HashMap<String, Object>();
    filterProperties.put("description", "Alle Aufgaben");
    filterProperties.put("priority", 10);

    Filter filter = engine.getFilterService().newTaskFilter() //
        .setName("Alle") //
        .setProperties(filterProperties)//
        .setOwner("demo")//
        .setQuery(engine.getTaskService().createTaskQuery());
    engine.getFilterService().saveFilter(filter);

    // and authorize demo user for it
    if (engine.getAuthorizationService().createAuthorizationQuery().resourceType(FILTER).resourceId(filter.getId()) //
        .userIdIn("demo").count() == 0) {
      Authorization managementGroupFilterRead = engine.getAuthorizationService().createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
      managementGroupFilterRead.setResource(FILTER);
      managementGroupFilterRead.setResourceId(filter.getId());
      managementGroupFilterRead.addPermission(ALL);
      managementGroupFilterRead.setUserId("demo");
      engine.getAuthorizationService().saveAuthorization(managementGroupFilterRead);
    }

  }
}