Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

spring-activiti/src/main/java/com/baeldung/activiti/security/config/MvcConfig.java

@@ -0,0 +1,20 @@
+package com.baeldung.activiti.security.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+
+@Configuration
+@EnableWebMvc
+public class MvcConfig extends WebMvcConfigurerAdapter {
+
+    @Override
+    public void addViewControllers(ViewControllerRegistry registry) {
+        registry.addViewController("/login")
+            .setViewName("login");
+        registry.addViewController("/homepage")
+            .setViewName("homepage");
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/config/ProcessController.java

@@ -0,0 +1,54 @@
+package com.baeldung.activiti.security.config;
+
+import java.util.List;
+
+import org.activiti.engine.IdentityService;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
+import org.activiti.spring.SpringProcessEngineConfiguration;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class ProcessController {
+
+    @Autowired
+    private RuntimeService runtimeService;
+
+    @Autowired
+    private TaskService taskService;
+
+    @Autowired
+    private IdentityService identityService;
+
+    @Autowired
+    SpringProcessEngineConfiguration config;
+
+    @GetMapping("/protected-process")
+    public String startProcess() {
+
+        String userId = SecurityContextHolder.getContext()
+            .getAuthentication()
+            .getName();
+
+        identityService.setAuthenticatedUserId(userId);
+
+        ProcessInstance pi = runtimeService.startProcessInstanceByKey("protected-process");
+
+        List<Task> usertasks = taskService.createTaskQuery()
+            .processInstanceId(pi.getId())
+            .list();
+
+        taskService.complete(usertasks.iterator()
+            .next()
+            .getId());
+
+        return "Process started. Number of currently running process instances = " + runtimeService.createProcessInstanceQuery()
+            .count();
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/config/SpringSecurityGroupManager.java

@@ -0,0 +1,86 @@
+package com.baeldung.activiti.security.config;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.GroupQuery;
+import org.activiti.engine.impl.GroupQueryImpl;
+import org.activiti.engine.impl.Page;
+import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
+import org.activiti.engine.impl.persistence.entity.GroupEntityImpl;
+import org.activiti.engine.impl.persistence.entity.GroupEntityManagerImpl;
+import org.activiti.engine.impl.persistence.entity.data.GroupDataManager;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.provisioning.JdbcUserDetailsManager;
+
+public class SpringSecurityGroupManager extends GroupEntityManagerImpl {
+
+    private JdbcUserDetailsManager userManager;
+
+    public SpringSecurityGroupManager(ProcessEngineConfigurationImpl processEngineConfiguration, GroupDataManager groupDataManager) {
+        super(processEngineConfiguration, groupDataManager);
+    }
+
+    @Override
+    public List<Group> findGroupByQueryCriteria(GroupQueryImpl query, Page page) {
+
+        if (query.getUserId() != null) {
+            return findGroupsByUser(query.getUserId());
+        }
+        return null;
+    }
+
+    @Override
+    public long findGroupCountByQueryCriteria(GroupQueryImpl query) {
+        return findGroupByQueryCriteria(query, null).size();
+    }
+
+    @Override
+    public List<Group> findGroupsByUser(String userId) {
+        UserDetails userDetails = userManager.loadUserByUsername(userId);
+        System.out.println("group manager");
+        if (userDetails != null) {
+            List<Group> groups = userDetails.getAuthorities()
+                .stream()
+                .map(a -> a.getAuthority())
+                .map(a -> {
+                    Group g = new GroupEntityImpl();
+                    g.setId(a);
+                    return g;
+                })
+                .collect(Collectors.toList());
+            return groups;
+        }
+        return null;
+    }
+
+    public void setUserManager(JdbcUserDetailsManager userManager) {
+        this.userManager = userManager;
+    }
+
+    public Group createNewGroup(String groupId) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+
+    }
+
+    @Override
+    public void delete(String groupId) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+
+    }
+
+    public GroupQuery createNewGroupQuery() {
+        throw new UnsupportedOperationException("This operation is not supported!");
+    }
+
+    public List<Group> findGroupsByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+    }
+
+    public long findGroupCountByNativeQuery(Map<String, Object> parameterMap) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/config/SpringSecurityUserManager.java

@@ -0,0 +1,144 @@
+package com.baeldung.activiti.security.config;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.User;
+import org.activiti.engine.identity.UserQuery;
+import org.activiti.engine.impl.Page;
+import org.activiti.engine.impl.UserQueryImpl;
+import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
+import org.activiti.engine.impl.persistence.entity.GroupEntityImpl;
+import org.activiti.engine.impl.persistence.entity.UserEntity;
+import org.activiti.engine.impl.persistence.entity.UserEntityImpl;
+import org.activiti.engine.impl.persistence.entity.UserEntityManagerImpl;
+import org.activiti.engine.impl.persistence.entity.data.UserDataManager;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.provisioning.JdbcUserDetailsManager;
+
+public class SpringSecurityUserManager extends UserEntityManagerImpl {
+
+    private JdbcUserDetailsManager userManager;
+
+    public SpringSecurityUserManager(ProcessEngineConfigurationImpl processEngineConfiguration, UserDataManager userDataManager, JdbcUserDetailsManager userManager) {
+        super(processEngineConfiguration, userDataManager);
+        this.userManager = userManager;
+    }
+
+    @Override
+    public UserEntity findById(String userId) {
+        UserDetails userDetails = userManager.loadUserByUsername(userId);
+        if (userDetails != null) {
+            UserEntityImpl user = new UserEntityImpl();
+            user.setId(userId);
+            return user;
+        }
+        return null;
+
+    }
+
+    @Override
+    public List<User> findUserByQueryCriteria(UserQueryImpl query, Page page) {
+        List<User> users = null;
+        if (query.getGroupId() != null) {
+            users = userManager.findUsersInGroup(query.getGroupId())
+                .stream()
+                .map(username -> {
+                    User user = new UserEntityImpl();
+                    user.setId(username);
+                    return user;
+                })
+                .collect(Collectors.toList());
+            if (page != null) {
+                return users.subList(page.getFirstResult(), page.getFirstResult() + page.getMaxResults());
+
+            }
+            return users;
+        }
+
+        if (query.getId() != null) {
+            UserDetails userDetails = userManager.loadUserByUsername(query.getId());
+            if (userDetails != null) {
+                UserEntityImpl user = new UserEntityImpl();
+                user.setId(query.getId());
+                return Collections.singletonList(user);
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Boolean checkPassword(String userId, String password) {
+        return true;
+    }
+
+    public void setUserManager(JdbcUserDetailsManager userManager) {
+        this.userManager = userManager;
+    }
+
+    public User createNewUser(String userId) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+    }
+
+    public void updateUser(User updatedUser) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+
+    }
+
+    public void delete(UserEntity userEntity) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+
+    }
+
+    @Override
+    public void deletePicture(User user) {
+        UserEntity userEntity = (UserEntity) user;
+        if (userEntity.getPictureByteArrayRef() != null) {
+            userEntity.getPictureByteArrayRef()
+                .delete();
+        }
+    }
+
+    public void delete(String userId) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+
+    }
+
+    public long findUserCountByQueryCriteria(UserQueryImpl query) {
+        return findUserByQueryCriteria(query, null).size();
+    }
+
+    public List<Group> findGroupsByUser(String userId) {
+        UserDetails userDetails = userManager.loadUserByUsername(userId);
+        if (userDetails != null) {
+            List<Group> groups = userDetails.getAuthorities()
+                .stream()
+                .map(a -> a.getAuthority())
+                .map(a -> {
+                    Group g = new GroupEntityImpl();
+                    g.setId(a);
+                    return g;
+                })
+                .collect(Collectors.toList());
+            return groups;
+        }
+        return null;
+    }
+
+    public UserQuery createNewUserQuery() {
+        throw new UnsupportedOperationException("This operation is not supported!");
+    }
+
+    public List<User> findUsersByNativeQuery(Map<String, Object> parameterMap, int firstResult, int maxResults) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+    }
+
+    public long findUserCountByNativeQuery(Map<String, Object> parameterMap) {
+        throw new UnsupportedOperationException("This operation is not supported!");
+
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/withactiviti/SecurityConfig.java

@@ -0,0 +1,47 @@
+package com.baeldung.activiti.security.withactiviti;
+
+import org.activiti.engine.IdentityService;
+import org.activiti.spring.security.IdentityServiceUserDetailsService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+
+@Configuration
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+
+    protected void configure(HttpSecurity http) throws Exception {
+        http.antMatcher("/**")
+            .authorizeRequests()
+            .antMatchers("/protected-process*")
+            .authenticated()
+            .anyRequest()
+            .permitAll()
+            .and()
+            .formLogin()
+            .loginPage("/login")
+            .defaultSuccessUrl("/homepage")
+            .failureUrl("/login?error=true")
+            .and()
+            .csrf()
+            .disable()
+            .logout()
+            .logoutSuccessUrl("/login");
+    }
+
+    @Autowired
+    private IdentityService identityService;
+
+    @Bean
+    public IdentityServiceUserDetailsService userDetailsService() {
+        return new IdentityServiceUserDetailsService(identityService);
+    }
+
+    @Autowired
+    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
+        auth.userDetailsService(userDetailsService());
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/withactiviti/SpringSecurityActivitiApplication.java

@@ -0,0 +1,34 @@
+package com.baeldung.activiti.security.withactiviti;
+
+import org.activiti.engine.IdentityService;
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.User;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication(scanBasePackages = { "com.baeldung.activiti.security.config", "com.baeldung.activiti.security.withactiviti" })
+public class SpringSecurityActivitiApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringSecurityActivitiApplication.class, args);
+    }
+
+    @Bean
+    InitializingBean usersAndGroupsInitializer(IdentityService identityService) {
+        return new InitializingBean() {
+            public void afterPropertiesSet() throws Exception {
+                User user = identityService.newUser("activiti_user");
+                user.setPassword("pass");
+                identityService.saveUser(user);
+
+                Group group = identityService.newGroup("user");
+                group.setName("ROLE_USER");
+                group.setType("USER");
+                identityService.saveGroup(group);
+                identityService.createMembership(user.getId(), group.getId());
+            }
+        };
+    }
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/withspring/ActivitiSpringSecurityApplication.java

@@ -0,0 +1,39 @@
+package com.baeldung.activiti.security.withspring;
+
+import org.activiti.engine.impl.persistence.entity.data.impl.MybatisGroupDataManager;
+import org.activiti.engine.impl.persistence.entity.data.impl.MybatisUserDataManager;
+import org.activiti.spring.SpringProcessEngineConfiguration;
+import org.activiti.spring.boot.SecurityAutoConfiguration;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.security.provisioning.JdbcUserDetailsManager;
+
+import com.baeldung.activiti.security.config.SpringSecurityGroupManager;
+import com.baeldung.activiti.security.config.SpringSecurityUserManager;
+
+@SpringBootApplication(exclude = SecurityAutoConfiguration.class, scanBasePackages = { "com.baeldung.activiti.security.config", "com.baeldung.activiti.security.withspring" })
+public class ActivitiSpringSecurityApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ActivitiSpringSecurityApplication.class, args);
+    }
+
+    @Autowired
+    private SpringProcessEngineConfiguration processEngineConfiguration;
+
+    @Autowired
+    private JdbcUserDetailsManager userManager;
+
+    @Bean
+    InitializingBean processEngineInitializer() {
+        return new InitializingBean() {
+            public void afterPropertiesSet() throws Exception {
+                processEngineConfiguration.setUserEntityManager(new SpringSecurityUserManager(processEngineConfiguration, new MybatisUserDataManager(processEngineConfiguration), userManager));
+                processEngineConfiguration.setGroupEntityManager(new SpringSecurityGroupManager(processEngineConfiguration, new MybatisGroupDataManager(processEngineConfiguration)));
+            }
+        };
+    }
+}

spring-activiti/src/main/java/com/baeldung/activiti/security/withspring/SecurityConfig.java

@@ -0,0 +1,50 @@
+package com.baeldung.activiti.security.withspring;
+
+import javax.sql.DataSource;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.provisioning.JdbcUserDetailsManager;
+
+@Configuration
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+
+    @Autowired
+    private DataSource dataSource;
+
+    protected void configure(HttpSecurity http) throws Exception {
+        http.antMatcher("/**")
+            .authorizeRequests()
+            .antMatchers("/protected-process*")
+            .authenticated()
+            .anyRequest()
+            .permitAll()
+            .and()
+            .formLogin()
+            .loginPage("/login")
+            .defaultSuccessUrl("/homepage")
+            .failureUrl("/login?error=true")
+            .and()
+            .csrf()
+            .disable()
+            .logout()
+            .logoutSuccessUrl("/login");
+    }
+
+    @Bean
+    public JdbcUserDetailsManager userDetailsManager() {
+        JdbcUserDetailsManager manager = new JdbcUserDetailsManager();
+        manager.setDataSource(dataSource);
+        return manager;
+    }
+
+    @Autowired
+    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
+        auth.userDetailsService(userDetailsManager());
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activitiwithspring/ActivitiController.java

@@ -0,0 +1,52 @@
+package com.baeldung.activitiwithspring;
+
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.task.Task;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+public class ActivitiController {
+    private static final Logger logger = LoggerFactory.getLogger(ActivitiController.class);
+
+    @Autowired
+    private RuntimeService runtimeService;
+
+    @Autowired
+    private TaskService taskService;
+
+    @GetMapping("/start-process")
+    public String startProcess() {
+        runtimeService.startProcessInstanceByKey("my-process");
+        return "Process started. Number of currently running process instances = " + runtimeService.createProcessInstanceQuery()
+          .count();
+    }
+
+    @GetMapping("/get-tasks/{processInstanceId}")
+    public List<TaskRepresentation> getTasks(@PathVariable String processInstanceId) {
+        List<Task> usertasks = taskService.createTaskQuery()
+          .processInstanceId(processInstanceId)
+          .list();
+
+        return usertasks.stream()
+          .map(task -> new TaskRepresentation(task.getId(), task.getName(), task.getProcessInstanceId()))
+          .collect(Collectors.toList());
+    }
+
+    @GetMapping("/complete-task-A/{processInstanceId}")
+    public void completeTaskA(@PathVariable String processInstanceId) {
+        Task task = taskService.createTaskQuery()
+          .processInstanceId(processInstanceId)
+          .singleResult();
+        taskService.complete(task.getId());
+        logger.info("Task completed");
+    }
+}

spring-activiti/src/main/java/com/baeldung/activitiwithspring/ActivitiWithSpringApplication.java

@@ -0,0 +1,12 @@
+package com.baeldung.activitiwithspring;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration;
+
+@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
+public class ActivitiWithSpringApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(ActivitiWithSpringApplication.class, args);
+    }
+}

spring-activiti/src/main/java/com/baeldung/activitiwithspring/TaskRepresentation.java

@@ -0,0 +1,43 @@
+package com.baeldung.activitiwithspring;
+
+class TaskRepresentation {
+
+    private String id;
+    private String name;
+    private String processInstanceId;
+
+    public TaskRepresentation() {
+        super();
+    }
+
+    public TaskRepresentation(String id, String name, String processInstanceId) {
+        this.id = id;
+        this.name = name;
+        this.processInstanceId = processInstanceId;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getProcessInstanceId() {
+        return processInstanceId;
+    }
+
+    public void setProcessInstanceId(String processInstanceId) {
+        this.processInstanceId = processInstanceId;
+    }
+
+}

spring-activiti/src/main/java/com/baeldung/activitiwithspring/servicetasks/SendEmailServiceTask.java

@@ -0,0 +1,12 @@
+package com.baeldung.activitiwithspring.servicetasks;
+
+import org.activiti.engine.delegate.DelegateExecution;
+import org.activiti.engine.delegate.JavaDelegate;
+
+public class SendEmailServiceTask implements JavaDelegate {
+
+    public void execute(DelegateExecution execution) {
+        //logic to sent email confirmation
+    }
+
+}