package cbsfs.cn.activity;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.ProcessDefinition;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class Part2_ProcessDefinition {
    @Autowired
    private RepositoryService repositoryService;
    // 声明并自动装配RepositoryService
    // 查询流程定义
    @Test
    public void getDefinitions() {
        // 调用RepositoryService的方法来查询所有的流程定义
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
        for (ProcessDefinition pd : list) {
            System.out.println("------流程定义--------");
            // 输出流程定义的名称、关键字、资源名称、部署ID和版本号
            System.out.println("Name：" + pd.getName());
            System.out.println("Key：" + pd.getKey());
            System.out.println("ResourceName：" + pd.getResourceName());
            System.out.println("DeploymentId：" + pd.getDeploymentId());
            System.out.println("Version：" + pd.getVersion());
        }
    }
    // 删除流程定义
    @Test
    public void delDefinition() {
        // 要删除的流程定义的部署ID
        String DeploymentId = "2577080d-faf6-11ed-8c18-22038c0a7b1d";
        // 通过RepositoryService删除指定流程定义。第二个参数表示是否级联删除相关的流程实例、历史等数据。
        repositoryService.deleteDeployment(DeploymentId, true);//true删除所有历史记录，false保留历史（实际项目中使用）
        // 打印删除成功信息
        System.out.println("删除流程定义成功");
    }
    //删除所有的流程定义
    @Test
    public void delDefinitionAll() {
        // 获取所有流程定义的列表
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
        // 遍历每一个流程定义
        for (ProcessDefinition pd : list) {
            // 删除包含该流程定义以及相关运行数据（例如流程实例和任务实例）的部署
            repositoryService.deleteDeployment(pd.getDeploymentId(), true);//true删除所有历史记录，false保留历史（实际项目中使用）
            // 打印消息，指示已删除该流程定义
            System.out.println("删除" + pd.getName());
        }
    }
}

package cbsfs.cn.activity;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part3_ProcessInstance {

    //流程实例相关的接口
    @Autowired
    private RuntimeService runtimeService;

    //初始化流程实例
    @Test
    public void initProcessInstance() {
        //1、获取页面表单填报的内容，请假时间，请假事由，String fromData
        //2、fromData 写入业务表，返回业务表主键ID==businessKey
        //3、把业务数据与Activiti7流程数据关联
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_Part1", "bKey001");
        System.out.println("流程实例ID：" + processInstance.getProcessDefinitionId());
    }
    //获取流程实例列表
    @Test
    public void getProcessInstances() {
        List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery().list();
        for (ProcessInstance processInstance : processInstances) {
            System.out.println("--------流程实例------");
            System.out.println("ProcessInstanceId：" + processInstance.getProcessInstanceId());//流程实例id
            System.out.println("ProcessDefinitionId：" + processInstance.getProcessDefinitionId());//流程定义id{key+版本号+UUID}
            System.out.println("isEnded：" + processInstance.isEnded());//流程是否执行完成
            System.out.println("isSuspended：" + processInstance.isSuspended());//流程实例是否被挂起
        }
    }
    //暂停与激活流程实例
    @Test
    public void activitieProcessInstance() {
        //流程实例挂起suspendProcessInstanceById
//        runtimeService.suspendProcessInstanceById("04b381e5-fc66-11ed-b5ab-22038c0a7b1d");
//        System.out.println("挂起流程实例");
        runtimeService.activateProcessInstanceById("04b381e5-fc66-11ed-b5ab-22038c0a7b1d");
        System.out.println("激活流程实例");
    }
    //删除流程实例
    @Test
    public void delProcessInstance() {
        runtimeService.deleteProcessInstance("04b381e5-fc66-11ed-b5ab-22038c0a7b1d", "删除实例，暂时不用");
        System.out.println("删除流程实例");
    }

}

package cbsfs.cn.activity;

import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part4_Task {

    @Autowired
    private TaskService taskService;
    //任务查询:查询所有任务【管理员用的】
    @Test
    public void getTasks(){
        List<Task> list = taskService.createTaskQuery().list();
        for (Task tk:list){
            System.out.println("ID："+tk.getId());//任务id
            System.out.println("Name："+tk.getName());//名称
            System.out.println("执行人："+tk.getAssignee());//执行人
        }
    }
    //查询我的代办任务
    @Test
    public void getTasksByAssignee(){
        List<Task> list = taskService.createTaskQuery().taskAssignee("wukong").list();
        for (Task tk:list){
            System.out.println("ID："+tk.getId());//任务id
            System.out.println("Name："+tk.getName());//名称
            System.out.println("执行人："+tk.getAssignee());//执行人
        }
    }
    //执行任务

    /**
     * 当所有任务执行完成后，流程实例表，任务表将会清空
     */
    @Test
    public void completeTask(){
        taskService.complete("72830474-fc77-11ed-aa74-22038c0a7b1d");
        System.out.println("完成任务");
    }
    //拾取任务
    @Test
    public void claimTask(){
        Task task=taskService.createTaskQuery().taskId("c13e95b0-fc79-11ed-a256-22038c0a7b1d").singleResult();
        taskService.claim("c13e95b0-fc79-11ed-a256-22038c0a7b1d","bajie");
    }
    //归还与交办任务
    @Test
    public void setA_Task(){
        Task task=taskService.createTaskQuery().taskId("c13e95b0-fc79-11ed-a256-22038c0a7b1d").singleResult();
        taskService.setAssignee("c13e95b0-fc79-11ed-a256-22038c0a7b1d","bajie");//归还候选任务
        taskService.setAssignee("c13e95b0-fc79-11ed-a256-22038c0a7b1d","wukong");//交办候选任务
    }
}

package cbsfs.cn.activity;

import org.activiti.engine.HistoryService;
import org.activiti.engine.history.HistoricTaskInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part5_HistoricTaskInstance {
    @Autowired
    private HistoryService historyService;

    //根据用户名查询历史记录
    @Test
    public void HistoricTaskInstanceByUser(){
        List<HistoricTaskInstance> list = historyService
                .createHistoricTaskInstanceQuery()
                .orderByHistoricTaskInstanceEndTime().asc()// 排序 asc 正序
                .taskAssignee("wukong")
                .list();
        for(HistoricTaskInstance hi : list){
            System.out.println("Id："+ hi.getId());//任务id
            System.out.println("ProcessInstanceId："+ hi.getProcessInstanceId());//流程实例id
            System.out.println("Name："+ hi.getName());//流程名称
            System.out.println("Time："+ hi.getTime());
        }
    }


    //根据流程实例ID查询历史
    @Test
    public void HistoricTaskInstanceByPiID(){
        List<HistoricTaskInstance> list = historyService
                .createHistoricTaskInstanceQuery()
                .orderByHistoricTaskInstanceEndTime().asc()
                .processInstanceId("fb2345a6-fc71-11ed-a1cb-22038c0a7b1d")
                .list();
        for(HistoricTaskInstance hi : list){
            System.out.println("Id："+ hi.getId());
            System.out.println("ProcessInstanceId："+ hi.getProcessInstanceId());
            System.out.println("Name："+ hi.getName());
        }
    }
}

package cbsfs.cn.activity;


import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.Map;

@SpringBootTest
public class Part6_UEL {


    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    //启动流程实例带参数，指定执行人
    @Test
    public void initProcessInstanceWithArgs() {
        //流程变量 ${ZhiXingRen}
        //Key:ZhiXingRen Value: wukong
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("ZhiXingRen", "wukong");
        //variables.put("ZhiXingRen2", "aaa");
        //variables.put("ZhiXingRen3", "wukbbbong");
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_UEL_V1"
                        , "bKey002"
                        , variables);
        System.out.println("流程实例ID：" + processInstance.getProcessDefinitionId());

    }

    //完成任务带参数，指定流程变量测试
    @Test
    public void completeTaskWithArgs() {
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("pay", "200");
        taskService.complete("8fc2298b-fc90-11ed-9e5a-22038c0a7b1d",variables);
        System.out.println("完成任务");
    }

    //启动流程实例带参数，使用实体类
    @Test
    public void initProcessInstanceWithClassArgs() {
        UEL_POJO uel_pojo = new UEL_POJO();
        uel_pojo.setZhixingren("bajie");

        //流程变量
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("uelpojo", uel_pojo);

        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_uelv3"
                        , "bKey002"
                        , variables);
        System.out.println("流程实例ID：" + processInstance.getProcessDefinitionId());

    }

    //任务完成环节带参数，指定多个候选人
    @Test
    public void initProcessInstanceWithCandiDateArgs() {
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("houxuanren", "wukong,tangseng");
        taskService.complete("7c791c8d-fc92-11ed-b14f-22038c0a7b1d",variables);
        System.out.println("完成任务");
    }

    //直接指定流程变量
    @Test
    public void otherArgs() {
        runtimeService.setVariable("4f6c9e23-d3ae-11ea-82ba-dcfb4875e032","pay","101");
//        runtimeService.setVariables(); 设置多个参数
//        taskService.setVariable(); 通过任务节点id设置变量
//        taskService.setVariables();通过任务节点id设置多个变量

    }

    //局部变量
    @Test
    public void otherLocalArgs() {
        runtimeService.setVariableLocal("4f6c9e23-d3ae-11ea-82ba-dcfb4875e032","pay","101");
//        runtimeService.setVariablesLocal();设置多个参数
//        taskService.setVariableLocal();通过任务节点id设置变量
//        taskService.setVariablesLocal();通过任务节点id设置多个变量
    }

}

package cbsfs.cn.activity;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.HashMap;
import java.util.Map;
@SpringBootTest
public class Part7_Gateway {
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
//启动流程实例
    @Test
    public void initProcessInstance() {
        // 通过流程定义的key启动一个名为"myProcess_Inclusive"的流程实例
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey(
                        "myProcess_Parallel");
        // 打印流程实例ID
        System.out.println("流程实例ID：" + processInstance.getProcessDefinitionId());
    }
    @Test
    public void completeTask() {
        // 创建一个Map对象，用于设置任务变量
        Map<String, Object> variables = new HashMap<String, Object>();

        /*
         * 完成两个任务，任务ID分别为"398a746e-d3ce-11ea-8bb4-dcfb4875e032"和
         * "398a7470-d3ce-11ea-8bb4-dcfb4875e032"。这里假设这两个任务是在同一个
         * 流程实例中。
         */
        taskService.complete("1d861ffc-fc91-11ed-89a2-22038c0a7b1d");
        taskService.complete("2691c1d4-fc90-11ed-8338-22038c0a7b1d");
        // 打印完成任务的提示信息
        System.out.println("完成任务");
    }
}

/*
 * Copyright 2010-2020 Alfresco Software, Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package cbsfs.cn.activity.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import static java.util.Arrays.asList;

@Configuration
public class DemoApplicationConfiguration {

    private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);

    @Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        String[][] usersGroupsAndRoles = {//GROUP_activitiTeam 用户组  //ROLE_ACTIVITI_USER角色
                {"bob", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"bajie", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"wukong", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"system", "password", "ROLE_ACTIVITI_USER"},
                {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
        };

        for (String[] user : usersGroupsAndRoles) {
            List<String> authoritiesStrings = asList(Arrays.copyOfRange(user, 2, user.length));
            logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]");
            inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]),
                    authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));
        }


        return inMemoryUserDetailsManager;
    }


    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}

/*
 * Copyright 2010-2020 Alfresco Software, Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package cbsfs.cn.activity.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;

import java.util.Collection;

@Component
public class SecurityUtil {

    private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);

    @Autowired
    private UserDetailsService userDetailsService;

    public void logInAs(String username) {

        UserDetails user = userDetailsService.loadUserByUsername(username);
        if (user == null) {
            throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
        }
        logger.info("> Logged in as: " + username);
        SecurityContextHolder.setContext(new SecurityContextImpl(new Authentication() {
            @Override
            public Collection<? extends GrantedAuthority> getAuthorities() {
                return user.getAuthorities();
            }

            @Override
            public Object getCredentials() {
                return user.getPassword();
            }

            @Override
            public Object getDetails() {
                return user;
            }

            @Override
            public Object getPrincipal() {
                return user;
            }

            @Override
            public boolean isAuthenticated() {
                return true;
            }

            @Override
            public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {

            }

            @Override
            public String getName() {
                return user.getUsername();
            }
        }));
        org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
    }
}

 String[][] usersGroupsAndRoles = {//GROUP_activitiTeam 用户组  //ROLE_ACTIVITI_USER角色
                {"bob", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"bajie", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"wukong", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"system", "password", "ROLE_ACTIVITI_USER"},
                {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
        };

package cbsfs.cn.activity;

import cbsfs.cn.activity.config.SecurityUtil;
import org.activiti.api.model.shared.model.VariableInstance;
import org.activiti.api.process.model.ProcessInstance;
import org.activiti.api.process.model.builders.ProcessPayloadBuilder;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part8_ProcessRuntime {

    @Autowired
    private ProcessRuntime processRuntime;

    @Autowired
    private SecurityUtil securityUtil;//模拟登录工具类

    //获取流程实例
    @Test
    public void getProcessInstance() {
        securityUtil.logInAs("bajie"); // 模拟用户登录，这里登录的是名为 "bajie" 的用户
        Page<ProcessInstance> processInstancePage = processRuntime
                .processInstances(Pageable.of(0,100)); // 分页查询流程实例，每页显示 100 条记录
        System.out.println("流程实例数量："+processInstancePage.getTotalItems()); // 打印流程实例总数
        List<ProcessInstance> list = processInstancePage.getContent(); // 获取当前页的流程实例列表
        for(ProcessInstance pi : list){ // 遍历流程实例列表
            System.out.println("-----------------------");
            System.out.println("getId：" + pi.getId()); // 流程实例 ID
            System.out.println("getName：" + pi.getName()); // 流程实例名称
            System.out.println("getStartDate：" + pi.getStartDate()); // 流程实例启动时间
            System.out.println("getStatus：" + pi.getStatus()); // 流程实例状态
            System.out.println("getProcessDefinitionId：" + pi.getProcessDefinitionId()); // 流程定义 ID
            System.out.println("getProcessDefinitionKey：" + pi.getProcessDefinitionKey()); // 流程定义标识符
        }
    }

    // 启动流程实例
    @Test
    public void startProcessInstance() {
        securityUtil.logInAs("bajie"); // 模拟用户登录，这里登录的是名为 "bajie" 的用户
        ProcessInstance processInstance = processRuntime.start(ProcessPayloadBuilder
                .start()
                .withProcessDefinitionKey("myProcess_ProcessRuntime") // 流程定义标识符
                .withName("第二个流程实例名称") // 流程实例名称
                //.withVariable("","") // 流程变量
                .withBusinessKey("自定义bKey") // 业务键
                .build()
        );
    }


    // 删除流程实例
    @Test
    public void delProcessInstance() {
        securityUtil.logInAs("bajie"); // 模拟用户登录，这里登录的是名为 "bajie" 的用户
        ProcessInstance processInstance = processRuntime.delete(ProcessPayloadBuilder
                .delete()
                .withProcessInstanceId("c80a5483-fefb-11ed-83e0-22038c0a7b1d") // 要删除的流程实例的 ID
                .build()
        );
    }


    // 挂起流程实例
    @Test
    public void suspendProcessInstance() {
        securityUtil.logInAs("bajie"); // 模拟用户登录，这里登录的是名为 "bajie" 的用户
        ProcessInstance processInstance = processRuntime.suspend(ProcessPayloadBuilder
                .suspend()
                .withProcessInstanceId("c8006a6e-fefb-11ed-83e0-22038c0a7b1d") // 要挂起的流程实例的 ID
                .build()
        );
    }


    // 激活流程实例
    @Test
    public void resumeProcessInstance() {
        securityUtil.logInAs("bajie"); // 模拟用户登录，这里登录的是名为 "bajie" 的用户
        ProcessInstance processInstance = processRuntime.resume(ProcessPayloadBuilder
                .resume()
                .withProcessInstanceId("c8006a6e-fefb-11ed-83e0-22038c0a7b1d") // 要激活的流程实例的 ID
                .build()
        );
    }


    // 获取流程实例参数
    @Test
    public void getVariables() {
        securityUtil.logInAs("bajie"); // 模拟用户登录，这里登录的是名为 "bajie" 的用户
        List<VariableInstance> list = processRuntime.variables(ProcessPayloadBuilder
                .variables()
                .withProcessInstanceId("c8006a6e-fefb-11ed-83e0-22038c0a7b1d") // 要获取参数的流程实例的 ID
                .build()
        );
        for (VariableInstance vi : list) { // 遍历参数列表
            System.out.println("-------------------");
            System.out.println("getName：" + vi.getName()); // 参数名称
            System.out.println("getValue：" + vi.getValue()); // 参数值
            System.out.println("getTaskId：" + vi.getTaskId()); // 参数关联的任务 ID（如果有）
            System.out.println("getProcessInstanceId：" + vi.getProcessInstanceId()); // 参数关联的流程实例 ID
        }
    }

}

package cbsfs.cn.activity;

import cbsfs.cn.activity.config.SecurityUtil;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.model.Task;
import org.activiti.api.task.model.builders.TaskPayloadBuilder;
import org.activiti.api.task.runtime.TaskRuntime;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Part9_TaskRuntime {
    @Autowired
    private SecurityUtil securityUtil;

    @Autowired
    private TaskRuntime taskRuntime;

    //获取任务列表
    @Test
    public void getTasks() {
        //模拟用户登录
        securityUtil.logInAs("bajie");
        //获取任务分页列表，每页100条任务记录
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0,100));
        //获取当前页的任务列表
        List<Task> list=tasks.getContent();
        for(Task tk : list){
            System.out.println("-------------------");
            System.out.println("getId："+ tk.getId()); //打印任务ID
            System.out.println("getName："+ tk.getName()); //打印任务名称
            System.out.println("getStatus："+ tk.getStatus()); //打印任务状态
            System.out.println("getCreatedDate："+ tk.getCreatedDate()); //打印任务创建时间
            if(tk.getAssignee() == null){
                //如果候选人为当前用户，则任务需要从候选池中领取
                System.out.println("Assignee：待拾取任务"+tk.toString());
            }else{
                //否则打印任务的负责人
                System.out.println("Assignee："+ tk.getAssignee());
            }
        }
    }

    //完成任务
    @Test
    public void completeTask() {
        //模拟用户登录
        securityUtil.logInAs("bajie");
        //根据任务ID获取任务实例
        Task task = taskRuntime.task("c80a5483-fefb-11ed-83e0-22038c0a7b1d");
        if(task.getAssignee() == null){
        //如果任务没有被认领，则将任务分配给当前用户
            taskRuntime.claim(TaskPayloadBuilder.claim()
                    .withTaskId(task.getId())
                    .build());
        }
        //执行任务
        taskRuntime.complete(TaskPayloadBuilder
                .complete()
                .withTaskId(task.getId())
                .build());
        System.out.println("任务执行完成");
    }
}

package cbsfs.cn.activity.pojo;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Collectors;

/**
 * 用户信息实体类，实现了Spring Security的UserDetails接口
 */
@Component
public class UserInfoBean implements UserDetails {
    // 用户ID
    private Long id;
    // 用户姓名
    private String name;
    // 用户地址
    private String address;
    // 用户密码
    private String password;
    // 用户名
    private String username;
    // 用户角色，多个角色用逗号隔开
    private String roles;

    /**
     * 获取用户地址
     *
     * @return 用户地址
     */
    public String getAddress() {
        return address;
    }

    /**
     * 获取用户权限列表，包括角色和权限等
     *
     * @return 用户权限列表
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Arrays.stream(roles.split(",")).map(
                s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList());
    }

    /**
     * 获取用户密码
     *
     * @return 用户密码
     */
    @Override
    public String getPassword() {
        return password;
    }

    /**
     * 获取用户名称
     *
     * @return 用户名称
     */
    @Override
    public String getUsername() {
        return username;
    }

    /**
     * 判断账户是否未过期
     *
     * @return true表示账户未过期，false表示账户已经过期
     */
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    /**
     * 判断账户是否未锁定
     *
     * @return true表示账户未锁定，false表示账户已经被锁定
     */
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    /**
     * 判断用户凭证是否未过期
     *
     * @return true表示用户凭证未过期，false表示用户凭证已经过期
     */
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    
    /**
     * 判断用户是否可用
     *
     * @return true表示用户可用，false表示用户不可用
     */
    @Override
    public boolean isEnabled() {
        return true;
    }
}

package cbsfs.cn.activity.mapper;

import cbsfs.cn.activity.pojo.UserInfoBean;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

/**
* @auther admin闫
* @Descriptopn
* @date 2023/5/31 21:53
*/
@Mapper
@Component
public interface UserInfoBeanMapper {
    /**
     * 根据用户名查询用户信息
     * @return 用户信息
     */
    @Select("select * from user where username = #{username}")
    UserInfoBean selectByUsername( @Param("username") String username);

}

package cbsfs.cn.activity.security;

import cbsfs.cn.activity.mapper.UserInfoBeanMapper;
import cbsfs.cn.activity.pojo.UserInfoBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @auther admin闫
 * @Descriptopn security登录类
 * @date 2023/5/31 21:15
 */
@Component
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    UserInfoBeanMapper userInfoBeanMapper;

    /**
     * 获取账号密码方法
     * @param username 账号
     * @return  账号，密码，权限
     * @throws UsernameNotFoundException 用户名错误异常
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 使用Spring Security提供的密码编码器生成"111"的哈希值密码
//        String password = passwordEncoder().encode("111");
        // 创建一个新的User对象，包含给定的用户名、哈希密码以及"ROLE_ACTIVITI_USER"权限
//        return new User(username
//                , password
//                , AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_ACTIVITI_USER"));
        //读取数据库用户
        UserInfoBean userInfoBean=userInfoBeanMapper.selectByUsername(username);
        if (username==null){
            throw new UsernameNotFoundException("数据库中没有用户");
        }
        return userInfoBean;

    }
    /**
     * 重写密码加密
     * @return Bean对象
     */
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

}

package cbsfs.cn.activity.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

/**
 * @auther admin闫
 * @Descriptopn Security 配置类
 * @date 2023/6/3 15:06
 */
@Configuration
public class ActivitiSecurityConfig extends WebSecurityConfigurerAdapter {


    @Autowired
    private LoginSuccessHandler loginSuccessHandler;
    /**
     * 方法是 Spring Security 提供的一种基于 Java 代码配置安全性的方式。它允许我们在其中定义我们应用程序的安全性规则。
     * 在该方法中，参数 http 是一个 HttpSecurity 对象，用于配置 web 安全性。
     * 通过该对象，我们可以配置登录、权限、注销、CSRF 防护等方面的安全控制。
     * @param http HttpSecurity对象
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin() // 开启表单登录，如果没有登录会跳转到默认的/login路径
                .loginPage("/login") // 定义自定义的登录页面路径
                .successHandler(loginSuccessHandler) // 登录成功后执行的方法
                .and().authorizeRequests() // 配置权限
                .anyRequest().permitAll() // 所有请求都允许通过
                .and().logout().permitAll() // 允许注销登录
                .and().csrf().disable() // 禁用 CSRF 防护功能
                .headers().frameOptions().disable(); // 禁用 X-Frame-Options，支持在 iframe 中显示网页内容
    }
}

package cbsfs.cn.activity.security;

import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @auther admin闫
 * @Descriptopn 登录成功的处理类
 * @date 2023/6/3 15:28
 */
@Component("loginSuccessHandler")
public class LoginSuccessHandler implements AuthenticationSuccessHandler {

    /**
     * 重写接口中的方法，处理认证成功后的操作
     * 表单的请求方法
     * @param request 当前请求
     * @param response 当前响应
     * @param chain 当前过滤器链
     * @param authentication 认证对象
     * @throws IOException 发生 I/O 异常时抛出
     * @throws ServletException 发生 Servlet 异常时抛出
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException, ServletException {
//        // 调用父类中的同名方法，继续执行过滤器链中的下一个过滤器
//        AuthenticationSuccessHandler.super.onAuthenticationSuccess(request, response, chain, authentication);
    }

    /**
     * 重写接口中的方法，处理认证成功后的操作
     * Ajax响应请求的方法
     * @param httpServletRequest 当前请求
     * @param httpServletResponse 当前响应
     * @param authentication 认证对象
     * @throws IOException 发生 I/O 异常时抛出
     * @throws ServletException 发生 Servlet 异常时抛出
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        httpServletResponse.getWriter().write("登录成功！LoginSuccessHandler"+authentication.getName());
    }
}

package cbsfs.cn.activity.security;

import org.springframework.http.HttpStatus;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @auther admin闫
 * @Descriptopn 登录失败的处理方法
 * @date 2023/6/3 15:54
 */
@Component("loginFailureHandler") // 声明为 Spring Bean，可在其他组件依赖注入
public class LoginFailureHandler implements AuthenticationFailureHandler {


    /**
     * 登录认证失败后的处理方法
     *
     * @param httpServletRequest HTTP 请求
     * @param httpServletResponse HTTP 响应
     * @param e 认证异常信息
     * @throws IOException 异常信息
     * @throws ServletException 异常信息
     */
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest,
                                        HttpServletResponse httpServletResponse,
                                        AuthenticationException e) throws IOException, ServletException {
        httpServletResponse.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value()); // 设置响应状态码为 500（服务器内部错误）
        httpServletResponse.setContentType("application/json;charset=UTF-8"); // 设置响应内容的类型为 JSON 格式
        httpServletResponse.getWriter().write("登录失败！原因是" + e.getMessage()); // 返回错误消息给客户端
    }
}