Examples with Group org.camunda.bpm.engine.identity.Group used on opensource projects

Example 21 with Group

use of org.camunda.bpm.engine.identity.Group in project camunda-bpm-platform by camunda.

the class FilterTaskQueryTest method tearDown.

@Override
public void tearDown() {
    processEngineConfiguration.setEnableExpressionsInAdhocQueries(false);
    Mocks.reset();
    for (Filter filter : filterService.createTaskFilterQuery().list()) {
        filterService.deleteFilter(filter.getId());
    }
    for (Group group : identityService.createGroupQuery().list()) {
        identityService.deleteGroup(group.getId());
    }
    for (User user : identityService.createUserQuery().list()) {
        identityService.deleteUser(user.getId());
    }
    for (Task task : taskService.createTaskQuery().list()) {
        if (task.getProcessInstanceId() == null) {
            taskService.deleteTask(task.getId(), true);
        }
    }
}

Example 22 with Group

use of org.camunda.bpm.engine.identity.Group in project camunda-bpm-platform by camunda.

the class StartAuthorizationTest method testProcessDefinitionList.

// this test checks the list without user constraint
@Deployment
public void testProcessDefinitionList() throws Exception {
    setUpUsersAndGroups();
    try {
        // Process 1 has no potential starters
        ProcessDefinition latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process1").singleResult();
        List<User> authorizedUsers = identityService.createUserQuery().potentialStarter(latestProcessDef.getId()).list();
        assertEquals(0, authorizedUsers.size());
        // user1 and user2 are potential Startes of Process2
        latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process2").singleResult();
        authorizedUsers = identityService.createUserQuery().potentialStarter(latestProcessDef.getId()).orderByUserId().asc().list();
        assertEquals(2, authorizedUsers.size());
        assertEquals("user1", authorizedUsers.get(0).getId());
        assertEquals("user2", authorizedUsers.get(1).getId());
        // Process 2 has no potential starter groups
        latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process2").singleResult();
        List<Group> authorizedGroups = identityService.createGroupQuery().potentialStarter(latestProcessDef.getId()).list();
        assertEquals(0, authorizedGroups.size());
        // Process 3 has 3 groups as authorized starter groups
        latestProcessDef = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process4").singleResult();
        authorizedGroups = identityService.createGroupQuery().potentialStarter(latestProcessDef.getId()).orderByGroupId().asc().list();
        assertEquals(3, authorizedGroups.size());
        assertEquals("group1", authorizedGroups.get(0).getId());
        assertEquals("group2", authorizedGroups.get(1).getId());
        assertEquals("group3", authorizedGroups.get(2).getId());
        // do not mention user, all processes should be selected
        List<ProcessDefinition> processDefinitions = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionName().asc().list();
        assertEquals(4, processDefinitions.size());
        assertEquals("process1", processDefinitions.get(0).getKey());
        assertEquals("process2", processDefinitions.get(1).getKey());
        assertEquals("process3", processDefinitions.get(2).getKey());
        assertEquals("process4", processDefinitions.get(3).getKey());
        // check user1, process3 has "user1" as only authorized starter, and
        // process2 has two authorized starters, of which one is "user1"
        processDefinitions = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionName().asc().startableByUser("user1").list();
        assertEquals(2, processDefinitions.size());
        assertEquals("process2", processDefinitions.get(0).getKey());
        assertEquals("process3", processDefinitions.get(1).getKey());
        // "user2" can only start process2
        processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("user2").list();
        assertEquals(1, processDefinitions.size());
        assertEquals("process2", processDefinitions.get(0).getKey());
        // no process could be started with "user4"
        processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("user4").list();
        assertEquals(0, processDefinitions.size());
        // "userInGroup3" is in "group3" and can start only process4 via group authorization
        processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("userInGroup3").list();
        assertEquals(1, processDefinitions.size());
        assertEquals("process4", processDefinitions.get(0).getKey());
        // "userInGroup2" can start process4, via both user and group authorizations
        // but we have to be sure that process4 appears only once
        processDefinitions = repositoryService.createProcessDefinitionQuery().startableByUser("userInGroup2").list();
        assertEquals(1, processDefinitions.size());
        assertEquals("process4", processDefinitions.get(0).getKey());
    } finally {
        tearDownUsersAndGroups();
    }
}

Example 23 with Group

use of org.camunda.bpm.engine.identity.Group in project camunda-bpm-platform by camunda.

the class ResourceAuthorizationProviderTest method createGroup.

// group //////////////////////////////////////////////////////////////
protected Group createGroup(String groupId) {
    Group group = identityService.newGroup(groupId);
    identityService.saveGroup(group);
    ;
    return group;
}

Example 24 with Group

use of org.camunda.bpm.engine.identity.Group in project camunda-bpm-platform by camunda.

the class GroupQueryTest method testQueryByMember.

public void testQueryByMember() {
    GroupQuery query = identityService.createGroupQuery().groupMember("fozzie");
    verifyQueryResults(query, 2);
    query = identityService.createGroupQuery().groupMember("kermit");
    verifyQueryResults(query, 3);
    query = query.orderByGroupId().asc();
    List<Group> groups = query.list();
    assertEquals(3, groups.size());
    assertEquals("admin", groups.get(0).getId());
    assertEquals("frogs", groups.get(1).getId());
    assertEquals("muppets", groups.get(2).getId());
    query = query.groupType("user");
    groups = query.list();
    assertEquals(2, groups.size());
    assertEquals("frogs", groups.get(0).getId());
    assertEquals("muppets", groups.get(1).getId());
}

Example 25 with Group

use of org.camunda.bpm.engine.identity.Group in project camunda-bpm-platform by camunda.

the class GroupQueryTest method testQueryByIdIn.

public void testQueryByIdIn() {
    // empty list
    assertTrue(identityService.createGroupQuery().groupIdIn("a", "b").list().isEmpty());
    // collect all ids
    List<Group> list = identityService.createGroupQuery().list();
    String[] ids = new String[list.size()];
    for (int i = 0; i < ids.length; i++) {
        ids[i] = list.get(i).getId();
    }
    List<Group> idInList = identityService.createGroupQuery().groupIdIn(ids).list();
    assertEquals(list.size(), idInList.size());
    for (Group group : idInList) {
        boolean found = false;
        for (Group otherGroup : list) {
            if (otherGroup.getId().equals(group.getId())) {
                found = true;
                break;
            }
        }
        if (!found) {
            fail("Expected to find group " + group);
        }
    }
}