Java Authorization.setResource方法代码示例

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
@Test
public void shouldFetchTaskCountWithAuthorization() {
  // given
  User user = identityService.newUser(userId);
  identityService.saveUser(user);

  Authorization authorization = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
  authorization.addPermission(READ);
  authorization.setResource(TASK);
  authorization.setResourceId(ANY);
  authorization.setUserId(userId);
  authorizationService.saveAuthorization(authorization);

  processEngineConfiguration.setAuthorizationEnabled(true);
  authenticate();

  // when
  List<TaskCountByCandidateGroupResult> results = taskService.createTaskReport().taskCountByCandidateGroup();
  processEngineConfiguration.setAuthorizationEnabled(false);
  authorizationService.deleteAuthorization(authorization.getId());
  identityService.deleteUser(userId);

  assertEquals(0, results.size());
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
private void createAuthenticationData() {
  IdentityService identityService = engineRule.getIdentityService();
  Group group = identityService.newGroup("group");
  identityService.saveGroup(group);
  User user = identityService.newUser("user");
  User user2 = identityService.newUser("user2");
  identityService.saveUser(user);
  identityService.saveUser(user2);
  Tenant tenant = identityService.newTenant("tenant");
  identityService.saveTenant(tenant);
  Tenant tenant2 = identityService.newTenant("tenant2");
  identityService.saveTenant(tenant2);
  identityService.createMembership("user", "group");
  identityService.createTenantUserMembership("tenant", "user");
  identityService.createTenantUserMembership("tenant2", "user2");


  TestResource resource1 = new TestResource("resource1", 100);
  // create global authorization which grants all permissions to all users (on resource1):
  AuthorizationService authorizationService = engineRule.getAuthorizationService();
  Authorization globalAuth = authorizationService.createNewAuthorization(AUTH_TYPE_GLOBAL);
  globalAuth.setResource(resource1);
  globalAuth.setResourceId(ANY);
  globalAuth.addPermission(ALL);
  authorizationService.saveAuthorization(globalAuth);

  //grant user read auth on resource2
  TestResource resource2 = new TestResource("resource2", 200);
  Authorization userGrant = authorizationService.createNewAuthorization(AUTH_TYPE_GRANT);
  userGrant.setUserId("user");
  userGrant.setResource(resource2);
  userGrant.setResourceId(ANY);
  userGrant.addPermission(READ);
  authorizationService.saveAuthorization(userGrant);

  identityService.setAuthenticatedUserId("user");
}
 

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

  grantReadFilter(filter.getId());
  Authorization authorization = processEngine.getAuthorizationService().createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
  authorization.addPermission(Permissions.READ);
  authorization.setUserId(Authorization.ANY);
  authorization.setResource(Resources.FILTER);
  authorization.setResourceId(Authorization.ANY);
  processEngine.getAuthorizationService().saveAuthorization(authorization);

  long count = filterService.createFilterQuery().count();
  assertEquals(1, count);

  Filter returnedFilter = filterService.createFilterQuery().filterId(filter.getId()).singleResult();
  assertNotNull(returnedFilter);

  returnedFilter = filterService.getFilter(filter.getId());
  assertNotNull(returnedFilter);

  processEngine.getAuthorizationService().deleteAuthorization(authorization.getId());
}
 

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包/类
public void addAuthorizationUser(AuthorizationService authorizationService,
                                 Resource resource, String resourceId,
                                 String userId, Permission[] permissions) {
    Authorization newAuthorization = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
    newAuthorization.setUserId(userId);
    newAuthorization.setResource(resource);
    newAuthorization.setResourceId(resourceId);
    Arrays.stream(permissions).forEach(newAuthorization::addPermission);
    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 Authorization createAuthorization(int type, Resource resource, String resourceId) {
  Authorization authorization = authorizationService.createNewAuthorization(type);

  authorization.setResource(resource);
  if (resourceId != null) {
    authorization.setResourceId(resourceId);
  }

  return authorization;
}
 

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

    User jonny1 = identityService.newUser("jonny1");
    identityService.saveUser(jonny1);

    Tenant tenant1 = identityService.newTenant("tenant1");
    identityService.saveTenant(tenant1);

    // add base permission which allows nobody to create memberships
    Authorization basePerms = authorizationService.createNewAuthorization(AUTH_TYPE_GLOBAL);
    basePerms.setResource(TENANT_MEMBERSHIP);
    basePerms.setResourceId(ANY);
    basePerms.addPermission(ALL); // add all then remove 'create'
    basePerms.removePermission(CREATE);
    authorizationService.saveAuthorization(basePerms);

    processEngineConfiguration.setAuthorizationEnabled(true);
    identityService.setAuthenticatedUserId(jonny2);

    try {
      identityService.createTenantUserMembership("tenant1", "jonny1");
      fail("exception expected");

    } catch (AuthorizationException e) {
      assertEquals(1, e.getMissingAuthorizations().size());
      MissingAuthorization info = e.getMissingAuthorizations().get(0);
      assertEquals(jonny2, e.getUserId());
      assertExceptionInfo(CREATE.getName(), TENANT_MEMBERSHIP.resourceName(), "tenant1", info);
    }
  }
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
protected void grantAuthorization(String userId, Resource resource, String resourceId, Permission permission) {
  Authorization authorization = engineRule.getAuthorizationService().createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
  authorization.setResource(resource);
  authorization.setResourceId(resourceId);
  authorization.addPermission(permission);
  authorization.setUserId(userId);
  engineRule.getAuthorizationService().saveAuthorization(authorization);
  authorizations.add(authorization);
}
 

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包/类
protected Authorization createAuthorization(int type, Resource resource, String resourceId) {
  Authorization authorization = engineRule.getAuthorizationService().createNewAuthorization(type);

  authorization.setResource(resource);
  if (resourceId != null) {
    authorization.setResourceId(resourceId);
  }

  return authorization;
}
 

import org.camunda.bpm.engine.authorization.Authorization; //导入方法依赖的package包/类
protected Authorization createAuthorization(Permission permission, String resourceId) {
  Authorization authorization = authorizationService.createNewAuthorization(Authorization.AUTH_TYPE_GRANT);
  authorization.setUserId(testUser.getId());
  authorization.setResource(Resources.FILTER);
  authorization.addPermission(permission);
  if (resourceId != null) {
    authorization.setResourceId(resourceId);
  }
  return authorization;
}
 

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

    Group group1 = identityService.newGroup("group1");
    identityService.saveGroup(group1);

    Tenant tenant1 = identityService.newTenant("tenant1");
    identityService.saveTenant(tenant1);

    // add base permission which allows nobody to create memberships
    Authorization basePerms = authorizationService.createNewAuthorization(AUTH_TYPE_GLOBAL);
    basePerms.setResource(TENANT_MEMBERSHIP);
    basePerms.setResourceId(ANY);
    basePerms.addPermission(ALL); // add all then remove 'create'
    basePerms.removePermission(CREATE);
    authorizationService.saveAuthorization(basePerms);

    processEngineConfiguration.setAuthorizationEnabled(true);
    identityService.setAuthenticatedUserId(jonny2);

    try {
      identityService.createTenantGroupMembership("tenant1", "group1");
      fail("exception expected");

    } catch (AuthorizationException e) {
      assertEquals(1, e.getMissingAuthorizations().size());
      MissingAuthorization info = e.getMissingAuthorizations().get(0);
      assertEquals(jonny2, e.getUserId());
      assertExceptionInfo(CREATE.getName(), TENANT_MEMBERSHIP.resourceName(), "tenant1", info);
    }
  }
 

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

    // crate group while still in god-mode:
    Group group1 = identityService.newGroup("group1");
    identityService.saveGroup(group1);

    // create global auth
    Authorization basePerms = authorizationService.createNewAuthorization(AUTH_TYPE_GLOBAL);
    basePerms.setResource(GROUP);
    basePerms.setResourceId(ANY);
    basePerms.addPermission(ALL);
    basePerms.removePermission(DELETE); // revoke delete
    authorizationService.saveAuthorization(basePerms);

    // turn on authorization
    processEngineConfiguration.setAuthorizationEnabled(true);
    identityService.setAuthenticatedUserId(jonny2);

    try {
      identityService.deleteGroup("group1");
      fail("exception expected");

    } catch (AuthorizationException e) {
      assertEquals(1, e.getMissingAuthorizations().size());
      MissingAuthorization info = e.getMissingAuthorizations().get(0);
      assertEquals(jonny2, e.getUserId());
      assertExceptionInfo(DELETE.getName(), GROUP.resourceName(), "group1", info);
    }

  }