tip-cq-kaizhou/tip-api/src/main/java/com/minto/app/task/manager/ITaskManager.java

/*
 * Copyright (c) 2014, 2023, Chengdu Minto Technology Co.,LTD. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 */

package com.minto.app.task.manager;

import com.github.pagehelper.PageInfo;
import com.minto.app.task.dto.TaskPanelOutput;
import com.minto.app.task.dto.TaskSummaryDto;
import com.minto.bff.home.dto.GenericParam;
import com.minto.tap.task.dto.TaskSummaryInfo;
import com.minto.tip.affair.po.TipAffair;
import com.minto.app.behavior.beans.BehSummaryBean;
import com.minto.app.dm.beans.MatrixTableColumnDefinition;
import com.minto.app.message.beans.MessageTypeBean;
import com.minto.app.organization.beans.OrgPersonBean;
import com.minto.app.organization.beans.OrgUnitBean;
import com.minto.app.resource.beans.CommonResourceRelationBean;
import com.minto.app.task.beans.*;
import com.minto.app.task.bo.*;
import com.minto.app.task.dto.SaveDraftParam;
import com.minto.app.task.dto.TaskInfo;
import com.minto.app.task.enums.TaskEnum;
import com.minto.app.task.enums.TaskEnum.TaskMemberRelTypeEnum;
import com.minto.app.task.enums.TaskEnum.TaskSummaryProgressStatusEnum;
import com.minto.app.task.enums.TaskPhaseStateEnum;
import com.minto.app.task.vo.*;
import com.minto.tip.affair.enums.AffairEnum;
import com.minto.app.space.beans.SpaceFileBean;
import com.minto.app.tipenum.po.TipEnumBean;
import com.minto.core.base.ListObject;
import com.minto.tip.common.exceptions.BusinessException;
import org.hibernate.criterion.Criterion;
import org.springframework.lang.NonNull;

import java.sql.SQLException;
import java.text.ParseException;
import java.util.*;

public interface ITaskManager {

    /**
     * 获取指定任务下的所有子孙任务，包含自身
     * @author inspired
     * @param superTaskId
     * @return
     */
    List<TaskSummaryBean> findAllTaskByParentId(Long superTaskId);

    /**
     * 根据任务名称查询对应资源id集合 (精准匹配 ，需要like)
     * @author inspired
     * @param titleStr 可以是多个 以（，|,）隔开
     * @return ids
     */
    List<Long> findTaskInfosByTitleStr(String titleStr);

    /**
     * 保存任务与矩阵数据的关联关系,关系不启用（启用了关系列表才能查到关联数据）
     * @author inspired
     * @param taskId
     * @param relTableId
     * @param relDataId
     * @throws BusinessException
     */
    void saveTaskMatrixDataRel(Long taskId, Long relTableId, Long relDataId) throws BusinessException;

    /**
     * 保存任务与关联数据的关联关系,关系不启用（启用了关系列表才能查到关联数据）
     * @author inspired
     * @param taskId
     * @throws BusinessException
     */
    void saveTaskLinkedData(Long taskId, SaveDraftParam param) throws BusinessException;

    /**
     * 启用任务与矩阵数据的关联关系（没有关联则会直接新建一条启用的数据关联）
     * @author inspired
     * @param taskId
     * @param relTableId
     * @param relDataId
     * @throws BusinessException
     */
    void applyTaskMatrixDataRel(Long taskId, Long relTableId, Long relDataId) throws BusinessException;

    /**
     * 启用任务与关联数据的关联关系（没有关联则会直接新建一条启用的数据关联）
     * @param taskId
     * @param param
     * @throws BusinessException
     */
    void applyTaskLinkedData(Long taskId, SaveDraftParam param) throws BusinessException;

    /**
     * 检查目标集组织对象在事项中是否有共享督办权限
     * @author inspired
     * @param taskId
     * @param targetIds
     * @return
     * @throws BusinessException
     */
    List<Long> findTaskSuperviseShare(Long taskId,List<Long> targetIds) throws BusinessException;

    Integer findTaskTypeMaxSort(Long accountId);
    /**
     *  更新事项状态和发消息
     * @param summaryBean
     * @param memberBeanList
     * @param updateMembers
     * @throws BusinessException
     */
    void updateStateAndSendMsg(TaskSummaryBean summaryBean, List<TaskMemberBean> memberBeanList, List<TaskMemberBean> updateMembers) throws BusinessException;

    /**
     * 处理子任务撤回
     * @author inspired
     * @param summaryBean
     * @param updateMembers
     * @param updateSummaries
     * @param updateSummaryIds
     * @param managerRel
     * @throws BusinessException
     */
    void processBackSubTasks(TaskSummaryBean summaryBean,List<TaskMemberBean> updateMembers, List<TaskSummaryBean> updateSummaries,List<Long> updateSummaryIds,  List<Integer> managerRel) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 生成listColumn数据
     * @createTime 2021/6/23 17:53
     */
    ListColumnBean addColumn2ListColumn(MatrixTableColumnDefinition field, Integer type) throws BusinessException;


    /**
     * @author inspired (胡启林)
     * @param
     * @describe 分类获取批量催办成员
     * @createTime 2021/5/12 10:32
     */
    Map<String,Object> findAllUrgeByteType(Integer searchType) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 保存任务关联数据
     * @createTime 2021/4/30 10:26
     */
    void saveTaskFileRelation(Map<String,Object> param) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 外来任务列表
     * @createTime 2021/4/26 11:37
     */
    com.minto.tip.common.util.PageInfo findOutAccountTask(com.minto.tip.common.util.PageInfo info,Map<String,Object> param) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 获取单位顶级事项类型
     * @createTime 2021/4/13 9:48
     */
    TaskTypeBean findRootTypeByAccountId(Long accountId);

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 修改任务阶段
     * @createTime 2021/4/6 17:10
     */
    Boolean updatePhaseByTaskId(Long taskId, Map<String,Object> param) throws BusinessException, SQLException, ParseException;

    /**
     * 根据任务获取某个汇报阶段的成员配置信息
     */
    List<TaskMemberPhaseReportConfig> findTaskMPRCByMemberIdsAndReportConfigId(Long taskId,List<Long> memberIds,Long reportConfigId);

    /**
     * @author inspired (胡启林)
     * @param taskMemberPhaseReportConfig
     * @describe 组装成员汇报灯
     * @createTime 2021/3/31 9:43
     */
    TaskPhaseStateEnum processTaskMemberPhaseReportConfig(TaskMemberPhaseReportConfig taskMemberPhaseReportConfig,TaskMemberBean memberBean) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param tasks 任务
     * @param subType {@link AffairEnum.SubTypeEnum}
     * @param pid
     * @describe 生成事项待办
     * @createTime 2021/3/12 15:21
     */
    Integer saveTaskAffair(List<TaskSummaryBean> tasks, Long pid) throws BusinessException;

    /**
     * 根据任务基本数据结构添加待办数据（新建时使用）
     * @author inspired
     * @param taskInfo {@link TaskInfo}
     * @return
     * @throws BusinessException
     */
    void addTaskAffair(TaskInfo taskInfo) throws BusinessException;

    /**
     * 获取当前阶段
     * @author inspired
     * @param
     * @return
     */
    TaskPhase processCurrentTaskPhase(List<TaskPhase> taskPhases);

    /**
     * 根据大阶段里的汇报阶段获取当前汇报阶段；阶段里需要包含小阶段数据
     * @author inspired
     * @param
     * @return
     */
    TaskPhaseReportConfig processCurrentReportConfig(TaskPhase taskPhase);

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 获取我督办的未完成的事项
     * @createTime 2021/3/10 15:30
     */
    com.minto.tip.common.util.PageInfo findPageMySuperviseTasks(com.minto.tip.common.util.PageInfo info, Map<String,Object> param) throws BusinessException;

    /**
     * 获取不同状态任务数量任务
     * @param param
     * @return
     */
    List<Map<String, Object>> findTaskCount(Map<String, Object> param) throws BusinessException;
    /**
     * @author inspired (胡启林)
     * @param
     * @describe 督办首页任务管理数据统计
     * @createTime 2021/3/19 9:16
     */
    Map<String,Object> countAllTaskByTaskState(Map<String,Object> param) throws BusinessException;

    /**
     * 撤销汇总操作
     * @author inspired
     * @param taskId
     * @param reportId
     * @throws BusinessException
     */
    void processCollectReport(Long taskId,Long reportId) throws BusinessException;

    /**
     * 新首页任务管理统计
     * @param param
     * @return
     * @throws BusinessException
     */
    Map<String, Object> countAllTaskByTaskStateNew(Map<String, Object> param) throws BusinessException;

    List<Integer> getTaskBehTypes();

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 督办事项统计
     * @createTime 2020/12/15 18:38
     */
    Map<String,Integer> countTaskByParam(Map<String,Object> param) throws BusinessException;
    com.minto.tip.common.util.PageInfo findAllTaskByParam(com.minto.tip.common.util.PageInfo info, Map<String,Object> param) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 督办首页饼图穿透数据列表
     * @createTime 2021/4/21 19:41
     */
    com.minto.tip.common.util.PageInfo findSupervisionTaskByParam(com.minto.tip.common.util.PageInfo info, Map<String,Object> param) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 查询分管的事项
     * @createTime 2020/12/15 10:07
     */
    com.minto.tip.common.util.PageInfo findPageInChargeByParam(com.minto.tip.common.util.PageInfo info, Map<String,Object> params);

    /**
     * 承办工作任务
     * @author inspired
     * @param info
     * @param param
     * @return
     */
    com.minto.tip.common.util.PageInfo<TaskSummaryDto> findManagerTask4Param(com.minto.tip.common.util.PageInfo info, Map param) throws BusinessException;

    /**
     * 自定义查询承办事项
     * @author inspired
     * @param param {"title":"","relationType":[],"tstate":[],"mstate":[],"accountId":"","year":2023,"taskTypeIds":[],"resourceIds":[]}
     * @return
     */
    com.minto.tip.common.util.PageInfo<TaskSummaryInfo> findTask4Param(com.minto.tip.common.util.PageInfo info, Map param);

    /**
     * 根据状态获取任务数量
     * @param params
     * @return
     */
    Map<String, Integer> findTaskCountByState(Map<String, Object> params);

    Integer countInChargeByParam(Map<String,Object> params) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 分页查询事项关注数据 领导关注跟我的关注
     * @describe type : 1 我的关注 ；  2 领导关注
     * @createTime 2020/12/11 11:29
     */
    com.minto.tip.common.util.PageInfo findPageFollowsByParams(com.minto.tip.common.util.PageInfo info,Map<String,Object> params);
    Integer findCountFollowsByParams(Map<String,Object> params);

    /**
     * @author inspired (胡启林)
     * @param taskTemplateId 模板名称
     * @param extend 自定义数据
     * @describe 根据任务模板id发布新的任务
     * @createTime 2020/10/16 15:52
     */
    Long saveTaskForTaskTemplateId(Long taskTemplateId,Map<String,Object> extend);

    /**
     * 修改模板基本信息（节点任务使用）
     * @author inspired
     * @param param
     * @return 模板id
     * @throws BusinessException
     */
    Map<String,Object> updateTaskTemplateInfo(Map<String,Object> param) throws BusinessException, ParseException, ReflectiveOperationException;
    Map<String,Object> saveTaskTemplateInfo(Map<String,Object> param) throws BusinessException, ParseException, ReflectiveOperationException;

    /**
     * @author inspired (胡启林)
     * @param templateIds
     * @describe 根据模板id查找下发的任务
     * @createTime 2020/11/30 11:19
     */
    Boolean findUseFlagByTemplateIds(List<Long> templateIds);


    /**查询牵头单位及责任单位的完成时限扩展字段*/
    Map<String,Object> findExtendDataByTaskId(Long taskId, String param) throws BusinessException;
    Boolean checkBasicExtendValueByTaskIdAndField() throws BusinessException;

    /**批量修改完成时限*/
    Integer updateEndDataByTaskIds(List<Map<String, Object>> params,Boolean editEndDate) throws BusinessException;
    /**
     * 修改单位
     */
    Integer updateTaskDataByParam(List<Map<String, Object>> params) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param taskIds
     * @param status {@link TaskSummaryProgressStatusEnum}
     * @describe 修改任务进度状态
     * @createTime 2020/11/18 20:04
     */
    Integer updateTaskProcessStatus(List<Long> taskIds,Integer status);

    /**
     * 添加成员至指定任务，通用方法
     * @param taskId
     * @param resourceType
     * @param resourceId
     * @param relationType
     * @param taskTypeBean
     * @return
     */
    Long  addTaskMemberInfo(Long taskId, Integer resourceType, Long resourceId, Integer relationType, TaskTypeBean taskTypeBean, String node);

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 重大项目挂图督办处理地图数据
     * @createTime 2019/10/9 10:04
     */
    List<Map<String,Object>> processMapData(List<Map<String, Object>> summaryList) throws BusinessException;

    /**
     * 返回经纬度数组
     */
    Double[] getAllAddrIpsByTaskId(Long taskId) throws BusinessException;

    public List<TaskProcessBO> findSubProcessBos(Long parentId, Long parentType) throws BusinessException;

    public void releaseTask(String ids) throws BusinessException;
    /**
     * 查询截止到当前时间时间进度刚好到一半的任务(时间差不得超过一分钟)
     * @return
     * @throws BusinessException
     */
    public List<TaskBO> findTaskByHalfTImeProcess() throws BusinessException;

    /**
     * 根据事项状态和事项关联类型查询即将到期的事项数量
     */
    public Integer findTaskByHalfTImeProcessByCount(Long cid, Long pid, Integer[] states, Integer[] memberRelations) throws BusinessException;

    public List<TaskSummaryBean> findTaskByHalfTImeProcessByCountList(Long cid, Long pid, Integer[] states, Integer[] memberRelations) throws BusinessException;

    public List<TaskSummaryBean> findTaskByHalfTImeProcessByList(Long cid, Long pid, Long cuurentPid, Integer[] states, Integer[] memberRelations) throws BusinessException;

    /**
     * 查询截止到指定时间的到期任务
     * @param endDate
     * @return
     * @throws BusinessException
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findExpireTaskSummary(Date endDate, Map<String, Object> params) throws BusinessException;

    /**
     * 查询某时间段到期任务
     * @param beginDate
     * @param endDate
     * @return
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findExpireTaskSummary(Date beginDate, Date endDate, Map<String, Object> params) throws BusinessException;

    /**
     * 添加任务
     * @param taskBO 任务bo对象
     * @throws BusinessException
     */
    public List<TaskMemberBean> addTask(TaskBO taskBO) throws BusinessException;

    public List<OrgUnitBean> findAllDepByType(Integer type) throws BusinessException;

    /**
     * 添加任务关联
     * @param tid 任务id
     * @param perIds 人员id 必须和type的个数位置相同
     * @param type 关联类型 参见枚举{@link TaskMemberRelTypeEnum}  必须和perIds的个数位置相同
     * @param pid 当前人员id
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> addTaskMember(Long cid, Long tid, String[] perIds, Integer[] type, Long pid, String errorSaveDeptFlag) throws BusinessException;

    /**
     * 添加任务的动态信息
     * @param processBO 任务处理信息
     * @param isHide 是否隐藏
     * @throws BusinessException
     */
    public void addTaskProcess(TaskProcessBO processBO, Boolean isHide) throws BusinessException;

    /**
     * 添加任务汇报
     * @param reportSummaries
     * @throws SQLException
     */
    public void addTaskReportSummarys(TaskReportBO reportBO) throws BusinessException;

    /**
     * 更新任务公告
     * @param taskId
     * @param notice
     * @param personId
     * @throws BusinessException
     */
    public void addTaskNotice(Long taskId, String notice, Long personId) throws BusinessException;

    /**
     * 更新红旗标记
     * @param taskIds 任务id
     * @param personId 人员id
     * @param redFlag 标记
     * @throws BusinessException
     */
    public void updateRedFlagByTaskIdAndPersonId(Long taskId, Long personId, Integer redFlag) throws BusinessException;

    /**
     * 根据任务id修改状态为
     * @param ids 任务id
     * @param state 任务状态 TaskSummaryStateEnum
     * @param pid
     * @param isSys 是否是系统动作
     * @throws BusinessException
     */
    public void updateTaskSummaryStateById(Long id, Integer state, Long pid, Boolean isSys) throws BusinessException;

    /**
     * 根据任务id修改状态为
     * @param ids 任务ids
     * @param state 任务状态 TaskSummaryStateEnum
     * @param pid
     * @param isSys 是否是系统动作
     * @throws BusinessException
     */
    public void updateTaskSummaryStateById(Long[] ids, Integer state, Long pid, Boolean isSys) throws BusinessException;

    /**
     * 更新任务成员信息
     * @param taskMemberBeans
     * @throws SQLException
     */
    public void updateTaskMemberReadDate(Long meberId, Date date) throws BusinessException;

    /**
     * 更新任务成员阅读时间
     * @param meberId
     * @throws BusinessException
     */
    public void updateTaskMemberReadDate(Long[] meberId) throws BusinessException;

    /**
     * 更新任务成员信息
     * @param memberBeans
     * @throws BusinessException
     */
    public void updateTaskMember(List<TaskMemberBean> memberBeans) throws BusinessException;

    /**
     * 根据id查找任务基本信息 查找任务
     * @param id 任务id
     * @return 成功返回任务基本信息，否则null
     * @throws BusinessException
     */
    public TaskSummaryBean findTaskSummaryBeanById(Long id) throws BusinessException;

    /**
     * 获取任务类型超时事项
     * @param taskTypes 任务类型id
     * @throws BusinessException
     */
    List<TaskSummaryBean> findOverdueTaskByTaskType(List<Long> taskTypes) throws BusinessException, SQLException;


    /**
     *  检查当前人在当前事项中状态，进行汇报验证，如果事项已经办结，则无法汇报，如果成员被办结，则事项无法再次汇报
     * @param id
     * @return
     * @throws BusinessException
     */
    Map<String,Object> checkTaskAndMemberStatus(Long id)throws BusinessException;
    /**
     * 任务id查询TaskBO
     * @param id 任务id
     * @return 成功返回任务信息，否则null
     * @throws BusinessException
     *
     */
    public TaskBO findTaskBOById(Long id) throws BusinessException;

    /**
     * 根据父id查询子任务
     * @param parentId
     * @return
     * @throws BusinessException
     */
    public List<TaskBO> findTaskBOByParentId(Long parentId) throws BusinessException;

    /**
     * 根据各种复合条件查询任务动态 查询条件和{@link #findTaskProcess(String, String, String, Integer, Integer, String, String, Long, Long, Long, Integer, Integer) 一样}
     * @param doType
     * @param keyword
     * @param keywordShow
     * @param roleType
     * @param actionType
     * @param dateFrom
     * @param dateTo
     * @param cid
     * @param taskId
     * @param personId
     * @return
     * @throws BusinessException
     */
    Integer countTaskProcess(String doType, String keyword, String keywordShow, Integer roleType, Integer actionType, String dateFrom, String dateTo, Long cid, Long taskId, Long personId) throws BusinessException;

    /**
     * 根据各种复合条件查询任务动态
     * @param doType 查询表示
     * @param keyword 人员id(key_id)
     * @param keywordShow 标题
     * @param roleType 角色,参见枚举TaskMemberRelTypeEnum
     * @param actionType 查询动态的分类，参见枚举BehSummaryBehTypeEnum
     * @param dateFrom 开始时间
     * @param dateTo 结束时间
     * @param cid 单位id
     * @param taskId 任务id
     * @param personId 人员id
     * @param start 开始页码
     * @param range 页大小
     * @return
     * @throws BusinessException
     */
    public ListObject<Object> findTaskProcess(String doType, String keyword, String keywordShow, Integer roleType, Integer actionType, String dateFrom, String dateTo, Long cid, Long taskId,
                                              Long personId, Integer start, Integer range) throws BusinessException;

    /**
     * 查询任务列表
     * @param redFlag 红旗标识，参见枚举TaskMemberRedFlag  全部(-1),只选红旗(TaskEnum.TaskMemberRedFlag.RedFlag)
     * @param doType 查询方式  标题(title)，状态(state)，时间范围(endDate)，责任人(manager,暂未使用)
     * @param keyword 责任人的id 暂未使用
     * @param keywordShow 任务标题
     * @param dateFrom 开始时间
     * @param dateTo 结束时间
     * @param personId 当前人员id
     * @param memberRelTypes 任务member关联状态，参见TaskMemberBean的relationType字段，及TaskMemberRelTypeEnum枚举   全部(责任,关注,参与),责任,关注,参与
     * @param states 任务summary的状态，参见TaskSummaryBean的tstate字段，及TaskSummaryStateEnum枚举
     * @param tCategory 任务summary的类型，参见TaskSummaryBean的tcategory字段，及TaskSummaryTcategoryEnum枚举
     * @param cid 单位id
     * @param start 开始页码
     * @param pageSize 结束页码
     * @return 任务列表
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long personId, Integer[] memberRelTypes,
                                          Integer[] states, Integer tCategory, Long cid, Integer start, Integer pageSize) throws BusinessException;

    /**
     * 查询任务列表
     * @param redFlag 红旗标识，参见枚举TaskMemberRedFlag  全部(-1),只选红旗(TaskEnum.TaskMemberRedFlag.RedFlag)
     * @param doType 查询方式  标题(title)，状态(state)，时间范围(endDate)，责任人(manager,暂未使用)
     * @param keyword 责任人的id 暂未使用
     * @param keywordShow 任务标题
     * @param dateFrom 开始时间
     * @param dateTo 结束时间
     * @param personId 当前人员id
     * @param memberRelTypes 任务member关联状态，参见TaskMemberBean的relationType字段，及TaskMemberRelTypeEnum枚举   全部(责任,关注,参与),责任,关注,参与
     * @param states 任务summary的状态，参见TaskSummaryBean的tstate字段，及TaskSummaryStateEnum枚举
     * @param tCategory 任务summary的类型，参见TaskSummaryBean的tcategory字段，及TaskSummaryTcategoryEnum枚举
     * @param cid 单位id
     * @param currentPid 当前人员的id
     * @param pid 某人的id
     * @param start 开始页码
     * @param pageSize 结束页码
     * @return 任务列表
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long curentPid, Integer[] memberRelTypes,
                                          Integer[] states, Integer tCategory, Long cid, Long pid, Integer start, Integer pageSize) throws BusinessException;

    /**
     * 查询任务列表
     * @param redFlag 红旗标识，参见枚举TaskMemberRedFlag  全部(-1),只选红旗(TaskEnum.TaskMemberRedFlag.RedFlag)
     * @param doType 查询方式  标题(title)，状态(state)，时间范围(endDate)，责任人(manager,暂未使用)
     * @param keyword 责任人的id 暂未使用
     * @param keywordShow 任务标题
     * @param dateFrom 开始时间
     * @param dateTo 结束时间
     * @param personId 当前人员id
     * @param memberRelTypes 任务member关联状态，参见TaskMemberBean的relationType字段，及TaskMemberRelTypeEnum枚举   全部(责任,关注,参与),责任,关注,参与
     * @param states 任务summary的状态，参见TaskSummaryBean的tstate字段，及TaskSummaryStateEnum枚举
     * @param tCategory 任务summary的类型，参见TaskSummaryBean的tcategory字段，及TaskSummaryTcategoryEnum枚举
     * @param cid 单位id
     * @param currentPid 当前人员的id
     * @param pid 某人的id
     * @param findState状态
     * @param start 开始页码
     * @param pageSize 结束页码
     * @return 任务列表
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long curentPid, Integer[] memberRelTypes,
                                          Integer[] states, Integer tCategory, Long cid, Long pid, Integer findState, Integer start, Integer pageSize) throws BusinessException;

    public List<TaskSummaryBean> findTaskListByIds(Long[] ids) throws BusinessException;

    /**
     * 任务id查询TaskBO
     * @param ids 任务id
     * @return 成功返回任务信息，否则null
     * @throws BusinessException
     */
    public List<TaskBO> findTaskBOByIds(Long[] ids) throws BusinessException;

    /**
     * @param ids
     * @return
     * @throws BusinessException
     */
    public List<TaskBO> findTaskBOByIdsWithoutOrder(Long[] ids) throws BusinessException;

    /**
     * 根据任务id查询任务汇报
     * @param taskIds
     * @param start
     * @param range
     * @return
     * @throws SQLException
     */
    public ListObject<TaskReportBO> findTaskReportSummaryByTaskId(Long taskId, Integer start, Integer range) throws BusinessException;

    /**
     * @param taskId
     * @return
     * @throws BusinessException
     */
    public List<TaskReportBO> findTaskReportBOByTaskId(Long taskId) throws BusinessException;
    /**
     * 任务id查询任务关联人员信息
     * @param taskIds 任务ID
     * @return 成功返回任务信息，否则null
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByTaskId(Long taskId) throws BusinessException;

    /**
     * 任务id查询任务关联人员信息
     * @param taskId 任务ID
     * @param includeDeleted 是否包含已删除的成员
     * @return 成功返回任务成员信息，否则null
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByTaskId(Long taskId, boolean includeDeleted) throws BusinessException;

    /**包含已删除的成员*/
    public List<TaskMemberBean> findAllTaskMembersByTaskId(Long taskId) throws BusinessException;
    /**
     * 任务taskId查询相关批示
     * @param taskId 任务ID
     * @return 成功返回批示，否则null
     * @throws BusinessException
     */
    public TaskProcessSummaryBean findTaskProcessBeansByTaskId(Long id) throws BusinessException;
    /**
     * @param taskId
     * @param memberType
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByTaskIdAndType(Long taskId, Integer memberType) throws BusinessException;

    public List<TaskMemberBean> findTaskMembersByTaskIdAndType(Long taskId, Integer[] memberType) throws BusinessException;

    public List<TaskMemberBean> findTaskMembersByTaskIdAndType(Long[] taskId, Integer[] memberType) throws BusinessException;


    public Map<String,Object> findIsErrorMemberByTaskIdAndType(String taskIds, Integer memberType) throws BusinessException;
    /**
     * 查找下级任务列表
     * @param taskId 任务ID
     * @throws BusinessException
     */
    public List<TaskBO> findTasksOfNextLevel(Long taskId) throws BusinessException;

    /**
     * 根据标题查找任务
     * @param cid 单位id
     * @param personId 人员id
     * @param memberRelTypes 任务人员关联类型
     * @param title 标题
     * @param start 分页起始位置，最小值>=0
     * @param range 分页范围参数
     * @return 返回查询到的任务信息列表对象，否则返回空列表对象：count=0，list.size()=0
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBOsByMemberAndTitle(Long cid, Long personId, Integer[] memberRelTypes, String title, Integer start, Integer range) throws BusinessException;

    /**
     * 根据多个人员查询多个单位的任务
     * @param cid 单位id
     * @param personId 人员id
     * @param memberRelTypes 任务人员关联类型
     * @param title 标题
     * @param category TODO
     * @param start 分页起始位置，最小值>=0
     * @param range 分页范围参数
     * @return 返回查询到的任务信息列表对象，否则返回空列表对象：count=0，list.size()=0
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBOsByMemberAndTitle(Long[] cid, Long[] personId, Integer[] memberRelTypes, String title, Integer category, Integer start, Integer range) throws BusinessException;

    /**
     * 根据多个人员查询多个单位的任务
     * @param cid 单位id
     * @param personId 人员id
     * @param memberRelTypes 任务人员关联类型
     * @param title 标题
     * @param category TODO
     * @param start 分页起始位置，最小值>=0
     * @param range 分页范围参数
     * @return 返回查询到的任务信息列表对象，否则返回空列表对象：count=0，list.size()=0
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBOsByMemberAndTitle(Long[] cid, Long[] personId, Integer[] memberRelTypes, String title, Integer category, Integer taskState, Integer start, Integer range)
            throws BusinessException;

    /**
     *
     * 根据多个人员查询多个单位的任务
     * @param cid 单位id
     * @param personId 人员id
     * @param memberRelTypes 任务人员关联类型
     * @param title 标题
     * @param category TODO
     * @param ids 事项id
     * @param start 分页起始位置，最小值>=0
     * @param range 分页范围参数
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBOsByMemberAndTitle(Long[] cid, Long[] personId, Integer[] memberRelTypes, String title, Integer category, Integer taskState, Long[] ids, Integer start,
                                                          Integer range) throws BusinessException;

    public ListObject<TaskBO> findTaskBOs(Long[] cid, Long[] personId, Integer[] memberRelTypes, String title, Integer category, Integer taskState, Long[] ids, Integer[] state, Long taskTypeId, Integer start, Integer range, String year, String sortFinishDate)throws BusinessException ;

    /**
     * 修改任务的正文
     * @param taskId 任务的id
     * @param contentId 正文的id
     * @throws BusinessException
     */
    public void updateContent(Long taskId, Long contentId) throws BusinessException;

    /**
     * 添加任务的附言
     * @param taskPostscriptBO
     * @throws BusinessException
     */
    public void addTaskPostscriptBo(TaskPostscriptBO taskPostscriptBO) throws BusinessException;

    /**
     * 根据单位id，时间查询所有任务
     * @param orgId
     * @param startDate
     * @param endDate
     * @return
     * @throws BusinessException
     */
    public int findTaskBOsByOrgIdAndDate(Long orgId, Date startDate, Date endDate) throws BusinessException;

    /**
     * 根据id查询任务动态
     * @return List
     * @throws BusinessException
     */
    public List<TaskProcessSummaryBean> findTaskProcessByIds(Long[] ids) throws BusinessException;

    /**
     * 根据processResourceId 查询
     * @param taskId
     * @param processResourceId
     * @return
     * @throws BusinessException
     */
    List<TaskProcessSummaryBean> findTaskProcessByProResourceId(Long taskId , Long processResourceId)throws BusinessException;

    /**
     * 根据任务查询动态信息
     * @param taskId 任务id
     * @param cid 单位id
     * @param start 页码
     * @param pageSize 页大小
     * @return ListObject
     * @throws BusinessException
     */
    public ListObject<TaskProcessSummaryBean> findTaskProcessBeansByTaskId(Long taskId, Integer start, Integer pageSize) throws BusinessException;

    /**
     * 根据父id查询回复的留言
     * @param parentIds
     * @return
     * @throws BusinessException
     */
    public List<TaskProcessSummaryBean> findTaskProcessByparentIds(Long[] parentIds) throws BusinessException;

    /**
     * 根据最后一次访问时间查询最新动态的条数
     * @param taskId 任务id
     * @param lastDate 最后一次访问时间，参看TaskMember
     * @return
     * @throws BusinessException
     */
    public Integer findTaskProcessNewestCount(Long taskId, Date lastDate) throws BusinessException;

    /**
     * 根据任务id和汇报id查询汇报信息
     * @param taskId
     * @param reportId
     * @return
     * @throws BusinessException
     */
    public TaskReportBO findTaskReportBOByTaskIdAndReportId(Long taskId, Long reportId) throws BusinessException;

    /**
     *
     * @param personId
     * @param roles
     * @param title
     * @param important
     * @param ucgency
     * @param onlyFlag
     * @return
     * @throws BusinessException
     */
    public List<Long> findTaskIdsByCri(Long cid, Long personId, Integer[] roles, String title, Integer important, Integer ucgency, Boolean onlyFlag, Integer tCategory, Integer[] taskStates, Long[] ids)
            throws BusinessException;

    /**
     * 查找正在进行中的红旗任务
     * @param personId
     * @param cid
     * @param ids
     * @return
     * @throws BusinessException
     */
    public List<TaskBO> findRedFlagTaskOfRecent(Long cid, Long personId, List<Long> ids) throws BusinessException;

    /**
     * 批量添加留言关系表
     * @param relationBeans
     * @throws BusinessException
     */
    public void addTaskProcessRelation(List<TaskProcessRelationBean> relationBeans) throws BusinessException;

    /**
     * 根据任务id和留言id查询留言关系
     * @param taskId
     * @param processId
     * @return
     * @throws BusinessException
     */
    public List<TaskProcessRelationBean> findTaskProcessRelationByProcessIdAndTaskId(Long taskId, Long processId) throws BusinessException;

    /**
     * 删除任务下面指定人员的关联信息
     * @param beans
     * @throws BusinessException
     */
    public void deleteTaskMemberByTaskIdAndPersonIds(List<TaskMemberBean> beans) throws BusinessException;

    public void deleteTaskMembers(List<TaskMemberBean> beans) throws BusinessException;

    /**
     * 添加和删除指定的关联
     * @param cid
     * @param tid
     * @param addPersons
     * @param types
     * @param pid
     * @param deletePerson
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> addAndDeleteTaskMemberBean(Long cid, Long tid, String[] addPersons, Integer[] types, Long pid, Long[] deletePersons, Integer type) throws BusinessException;

    public void updateTaskSummary(TaskSummaryBean summerBean) throws BusinessException;

    /**
     * 添加任务委托
     * @param deputeBeans
     * @throws BusinessException
     */
    //	public void addTaskDepute(List<TaskDeputeBean> deputeBeans) throws ModuleException;
    //	/**
    //	 * 修改委托任务状态
    //	 * @param resouceIds 任务id
    //	 * @param targetIds 被委托人的id
    //	 * @param dstate 状态 0未删除，1删除
    //	 * @throws ModuleException
    //	 */
    //	public void updateTaskDeputeState(Long[] resouceIds, Long[] targetIds , Integer dstate) throws ModuleException;
    /**
     * 添加任务委托
     * @param pids 被委托的人，格式为：type_id ，如(100003_123456789)
     * @param endDate 被委托的结束时间
     * @param description 描述
     * @param pid 当前登陆人的id
     * @param taskId 任务id
     * @throws BusinessException
     */
    public void addTaskDepute(Long[] pids, String endDate, String description, Long pid, Long taskId, Long cid) throws BusinessException;

    /**
     * 根据任务id查询TaskDeputeBean
     * @param taskId
     * @param cid
     * @return
     * @throws BusinessException
     */
    public TaskDeputeBean findTaskDeputeByResouceId(Long taskId, Long cid) throws BusinessException;

    /**
     * @param cid 圈子ID
     * @param ids ID取值范围
     * @return 圈子最近发布的公告
     * @throws BusinessException
     */
    public List<TaskBO> findNoticeTaskOfRecent(Long cid, List<Long> ids) throws BusinessException;

    /**
     * 管理员删除人员或审核不通过时处理人员作为负责人的任务
     * 1. 是任务责任人但不是创建人，将任务委托给任务创建人
     * 2. 是任务责任人又是创建人，将任务委托给任务参与人
     * @param perIds 人员ID列表
     * @throws BusinessException
     */
    public void handleTaskWithDelMember(Long[] perIds) throws BusinessException;

    /**
     * 根据人员id和单位id，查询所有委托给我事项id
     * @param cid 单位id
     * @param personId 人员id
     * @return 事项id集合
     * @throws BusinessException
     */
    public List<Long> getTaskDeputTaskIds(Long cid, Long personId) throws BusinessException;

    /**
     * 分享任务到其他圈子
     * @param taskId 要分享的任务
     * @param cid 目标圈子的ID
     * @throws BusinessException
     */
    public void shareTask(Long taskId, Long cid) throws BusinessException;

    /**
     * 分享任务到其他圈子
     * @param taskId
     * @param cid
     * @param title
     * @param taskRelationType
     * @param labels
     * @param iconId
     * @throws BusinessException
     */
    public void shareTask(Long taskId, Long cid, String title, Integer taskRelationType, String labels, Long iconId) throws BusinessException;

    /**
     * 统计任务条数
     * @param pid 人员id
     * @param cid 单位id
     * @return
     * @throws BusinessException
     */
    public Integer findTaskCount(Long pid, Long pid2, Long cid, Integer[] states, Integer findState, Date startDate, Date endDate,Integer[] progressState) throws BusinessException;

    public Integer findTaskCount(Long pid, Long pid2, Long cid, Integer[] states, Integer findState,Integer[] progressState) throws BusinessException;

    /**
     *
     * @param pid
     * @param pid2
     * @param cid
     * @param states
     * @param findState
     * @param startDate
     * @param endDate
     * @param start TODO
     * @param pageSize TODO
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskSummaryBean> findTaskCountByList(Long pid, Long pid2, Long cid, Integer[] states, Integer findState, Date startDate, Date endDate, Integer start, Integer pageSize,Integer[] progressState)
            throws BusinessException;

    /**
     * 根据多个人员和查询标志，返回多个人员的事项数量
     * @param ids 人员id数组
     * @param TaskFindTypeEnum 参考枚举{@link TaskEnum.TaskFindTypeEnum}
     * @return Map  key为人员id,value为事项数量
     * @throws BusinessException
     */
    public Map<Long, Integer> findTaskByCount(Long[] ids, Integer TaskFindTypeEnum) throws BusinessException;

    /**
     * 提供给移动端查询事项
     * @param findState
     * @param pid
     * @param cid
     * @param type
     * @param title
     * @param start
     * @param pageSize
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskSummaryBean> findTaskByExtends(Integer findState, Long pid, Long cid, Integer type, String title, Integer start, Integer pageSize) throws BusinessException;

    /**
     *
     * findTask(查询公共圈子分享)
     * @param relationType 分类枚举
     * @param themeLabel 标签名称（模糊查询）
     * @param title 分享标题（模糊查询）
     * @param createDate 创建时间
     * @param start 页下标
     * @param pageSize 条数
     * @return ListObject
     * @throws BusinessException
     *ListObject<TaskShareBean>
     * @exception
     * @since  1.0.0
     */
    public ListObject<TaskShareBean> findTaskShare(Integer relationType, String themeLabel, String title, Date createDate, Integer start, Integer pageSize) throws BusinessException;

    /**
     * 根据id查询事项分享
     * @param id
     * @return
     * @throws BusinessException
     */
    public TaskShareBean findTaskShareById(Long id) throws BusinessException;

    /**
     * 根据某人资源查询条数
     * @param id
     * @param targetType
     * @param targetId
     * @return
     * @throws BusinessException
     */
    public Integer findTaskShareCount(Long id, Integer targetType, Long targetId) throws BusinessException;

    /**
     * 修改任务分享实体
     * @param shareBean
     * @throws BusinessException
     */
    public void updateTaskShare(TaskShareBean shareBean) throws BusinessException;

    /**
     * 根据分页查询分享
     * @param start
     * @param findCount
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskShareBean> findTaskShareByHot(Integer start, Integer findCount) throws BusinessException;

    public ListObject<TaskShareBean> findTaskShareByRecommend(Long sourceId, Integer start, Integer findCount) throws BusinessException;

    public ListObject<TaskShareBean> findTaskShareByHot(Long sourceId, Integer start, Integer findCount) throws BusinessException;

    /**
     * 修改事项属性
     * @param taskId
     * @param nowAttrBean
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> updateTaskAttr(Long taskId, TaskAttrBean nowAttrBean) throws BusinessException;

    /**
     * 根据单位查询接收消息的事项
     * @param cid
     * @return
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTaskByReceiveMsg() throws BusinessException;

    List<TaskAttrBean> findTaskAttrByReceiveMsg() throws BusinessException;

    public void clearTaskReceiveMsgState(Long[] ids) throws BusinessException;

    public void clearTaskReceiveMsgState(List<Long> ids) throws BusinessException;

    public ListObject<TaskProcessBO> findTaskProcessBosByTaskId(Long taskId, Integer start, Integer pageSize) throws BusinessException;

    /**
     * 添加事项评价
     * 时间，评论ID，评论状态都被写了
     * @param taskAssess 事项评价对象
     * @throws BusinessException
     */
    public void addTaskAssess(TaskAssessBean taskAssess) throws BusinessException;

    /**注意：在调用这个方法前要进行判断taskId!=null&&assessPersonId!=null&&assessPersonEdId!=null
     * ，否则不能判断是否评论1
     * 通过对事项评价taskId, assessPersonId,assessPersonEdId他们间的and关系查找
     * @param
     * @throws BusinessException
     */

    List<TaskSummaryBean> findTaskSummaryBeansWithoutOrder(Long[] ids) throws BusinessException;

    /**
     * 根据部门id查询责任人是当前部门的任务
     * @param deptId 部门id
     * @param start 分页起始位置，最小值>=0
     * @param range 分页范围参数
     * @return 返回查询到的任务信息列表对象，否则返回空列表对象：count=0，list.size()=0
     * @throws BusinessException
     */
    public ListObject<TaskBO> findTaskBOsByDeptId(Long deptId, Integer start, Integer range) throws BusinessException;

    public List<TaskAssessBean> findTaskAssessBean(Long taskId, Long assessPersonId, Long assessPersonEdId) throws BusinessException;

    /**
     * 通过对事项评价taskId, assessPersonEdId他们间的and关系查找
     * 得出这件事，这人被那些人评论过评论了那些人
     * @param
     * @throws BusinessException
     */

    public List<TaskAssessBean> findTaskAssessList1(Long taskId, Long assessPersonEdId) throws BusinessException;

    /**
     * 通过对事项评价两个Id，他们间的and关系查找
     * 得出这件事，这人被那些人评论过评论了那些人
     * @param id1
     * @param value1：id1的属性名
     * @param id2
     * @param value2：id2的属性名

     * @throws BusinessException
     */

    public List<TaskAssessBean> findTaskAssessList(Long id1, String value1, Long id2, String value2) throws BusinessException;

    /**
     * 通过id来删除
     * @param
     * @throws BusinessException
     */

    public void deleteTaskAssessById(Long id) throws BusinessException;

    /**
     *
     * @param value为属性的字段名，查询平均
     * @throws BusinessException
     */
    public Double findTaskAssessListAvg(Long id1, String value1, Long id2, String value2, String value) throws BusinessException;

    /**
     * 根据部门id查询部门所有和我相关的事项（缺省排除结束的事项）
     * @param departmentId
     * @param pid
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTaskByDepartment(Long departmentId, Long pid) throws BusinessException;

    /**
     * 根据部门id查询部门所有和我相关的事项（缺省排除结束的事项）
     * @param departmentId
     * @param pid
     * @throws BusinessException
     */
    public List<TaskBO> findTaskByDepartmentByPage(Long departmentId, Long pid, Integer start, Integer range) throws BusinessException;

    /**
     * 根据指定人查询和我相光的事项（缺省排除结束的事项）
     * @param targetPid
     * @param pid
     * @throws BusinessException
     */
    public List<TaskBO> findTaskByPersonTogether(Long targetPid, Long pid, Integer start, Integer range) throws BusinessException;

    /**
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTaskSummaryBeans(Long[] ids) throws BusinessException;
    public ListObject<TaskSummaryBean> findTaskSummaryBeans(Long[] ids, Integer start, Integer range) throws BusinessException;
    /**
     * 撤销任务
     * @param taskId
     * @param perId 当前登录人ID
     * @throws BusinessException
     */
    public void cancleTask(Long taskId, Long perId, Long cid) throws BusinessException;

    /**
     * @param memberId
     * @throws BusinessException
     */
    public TaskMemberBean findTaskMemberById(Long memberId) throws BusinessException;
    public List<TaskMemberBean> findTaskMemberByParentId(Long parentMemberId) throws BusinessException;

    /**
     * 查询出所有的taskMember
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> findAllTaskMember() throws BusinessException;

    /**
     * 用于指派任务给他人
     * @param cid
     * @param tid
     * @param perIds
     * @param type
     * @param pid
     * @param isDepute 是否是被委托
     * @param parentId 委托的member ID
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> addTaskMember(Long cid, Long tid, Long[] perIds, Integer[] type, Long pid, Boolean isDepute, Long parentId) throws BusinessException;

    /**
     * 转发事项
     * @param pid
     * @param cid
     * @param taskId
     * @param supervisePersonId 督办人，格式为100003_1000000001
     * @param managerPersonId 责任人，格式为100003_1000000001
     * @param participantPersonId 参与人，格式为100003_1000000001
     * @param title 转发的标题
     * @param description 留言
     * @throws BusinessException
     */
    public Long forwardTask(Long pid, Long cid, Long taskId, String supervisePersonId, String managerPersonId, String participantPersonId, String title, String description) throws BusinessException;

    /**
     * 根据taskIds查询List
     * @param taskIds
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByTaskIds(List<Long> taskIds) throws BusinessException;

    /**
     * 根据taskIds查询成员集合
     * @param taskIds 事项ID
     * @param includeDeleted 是否包含被删除的成员
     * @return 成员集合
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByTaskIds(List<Long> taskIds, boolean includeDeleted) throws BusinessException;

    /**
     * 根据orgPersonIdsByBeans查询事项数量，包含所有参与的
     * @param orgPersonIdsByBeans 人员id集合
     * @return
     * @throws BusinessException
     */
    //public Integer findTaskCountByPersonIds(List<Long> orgPersonIdsByBeans, String startDate, String endDate) throws ModuleException;

    /**
     * 根据orgPersonIdsByBeans查询超期数量，包含超期和超期完成
     * @param orgPersonIdsByBeans 人员id集合
     * @return
     * @throws BusinessException
     */
    //public Integer findOverdueTaskCountByPersonIds(List<Long> orgPersonIdsByBeans, String startDate, String endDate) throws ModuleException;

    //保存，更新
    /**
     * 保存催办
     * @param pid 催办人id
     * @param memberId taskMemberId
     * @param taskId 事项id
     * @param content 内容
     * @param cid 单位id
     * @throws BusinessException
     */
    public void addTaskRemind(Long pid, Long memberId, Long taskId, String content, Long cid) throws BusinessException;
    /**
     * 保存任务意见信息
     * 2016-5-7 上午11:14:39
     *
     * 增加返回值
     * modify by huzy 2017/9/22 上午11:54
     * addTaskOption
     * @param pid 创建人id
     * @param taskId 任务id
     * @param content 内容
     * @param cid 单位id
     * @param type 意见类型
     * @param sendMsg 是否发送短信
     * @param recevice 短信接收人
     * @param files TODO
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    public Long addTaskOption(Long pid, Long taskId, String content, Long cid , Integer type , Boolean sendMsg  , String recevice, String[] files) throws BusinessException;

    /**
     * 处理催办
     * @param taskRemindId 催办id
     * @param state 状态，参考枚举
     * @param content 内容
     * @param reportId 汇报id
     * @throws BusinessException
     */
    public void handleTaskRemind(Long taskRemindId, String content, Long reportId, Long pid) throws BusinessException;

    /**
     * 根据memberId查询所有状态的催办记录
     * @param memberId
     * @param start 分页参数
     * @param range 分页参数
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskRemindMemberBean> findTaskRemindMember(Long memberId, Integer start, Integer range) throws BusinessException;

    /**
     * 根据memberId查询所有状态的催办条数
     * @param memberId
     * @return
     * @throws BusinessException
     */
    public Integer findTaskRemindMemberCount(Long memberId) throws BusinessException;

    /**
     * 根据memberId和state查询催办记录
     * @param memberId
     * @param state
     * @return
     * @throws BusinessException
     */
    public List<TaskRemindMemberBean> findTaskRemindMemberByState(Long memberId, Integer state) throws BusinessException;

    /**
     * 根据memberIds查询催办记录
     * 2015-10-8 下午5:51:46
     *
     * findTaskRemindMemberByState
     * @param memberIds
     * @param state
     * @return
     * @throws BusinessException
     *List<TaskRemindMemberBean>
     * @exception
     * @since  1.0.0
     */
    public List<TaskRemindMemberBean> findTaskRemindMemberByState(List<Long> memberIds, Integer state) throws BusinessException;

    /**
     * 根据memberId和state查询催办记录条数
     * @param memberId
     * @param state
     * @return
     * @throws BusinessException
     */
    public Integer findTaskRemindMemberByStateCount(Long memberId, Integer state) throws BusinessException;

    /**
     * 查找所有的催办信息
     * @return
     * @throws BusinessException
     */
    public List<TaskRemindMemberBean> findTaskRemindMember() throws BusinessException;

    /**
     * 根据memberIds和state查询催办记录条数
     * 2015-10-8 下午5:59:22
     *
     * findTaskRemindMemberByStateCount
     * @param memberIds
     * @param state
     * @return
     * @throws BusinessException
     *Integer
     * @exception
     * @since  1.0.0
     */
    public Integer findTaskRemindMemberByStateCount(List<Long> memberIds, Integer state) throws BusinessException;

    /**
     *
     * 2015-9-25 上午10:33:15
     * 根据taskProcessSummaryId查询TaskProcessBO
     * findTaskProcessBOById
     * @param taskProcessSummaryId
     * @return
     * @throws BusinessException
     *TaskProcessBO
     * @exception
     * @since  1.0.0
     */
    public TaskProcessBO findTaskProcessBOById(Long taskProcessSummaryId) throws BusinessException;

    /**
     * 根据taskId和pid查询事项动态
     * 2015-9-29 下午3:23:00
     *
     * findTaskProcessBeansByTaskId
     * @param taskId 事项id
     * @param pid 人员
     * @return
     * @throws BusinessException
     *TaskProcessSummaryBean
     * @exception
     * @since  1.0.0
     */
    public TaskProcessSummaryBean findTaskProcessBeansByTaskId(Long taskId, Long pid) throws BusinessException;

    /**
     * 根据任务ID和reportId
     * 查询留言信息
     * memberID
     * @param taskId
     * @param pid
     * @param reportId
     * @return
     */
    public TaskProcessSummaryBean findTaskProcessBeansByTaskIdAndReportId(Long taskId, Long pid,Long reportId) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 根据任务ID和reportId查对应阶段的汇报留言
     * @createTime 2021/6/4 10:06
     */
    public TaskProcessSummaryBean findTaskProcessByTaskIdAndReportIdAndPhaseId(Long taskId, Long pid,Long reportId,Long phaseId) throws BusinessException;


    public TaskProcessSummaryBean findTaskProcessBeansByReportId(Long reportId) throws BusinessException;

    public TaskProcessSummaryBean findTaskProcessBeanByReportIdAndPhaseId(Long reportId,Long phaseId) throws BusinessException;

    public List<TaskProcessSummaryBean> findTaskProcessBeanByReportIdAndPhaseId(Long taskId,Long reportId,Long phaseId) throws BusinessException;

    public TaskProcessSummaryBean findTaskProcessSummaryById(Long id) throws BusinessException;
        /**
         * 根据任务ID和memberID
         * 查询主办或协办信息
         * memberID
         * @param taskId
         * @param memberId
         * @param startIndex
         * @param range
         * @return
         */
    public ListObject<TaskReportBO> findTaskReportSummaryByTaskIdAndMemberId(Long taskId, Long memberId, int startIndex, int range) throws BusinessException;

    /**
     * 查找任务最新进度汇报的时间
     * 用于任务时间视图展示超期的时间段
     * @param taskIds 任务ID
     * @return {@code Map<任务ID, 汇报的时间>}
     * @throws SQLException
     */
    public Map<Long, String> findLatestUpdateDateOfTask(List<Long> taskIds) throws BusinessException;

    /**
     * zhangzy
     * @param tid
     * @param key
     * @param faildtime
     */
    public void updateTaskReportSummaryBytaskIdAndMembrId(Long id, int key, Date faildtime) throws BusinessException;

    /**
     * zhangzy
     * 保存打回信息
     * @param tbm
     */
    public void saveTaskBackMessage(TaskBackMessageBean tbm) throws BusinessException;

    /**
     * zhangzy
     * @param taskId
     * @param memeberId
     * @param did
     * @param i
     * @param j
     * @return
     */
    public ListObject<TaskReportBO> findTaskReportSummaryByTaskIdAndMemberIdDid(Long taskId, Long memeberId, Long did, int i, int j) throws BusinessException;

    /**
     * zhangzy
     * @param reportBO
     * @param ismanager
     */
    public void addTaskReportSummarys(TaskReportBO reportBO, boolean ismanager) throws BusinessException;

    /**
     * 单位下最新的一条汇报记录
     * zhangzy
     * @param taskId
     * @param did
     * @param i
     * @param j
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskReportBO> findTaskReportSummaryByTaskIdAndDid(Long taskId, Long did, int i, int j) throws BusinessException;

    /**
     * 根据汇报ID 查询对应打回记录
     * @param id
     * @return
     * @throws BusinessException
     */
    public List<TaskBackMessageBean> findtaskbackmessageByTaskreportId(Long id) throws BusinessException;

    /**
     * @param taskId
     * @return 当前任务根据member组合最新的进度汇报情况
     * @throws SQLException
     */
    public List<TaskReportBO> findLastestReportByTaskId(Long taskId) throws BusinessException;

    /**
     * @param taskId
     * @return 事项中按照单位统计的进度情况
     * @throws BusinessException
     */
    public List<Map<String, Object>> getTaskReportStatics(Long taskId) throws BusinessException;
    /**
     * 根据tasskId和pids查询汇报
     * 2016-1-26 下午2:44:20
     *
     * findTaskReportBosByTaskIdAndPids
     * @param taskId
     * @param pids
     * @return
     * @throws BusinessException
     *List<TaskReportBO>
     * @exception
     * @since  2.0
     */
    public List<TaskReportBO> findTaskReportBosByTaskIdAndPids(Long taskId, Long[] pids) throws BusinessException;
    /**
     * 根据taskId和taskMemberIdsByBeans查询催办记录
     * 2016-1-26 下午4:58:23
     *
     * findTaskRemindMember
     * @param taskId
     * @param taskMemberIdsByBeans
     * @return
     * @throws BusinessException
     *List<TaskRemindMemberBean>
     * @exception
     * @since  2.0
     */
    public Integer findTaskRemindMember(Long taskId, List<Long> taskMemberIdsByBeans) throws BusinessException;
    /**
     * 添加汇报审核信息
     * 2016-3-8 下午5:58:45
     *
     * addTaskReportMemberBeans
     * @param reportMembersBeans
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    public void addTaskReportMemberBeans(List<TaskReportMemberBean> reportMembersBeans) throws BusinessException;
    /**
     * 根据事项id和人员id查询未处理的汇报审批
     * 2016-3-8 下午8:06:09
     *
     * findTaskReportMemberBeans
     * @param taskId
     * @param personId
     * @return
     * @throws BusinessException
     *List<TaskRemindMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskReportMemberBean> findTaskReportMemberBeans(Long taskId, Long personId) throws BusinessException;
    /**
     * 根据taskId和examine状态查询未审核或者已审核的汇报审批
     * 2016-3-26 下午2:15:54
     *
     * findTaskReportMemberBeans
     * @param taskId
     * @param personId
     * @return
     * @throws BusinessException
     *List<TaskReportMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskReportMemberBean> findTaskReportMemberBeans(Long taskId, Integer examine) throws BusinessException;
    /**
     * 根据reportMemberId查询bean
     * 2016-3-9 下午8:17:30
     *
     * findTaskReportMemberById
     * @param reportMemberId
     * @return
     * @throws BusinessException
     *TaskReportMemberBean
     * @exception
     * @since  2.0
     */
    public TaskReportMemberBean findTaskReportMemberById(Long reportMemberId)throws BusinessException;
    /**
     *
     * 2016-3-9 下午8:17:34
     * 根据taskReportId查询bo
     * findTaskReportBo
     * @param taskReportId
     * @return
     * @throws BusinessException
     *TaskReportBO
     * @exception
     * @since  2.0
     */
    public TaskReportBO findTaskReportBo(Long taskReportId) throws BusinessException;


    /**
     * 处理汇报审核
     * 2016-3-10 下午6:45:59
     *
     * handleTaskReport
     * @param reportMemberId
     * @param option
     * @param state
     * @param pid
     * @param leaderManager TODO
     * @param memberType TODO
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    public void handleTaskReport(Long reportMemberId, String option, Integer state, Long pid, String leaderManager, Integer memberType) throws BusinessException;
    /**
     * 根据条件查询汇报审批记录
     * 2016-3-10 下午8:01:19
     *
     * findTaskReportMemberBeans
     * @param taskId 事项id
     * @param personId 人员id
     * @param state 0代表未查看，1代表已查看
     * @return
     * @throws BusinessException
     *List<TaskReportMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskReportMemberBean> findTaskReportMemberBeans(Long taskId, Long personId, Integer state) throws BusinessException;
    /**
     * 添加汇报的审批
     * 2016-3-14 下午2:13:36
     *
     * addTaskReportExamine
     * @param reportBO
     * @param
     * @param colIds TODO
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    public void addTaskReportExamine(TaskReportBO reportBO , Integer state , Integer process, String sendColType, String colIds) throws BusinessException;
    /**
     * 根据事项id和汇报id查询汇报审批记录
     * 2016-3-15 下午4:23:36
     *
     * findTaskReportMemberBean
     * @param l 任务id
     * @param m 汇报的id
     * @return
     * @throws BusinessException
     *TaskReportMemberBean
     * @exception
     * @since  2.0
     */
    public TaskReportMemberBean findTaskReportMemberBean(Long l, Long m) throws BusinessException;

    public List<TaskAttrBean> findTaskAttr(Long cid, Integer taskCategory) throws BusinessException;
    // ---任务类型管理

    /**
     * 新增任务类别或来源
     *
     * @param taskType
     * @throws BusinessException
     */
    public void addTaskType(TaskTypeBean taskType) throws BusinessException;

    /**
     * 批量新增任务类别
     * @param taskTypeBeans
     * @param account
     * @throws BusinessException
     */
    void addTaskTypes(List<TaskTypeBean> taskTypeBeans, OrgUnitBean account) throws BusinessException;

    /**
     * 更新任务类型或来源
     *
     * @param taskType
     * @throws BusinessException
     */
    public void updateTaskType(TaskTypeBean taskType) throws BusinessException;

    /**
     * 批量更新任务类型或来源
     *
     * @param taskType
     * @throws BusinessException
     */
    void updateTaskTypes(List<TaskTypeBean> taskType) throws BusinessException;

    /**
     * @param ids
     * @param status
     * @throws BusinessException
     */
    public void updateTaskTypeStatus(Long[] ids, Integer status) throws BusinessException;

    /**
     * 在缓存中查找指定id数组任务类型下是否存在子任务类型
     * @param ids
     * @return true：存在  false：不存在
     */
    public boolean findIsChildTaskType(Long[] ids) throws BusinessException;

    /**
     * 根据类型Id更新该类型的使用范围
     * @param ids
     * @param users
     * @throws BusinessException
     */
    public void updateTaskTypeUsers(Long[] ids, String users) throws BusinessException;

    /**
     * 根据任务类型id查询任务类型
     *
     * @param id
     * @return
     * @throws BusinessException
     */
    public TaskTypeBean findTaskTypeBean(Long id) throws BusinessException;

    /**
     * 获取回报情况
     * @param tasktype_id
     * @return  指标总数及未汇报数量
     */
    Map<String,Object> getReportNum(String tasktype_id) throws BusinessException;
    /**
     * 根据任务remark查询任务类型
     *
     * @param  remark
     * @return
     * @throws BusinessException
     */
    public TaskTypeBean findTaskTypeBeanByRemark(String remark,Long accountId) throws BusinessException;

    TaskTypeBean findTaskTypeByNameAndPName(String name, String parentName, Long accountId) throws BusinessException;
    /**
     * @author inspired (胡启林)
     * @param subType {@link TaskEnum.TaskTypeSub}
     * @describe 根据subType查询所有类型
     * @createTime 2020/11/26 16:44
     */
    public List<TaskTypeBean> findTaskTypeBeansBySubType(Integer subType,Long accountId) throws BusinessException;
    public List<TaskTypeBean> findTaskTypeBeansBySubTypes(List<Integer> subTypes,Long accountId) throws BusinessException;

    /**
     * @param subType {@link TaskEnum.TaskTypeSub}
     * @describe 根据subType查询所有类型，针对前端树的生成
     * @createTime 2021/2/25
     * @return
     */
    public List<Map<String, Object>> findTaskTypeBeansBySubTypeForZtree(Integer subType) throws BusinessException;

    List<Map<String, Object>> findTaskTypebeansBySubTypeAndRourcetype(Integer subType,Integer rouceType)throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 获取能够参与统计的督办类型
     * @createTime 2021/1/25 14:57
     */
    public List<TaskTypeBean> findCanCountTaskTypeBeans(Long accountId) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 获取专项工作任务类型
     * @createTime 2020/12/30 11:30
     */
    public List<TaskTypeBean> findSpecificWorkTaskTypeBeans() throws BusinessException;

    /**
     * 根据任务类型id查询任务类型
     *
     * @param id
     * @return
     * @throws BusinessException
     */
    public List<Map<String, Object>> findTaskTypeBeanList(Long id) throws BusinessException;

    /**
     * 根据任务类型id查询任务类型
     * @param ids
     * @return
     * @throws BusinessException
     */
    public List<TaskTypeBean> findTaskTypeBean(Collection<Long> ids)throws BusinessException;

    /**
     * 根据单位id和子类别查询任务类型或来源
     *
     * @param cid
     * @param resourceType TODO
     * @param subType
     * @param status
     *            TODO
     * @param start
     *            TODO
     * @param range
     *            TODO
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskTypeBean> findTaskType(Long cid, Integer resourceType, Integer subType, Integer status, Integer start, Integer range,Long accountId)
            throws BusinessException;

    List<TaskTypeBean> findtasktypeByKeyProject(Integer isKeyProject) throws BusinessException;
    /**
     * 根据id查询子类型
     * @param parentId
     * @param resourceType TODO
     * @param subType TODO
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskTypeBean> findTaskTypesByParentId(Long parentId,Integer resourceType, Integer subType, Integer start, Integer range,Long accountId) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param taskTypeId
     * @param start
     * @param range
     * @describe 根据任务类型分页查询任务模板
     * @createTime 2020/10/14 16:40
     */
    public ListObject<TaskSummaryBean> findTaskTemplateByTaskTypeId(Long taskTypeId, Integer start, Integer range) throws BusinessException, SQLException;

    /**
     * 查询单位的所有任务类型和来源
     *
     * @param cid
     * @param status
     *            TODO
     * @return
     * @throws BusinessException
     */
    public List<TaskTypeBean> findTaskTypes(Long cid, Integer status,Long accountId) throws BusinessException;

    /**
     * @param cid
     * @param resourceType TODO
     * @param subType
     * @return
     * @throws BusinessException
     */
    public List<TaskTypeBean> findTaskTypes(Long cid, Integer resourceType, Integer subType, Integer status,Long accountId) throws BusinessException;

    /**
     * @param cid
     * @param resourceType
     * @param subType
     * @return
     * @throws BusinessException
     */
    public List<TaskTypeBean> findTaskTypes(Long cid, Integer resourceType, Integer subType,Long accountId)throws BusinessException;

    /**
     * @param cid 单位id
     * @param personId 人员id
     * @param resourceType 资源ID：任务、会议等
     * @param subType 来源-2，类型-1
     * @param status TaskEnum.TaskTypeStatus
     * @return
     * @throws BusinessException
     */
    public List<TaskTypeBean> findTaskTypes(Long cid,Long personId, Integer resourceType, Integer subType, Integer status,Long accountId) throws BusinessException;

    /**
     * 根据taskId查询所有文件
     * 2016-5-24 上午10:50:05
     *
     * findTaskFilesById
     * @param taskId 事项id
     * @return
     * @throws BusinessException
     *List<SpaceFileBean>
     * @exception
     * @since  2.0
     */
    public List<SpaceFileBean> findTaskFilesById(Long taskId) throws BusinessException;


    /**
     * 增加问题
     * @param taskProblemBean
     * @throws SQLException
     */
    public void addTaskProblem(TaskProblemBean taskProblemBean) throws BusinessException;

    /**
     * 更新问题
     * @param taskProblemBean
     * @throws SQLException
     */
    public void updateTaskProblem(TaskProblemBean taskProblemBean) throws BusinessException;

    /**
     * 根据id查询问题
     * @param id
     * @return TODO
     * @throws BusinessException
     */
    public TaskProblemBean findTaskProblemById(Long id) throws BusinessException;
    /**
     * 添加签收处理意见
     * 2016-6-16 下午2:59:26
     *
     * addTaskReceiveMemberBean
     * @param receiveMemberBean
     * @param leanderManager TODO
     * @return
     * @throws BusinessException
     *TaskReceiveMemberBean
     * @exception
     * @since  2.0
     */
    public void addTaskexamineByReceive(TaskExamineMemberBean receiveMemberBean, String leanderManager) throws BusinessException;
    /**
     * 根据taskExaminId查询实体
     * 2016-6-17 下午5:15:16
     *
     * findTaskExamineBeanById
     * @param taskExaminId
     * @return
     *TaskExamineMemberBean
     * @exception
     * @since  2.0
     */
    public TaskExamineMemberBean findTaskExamineBeanById(Long taskExaminId) throws BusinessException;
    /**
     * 退回审核
     * 2016-6-17 下午5:15:48
     *
     * submitTaskReceiveExamine
     * @param taskExamineMemberBean
     * @param manager
     * @param startDate TODO
     * @param endDate TODO
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    public void submitTaskReceiveExamine(TaskExamineMemberBean taskExamineMemberBean, String manager, String startDate, String endDate) throws BusinessException;
    /**
     * 领导任务审核
     * 2016-6-20 下午1:35:18
     *
     * submitTaskExamine
     * @param taskExamineMemberBean
     * @param difficulty
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    public void submitTaskExamine(TaskExamineMemberBean taskExamineMemberBean, String difficulty) throws BusinessException;

    /**
     * 查询我提交的签收处理
     * 2016-6-21 上午11:02:44
     *
     * findTaskExamineBeansBySubmitRecevice
     * @param personId
     * @param memberId
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskExamineBeansBySubmitRecevice(Long personId, Long memberId, Long taskId) throws BusinessException;
    /**
     * 查询我待审核的退回
     * 2016-6-21 上午11:03:41
     *
     * findTaskExamineBeansByWaitRecevice
     * @param personId
     * @param memberId
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskExamineBeansByWaitRecevice(Long personId, Long memberId, Long taskId) throws BusinessException;
    /**
     * 查询我提交的领导审核
     * 2016-6-21 上午11:31:57
     *
     * findTaskExamineBeansByLeader
     * @param personId
     * @param memberId
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskExamineBeansByLeader(Long personId, Long memberId, Long taskId) throws BusinessException;
    /**
     *
     * 2016-6-21 上午11:32:08
     * 查询我待审核的任务
     * findTaskExamineBeansByWaitLeader
     * @param personId
     * @param memberId
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskExamineBeansByWaitLeader(Long personId, Long memberId, Long taskId) throws BusinessException;
    /**
     * 查询任务所有签收的实体
     * 2016-6-21 下午5:37:09
     *
     * findTaskIsRecevice
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskIsRecevice(Long taskId) throws BusinessException;

    public List<TaskExamineMemberBean> findTaskIsLeader(Long taskId) throws BusinessException;

    public List<TaskRemindMemberBean> findTaskRemindMemberByTaskId(Long taskId) throws BusinessException;
    /**
     * 替换任务的member
     * @param taskId
     * @param selectType
     * @param person
     * @param pid TODO
     * @throws BusinessException
     */
    public void updateTaskMember(Long taskId, Integer selectType, String person, Long pid) throws BusinessException;


    public void addTaskScroeMember(TaskScoreMemberBean scoreMemberBean) throws BusinessException;

    public TaskScoreMemberBean findTaskScoreMemberBean(Long id) throws BusinessException;

    public void submitTaskScoreHandle(Long taskScoreMemberId , Integer leaderScore , Long pid , String option) throws BusinessException;

    public TaskScoreMemberBean findTaskScoreMemberBeanByLastTime(Long taskId) throws BusinessException;

    public void updateTaskScoreMemberBean(TaskScoreMemberBean scoreMemberBean) throws BusinessException;
    /**
     * 查询事项领导未处理的审批
     * 2016-7-13 上午12:34:00
     *
     * findTaskIsLeaderNoSubmit
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskIsLeaderNoSubmit(Long taskId) throws BusinessException;
    /**
     * 根据taskId查询所有签收的实体，包含已经处理过的签收
     * 2016-7-13 下午2:43:59
     *
     * findTaskIsAllRecevice
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskIsAllRecevice(Long taskId) throws BusinessException;
    /**
     * 查询所有领导审批
     * 2016-7-13 下午3:14:52
     *
     * findTaskExamineBeansByAllLeader
     * @param personId
     * @param memberId
     * @param taskId
     * @return
     * @throws BusinessException
     *List<TaskExamineMemberBean>
     * @exception
     * @since  2.0
     */
    public List<TaskExamineMemberBean> findTaskExamineBeansByAllLeader(Long taskId) throws BusinessException;

    public List<TaskExamineMemberBean> findTaskExamineBeans(Criterion c) throws BusinessException;

    public List<TaskReportMemberBean> findTaskReportMemberBeans(Criterion c) throws BusinessException;

    public List<TaskScoreMemberBean> findTaskScoreMemberBeans(Criterion c) throws BusinessException;

    public List<TaskScoreMemberBean> findTaskScoreMemberBeansByTaskId(Long taskId) throws BusinessException;

    /**
     * 根据人员id查询所有任务
     * @param personId
     * @param cid TODO
     * @param relTypes TODO
     * @param redFlag TODO
     * @return
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTasksByPersonId(Long personId, Long cid, Integer[] relTypes, Integer[] redFlag) throws BusinessException;

    /**
     * 根据人员ID查询所有事项ID
     * @param deparIds
     * @throws BusinessException
     */
    public List<Long> findTaskMembersByResourceIds(List<Long> deparIds) throws BusinessException;

    /**
     * 根据tcode查询所有事项
     * @param tcode
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTaskSummaryByTcode(String tcode);

    /**
     * 根据组织id查询所有事项ID
     * @param deparIds
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByResourceIds(List<Long> orgIds,Integer[] relTypes) throws BusinessException;

    /**
     * @param taskId
     * @param orgIds
     * @param relTypes
     * @return
     * @throws BusinessException
     */
    public List<TaskMemberBean> findTaskMembersByResourceIds(Long taskId, List<Long> orgIds,Integer[] relTypes) throws BusinessException;

    /**
     * 指定事项阶段汇总数据
     * @author inspired
     * @param taskId
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    List<TaskReportBean> findTaskCollectReports(Long taskId,Long phaseId) throws BusinessException;


    /**
     * 查询承办单位未签收的人员名称
     * @param taskId
     * @param orgIds
     * @param relTypes
     * @return
     * @throws BusinessException
     */
    public String[] findUnreceiptedManagerTaskMembersByResourceIds(Long taskId, List<Long> orgIds,Integer[] relTypes) throws BusinessException;


    /**
     * 查询距离当前时间最接近的3条数据
     * @return
     * @throws BusinessException
     */
    public ListObject<TaskSummaryBean> findTaskSummaryBeansByCreateDate(Date createdate,Integer pageSize ,Integer start) throws BusinessException;

    /**
     * 统计事项各状态数量
     * @param key
     * @return
     * @throws BusinessException
     */
    public int countTaskSummaryByTstate(int key) throws BusinessException;

    /**
     * 通过父类来源获取子类来源数据
     * @param from
     * @param taskYear
     * @return
     * @throws BusinessException
     */
    public List<Map<String, Object>> findTaskSubFromByFrom(Long from, String taskYear) throws BusinessException;

    /**
     * 根据人员和状态查询任务条数
     * @param personId
     * @param state
     * @param memberRel
     * @return
     */
    public Integer findTaskCountByPerson(Long cid,Long personId,Integer[] state,Integer memberRel) throws BusinessException;
    /**
     *
     * @param pid 用户id
     * @return 通过用户id查询相关事项
     */
    public List<TaskMemberBean> findTaskByPersonId(Long pid,Integer memberRelType);

    //----------------------------------20161018------------------------------------------------

    /**
     * 根据单位查询任务
     * @param cid   单位id
     * @param from  创建时间
     * @param to    创建时间
     * @return
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTasksByCid(Long cid,Date from,Date to)throws BusinessException;

    /**
     * @param personId 人员id
     * @param from     创建时间
     * @param to       创建时间
     * @return
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTasksByDept(Long[] deptId,Date from,Date to)throws BusinessException;

    /**
     * @param personId 人员id
     * @param from     创建时间
     * @param to       创建时间
     * @return
     * @throws BusinessException
     */
    public List<TaskSummaryBean> findTasksByPer(Long[] personId,Date from,Date to)throws BusinessException;

    /**
     * 根据任务id查询催办记录
     * @param taskIds
     * @return
     * @throws BusinessException
     */
    public List<TaskRemindMemberBean> findTaskRemindMemberByTaskId(Long[] taskIds)throws BusinessException;

    /**
     * 根据任务Id删除任务
     * @param ids
     * @throws BusinessException
     */
    public void deleteTaskById(Long[] ids)throws BusinessException;

    void deleteTaskById(Long[] ids, boolean isLogic) throws BusinessException;

    /**
     * 判断人员是否为任务领导角色
     * @param pid 人员ID
     * @return
     *
     */
    Boolean isLeader(Long pid)  throws BusinessException;

    List<TaskMemberBean> findTaskMembersByTaskIdsAndRelationType(List<Long> taskIds, Integer[] relationTypes)
            throws BusinessException;

    public List<TaskMemberBean> findTaskMembersByTaskIdsAndResourceType(List<Long> taskIds, Integer[] resourceTypes) throws BusinessException;

    /**
     * 领导id和relationType查询包保事项详情
     * @param perId
     * @param key
     * @return
     */
    public List<TaskMemberBean> findTaskMembersByResourceIdsAndRelationType(
            Long perId, int key) throws BusinessException;
    /**
     * 通过事项id查询表JnFgwProjectBean的详情
     * @param id
     * @return
     */
    public JnFgwProjectBean findJnFgwProjectBeanByTaskId(Long id) throws BusinessException;

    /**
     * 领导批示
     * @param id
     * @return
     * @throws BusinessException
     */
    public List<TaskCommandBean> findTaskCommand(Long id) throws BusinessException;

    /**
     * 重点项目展示
     * @return
     */
    public List<JnTaskPublishBean> findAllPublished() throws BusinessException;

    /**
     * 查询最新有效的汇报信息
     * @param taskId
     * @return
     */
    public TaskReportBean findNewestReport4Task(Long taskId) throws BusinessException;

    /**
     * 批量查询最新汇报
     * @param taskIds 事项ID
     * @return key 为事项ID,value为最新汇报
     * @throws BusinessException
     */
    public Map<Long, TaskReportBean> findNewestReport4Task(Collection<Long> taskIds) throws BusinessException;

    /**
     * 根据任务id查询项目
     * @param taskId
     * @return
     * @throws BusinessException
     */
    public JnFgwProjectBean findProjectByTaskId(Long taskId) throws BusinessException;
    /**
     * 根据任务id查询所有有效（非被打回的汇报）汇报图片
     * @param taskId
     * @return
     */
    public List<Map<String, Object>> findReportImgsByTaskId(Long taskId) throws BusinessException;

    /**
     * 通过事项状态tstate查询事项
     * 添加二级查询  by chenx
     * @param i
     * @return
     */
    List<TaskSummaryBean> findAllTaskSummaryBeans(Integer[] i, Integer[] j) throws BusinessException;

    /**
     * 通过承办单位查询其所参与的所有事项
     * @param object
     * @param mstate
     * @return
     */
    List<TaskMemberBean> findTaskMembersByResourceIdAndMstate(Long depId, Integer mstate) throws BusinessException;

    /**
     * 通过id查询事项的所有汇报
     * @param id
     * @return
     * @throws BusinessException
     */
    List<TaskReportBean> findAllTaskReportBean(Long id) throws BusinessException;

    /**
     * 检查事项有无暂存汇报内容
     * @param taskId
     * @return
     * @throws BusinessException
     */
    Boolean findAllHistoryTaskReportBeans(Long[] ids) throws BusinessException;

    /**
     * 通过事项id和部门Id查询事项的所有汇报
     * @param id
     * @param depId
     * @return
     * @throws BusinessException
     */
    List<TaskReportBean> findAllTaskReportBean(Long id, Long departmentId) throws BusinessException;

    /**
     * 通过事项id和部门Id查询事项的所有汇报
     * @param id
     * @param depId
     * @return
     * @throws BusinessException
     */
    List<TaskReportBean> findAllTaskReportBeanBydepartmentIds(Long id, List<Long> departmentId) throws BusinessException;

    /**
     * 根据任务类型查询事项
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryBeanByTaskTypeId(Long typeId, Integer[] i) throws BusinessException;

    List<TaskSummaryBean> findTaskSummaryBean(String taskTypeId) throws BusinessException;

    ListObject<TaskSummaryBean> findTaskSummaryBeanByTaskTypeId(Long typeId, Integer[] i, Integer start, Integer range) throws BusinessException;
    /**
     * 根据任务类型name查血任务类型id
     * @param name
     * @return
     */
    TaskTypeBean findTaskTypeBeanByName(String name) throws BusinessException;
    TaskTypeBean findTaskTypeBeanByName(String name, Integer subType) throws BusinessException;
    TaskTypeBean findTaskTypeBeanLikeName(String name, Integer subType) throws BusinessException;
    TaskTypeBean findTaskTypeByNameAndSubType(String name, Integer subType, Long accountId) throws BusinessException;

    TaskTypeBean findTaskTypeByParam(Map<String, Object> map , Long accountId) throws BusinessException;

    /**
     * 根据事项id查询关注信息
     * @param id
     * @return
     * @throws BusinessException
     */
    List<TaskAttention> findDzdbAeeentionsByTaskId(Long id) throws BusinessException;

    /**
     * 添加领导批示
     * @param taskCommandBean
     * @throws BusinessException
     */
    void addTaskCommand(TaskCommandBean taskCommandBean) throws BusinessException;

    TaskSummaryBean findTaskSummaryBeanByIdAndTaskType(Long taskId,
                                                       Long l) throws BusinessException;

    /**
     * 通过事项id和责任单位查询事项的责任单位
     * @param taskId
     * @param key
     * @return
     * @throws BusinessException
     */
    TaskMemberBean findTaskMembersByTaskIdAndRelationType(Long taskId, Integer key) throws BusinessException;

    List<TaskMemberBean> findTaskMembersByTaskIdAndRelType(Long taskId, Integer key) throws BusinessException;

    /**
     * 通过事项id和责任单位查询事项的责任单位
     * @param taskId
     * @param key
     * @return
     * @throws BusinessException
     */
    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypes(
            Long taskId, Integer key) throws BusinessException;

    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypes(Long taskId, List<Integer> key) throws BusinessException;

    /**
     * 查询事项的进度
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findProcessState() throws BusinessException;

    /**
     * 根据事项id和状态查询事项
     * @param ids
     * @param i
     * @return
     */
    List<TaskSummaryBean> findTaskListByIdsAndTstate(
            java.lang.Long[] ids, Integer[] i) throws BusinessException;

    /**
     * 根据部门和承办查询taskMember
     * @param key
     * @param key2
     * @return
     * @throws BusinessException
     */
    List<TaskMemberBean> findByResourceAndRelation(Integer key, Integer key2) throws BusinessException;

    /**
     * 根据事项id查询事项的督办设置
     * @param taskid
     * @return
     * @throws BusinessException
     */
    TaskReportConfigBean findTaskReportConfigByTaskId(Long taskid) throws BusinessException;

    List<TaskReportConfigBean> findAllTaskReportConfigByTaskId(Long taskId) ;

    /**
     *
     * @param taskid
     * @param key
     * @return
     * @throws BusinessException
     */
    List<TaskProcessSummaryBean> findTaskProcessByTaskIdsAndPtype(
            Long taskid, Integer key) throws BusinessException;

    /**
     * 根据id查询汇报详情
     * @param valueOf
     * @return
     */
    TaskReportBean findTaskReportById(Long id) throws BusinessException;
    List<TaskReportBean> findTaskReportByIds(List<Long> ids) throws BusinessException;

    /**
     * 根据领导id查询级别
     * @param id
     * @return
     * @throws BusinessException
     */
    LeaderShowConfigBean findLeaderConfigBeanByPid(Long id) throws BusinessException;

    void addTaskMember(TaskMemberBean memberBean) throws BusinessException;
    void addTaskMember(List<TaskMemberBean> memberBean) throws BusinessException;


    /**
     * 根据事项id和人员id查询
     * @param valueOf
     * @param personId
     * @return
     */
    List<TaskMemberBean> findTaskMembersByTaskIdsAndPid(Long taskId,
                                                        Long personId);

    List<Long> findTaskMembersByTaskIdsAndPid(List<Long> taskIds,
                                                        Long personId);

    /**
     * 查询重点办的项目
     * @param taskTypelist
     * @return
     */
    List<TaskSummaryBean> findAllTaskSummaryBeanByTypes(
            String[] taskTypelist, Integer[] i);


    /**
     * 查询所有项目（按照投资截至月份排序）
     * @param id
     * @return
     */
    List<TaskReportBean> findAllTaskReportBeanOrderByEndMonth(Long id) throws BusinessException;

    /**
     * 按照月份查询当月的最新汇报
     * @param id
     * @param month
     * @return
     */
    TaskReportBean findNewestReportByMonth(Long id, Integer month) throws BusinessException;

    /**
     * 根据进度ID查询被催办的单位
     * created by huzy 2017/9/20 下午3:17
     * @param id
     * @return
     * @throws BusinessException
     */
    List<OrgUnitBean> findTaskRemindDepartmentByProcessId(Long id) throws BusinessException;
    /**
     * 根据进度ID查询被催办的人员
     * created by huzy 2017/9/20 下午3:17
     * @param id
     * @return
     * @throws BusinessException
     */
    List<OrgPersonBean> findTaskRemindPersonByProcessId(Long id) throws BusinessException;

    /**
     * 查询指定事项成员的汇报数据
     * @param id
     * @param memberPhaseId 事项成员阶段ID
     * @param memberId 事项成员ID
     * @param status
     * @return
     * @throws BusinessException
     */
    List<TaskReportBean> findAllTaskReportBeanTaskId(Long id, Long memberPhaseId, Long memberId, List<Integer> status) throws BusinessException;

    void setScreenScope(Long[] plateIds, String[] scope) throws BusinessException;

    void handleWithOutManagerMemberTask() throws BusinessException;

    void handleWithOutTaskPhaseTask() throws BusinessException;

    /**
     * 更新结束时间
     * @param taskIds 事项ID集合
     * @param endTime 结束时间
     * @param curUserId 操作人
     * @param isSys 是否是系统操作，系统操作就不需要记录日志
     */
    void updateTaskEndTime(List<Long> taskIds, Date endTime, Long curUserId, boolean isSys) throws BusinessException;

    /**
     * 根据事项ID查询该事项所有的附件
     * @param taskId
     * @return
     * @throws BusinessException
     */
    List<Map<String,Object>> findAllTaskFileByTaskId(Long taskId) throws BusinessException;

    List<CommonResourceRelationBean> findAllTaskFileRelationsByTaskIds(List<Long> taskIds,Long accountId) throws BusinessException;

    /**
     * 查询汇报的相关附件 即字段名字为reportFile的附件
     * @param cid 单位ID
     * @param id 汇报ID，来自{@link TaskReportBean#id}
     * @return
     */
    List<SpaceFileBean> findReportFileById(Long cid, Long id) throws BusinessException;

    /**
     * 查询任务所有汇报的相关附件
     * @param cid 单位ID
     * @param taskId 事项
     * @return
     */
    List<SpaceFileBean> findReportFileByTaskId(Long cid,Long taskId) throws BusinessException;

    /**
     * 查询汇报的沟通详情附件（人大政协业务） 即字段名字为detailFile的附件
     * @param cid 单位ID
     * @param id 汇报ID，来自{@link TaskReportBean#id}
     * @return
     */
    List<SpaceFileBean> findReportDetailFileById(Long cid, Long id) throws BusinessException;

    /**
     * 根据事项ID查询事项分类
     * create by huzy 2018/2/9 15:00
     * @param taskId
     * @return
     */
    TaskTypeBean findTaskTypeBeanByTaskId(Long taskId) throws BusinessException;
    TaskTypeBean findTaskTypeBeanByTaskId(Map<String,Object> params) throws BusinessException;
    /**
     * 根据iD查询任务类别
     * create by inspired
     * @param
     * @return
     */
    TaskTypeBean findTaskTypeBeanById(Map<String, Object> params) throws BusinessException;

    /**
     * 根据当前登录和事项ID查询最新汇报
     * @param taskId
     * @param pid
     * @return
     * @throws BusinessException
     */
    TaskReportBean findTaskReportByIdAndCreateBy(Long taskId, Long pid) throws BusinessException;

    /**
     * 补充完整事项留言(也可能是其他的内容 进展情况?
     * @param beans
     * @return
     * @throws BusinessException
     */
    List<TaskProcessBO> fillTaskProcessBOs(List<TaskProcessSummaryBean> beans) throws BusinessException;

    /**
     * 根据汇报类型查询事项配置
     * @param reportType
     * @return
     */
    List<TaskReportConfigBean> findTaskReportConfigByReportType(Integer reportType) throws BusinessException;

    /**
     * 根据父ID查询子任务
     * @param id
     * @return
     */
    List<TaskSummaryBean> findTaskSummaryBeansByParentId(Long id) throws BusinessException;
    List<TaskSummaryBean> findTaskSummaryBeansByParentIds(List<Long> ids) throws BusinessException;
    /**
     * 根据父ID查询子任务（包含未交办）
     * @param id
     * @return
     */
    List<TaskSummaryBean> findTaskSummaryBeansByParentIdTemp(Long id) throws BusinessException;
    List<TaskSummaryBean> findTaskSummaryBeansByParentIdsTemp(Long[] ids) throws BusinessException;
    /**
     * 根据父ID和部门id查询子任务
     * @param id
     * @return
     */
    List<Map<String,Object>> findTaskSummaryBeansByParentIdAndDepartmentId(Long id,Long departmentId,Integer type) throws BusinessException;

    /**
     * 查询当前登录所能查看的消息类型
     * @param personId
     * @return
     */
    ListObject<MessageTypeBean> findMessageTypeBeanByAuthorizedPerson(Integer start, Integer pageSize) throws BusinessException;



    /**
     *根据taskTypeId查找 状态不为删除态的TaskSummaryBean,
     *
     **/
    List<TaskSummaryBean> findByTaskTypeAndDontDelete(String taskTypeId) throws BusinessException;

    Integer findMaxSerialNumByTaskTypeAndIsValid(String taskTypeId) throws BusinessException;
    /**
     *根据taskId查找 事项
     *
     **/
    TaskSummaryBean getTaskSummaryById(Long taskId) throws BusinessException;

    /**
     *根据taskTypeId 和 tstate状态查询 TaskSummaryBean,
     *
     **/
    List<TaskSummaryBean> findByTaskTypeAndDontDelete(List<Long> taskTypeId) throws BusinessException;
    /**
     *检查子任务是否由完成时间和责任单位
     *
     **/
    Boolean checkChildrenTask(Long id) throws BusinessException;

    /**
     * 根据消息类型ID查询详情
     * @param aLong
     * @return
     * @throws BusinessException
     */
    MessageTypeBean findMessageTypeById(Long aLong) throws BusinessException;

    /**
     * 根据
     * @param id
     * @param cancount
     * @return
     * @throws BusinessException
     */
    List<TaskTypeBean> findTaskTypesByParentIdAndCanCount(long parentId, int canCount) throws BusinessException;


    /**
     * 更新没有承办部门的信息
     *
     * */
    void updateNotDeptInfos()throws BusinessException;

    /**
     * 根据成员id集合查找出对应的memberBean
     *
     * */
    List<TaskMemberBean> findTaskMemberByIds(List<Long> memberIds) throws BusinessException;

    /**
     * 更新查看标记
     *
     * */
    void updateTaskSummaryByLookOverFlag(TaskSummaryBean summary, String flag)throws BusinessException;

    /**
     * 根据ID获取当前阶段
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    TaskPhase findTaskPhaseById(Long phaseId)throws BusinessException;

    /**
     * 根据一个阶段获取下一个有效的阶段
     * @author inspired
     * @param config
     * @return
     * @throws BusinessException
     */
    TaskPhaseReportConfig findNextTaskPhaseConfigByConfig(TaskPhaseReportConfig config)throws BusinessException;

    /**
     * 获取事项成员分派的人
     * @author inspired
     * @param taskId
     * @param memberId
     * @return
     * @throws BusinessException
     */
    List<TaskMemberBean> findTaskDispatchMember(Long taskId,Long memberId) throws BusinessException;

    /**
     * 根据ID获取当前阶段
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    List<TaskPhase> findTaskPhaseByIds(List<Long> phaseId)throws BusinessException;

    /**
     * 查询所有的TaskPhase
     * @return 返回一个map结构 key:主键id, value:TaskPhase的Map
     * @throws BusinessException
     *
     */
    Map<Long,TaskPhase> findAllTaskPhaseMap() throws BusinessException;

    /**
     * 查询进行中已超期，单位未办结事项
     * @param key
     * @param key1
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findOverdueNotRunTaskSummary(int key, int key1)throws BusinessException;

    /**
     * 保存members
     * @param saveList 需要保存的member集合
     * @param bossIds  if not null execute send message
     * @param summarys  if not null execute send message
     *
     * */
    void saveMembers(List<TaskMemberBean> saveList, Long[] bossIds, List<TaskSummaryBean> summarys)throws BusinessException;

    /**
     * @param taskIds
     * @param bossIds
     * @param resourceId
     * */
    Map<Long,List<TaskSummaryBean>> findTaskMemberByTaskIdsAndTypeAndResourceId(Long[] taskIds, Long[] bossIds, Integer resourceType)throws BusinessException;

    /**
     * 撤销推送信息
     *
     * */
    void revokePush(Long[] taskIds, Long[] bossIds, Integer resourceType)throws BusinessException;

    /**
     * 撤销前的检查
     *
     * */
    Map<Long,List<TaskSummaryBean>> checkRevokePush(Long[] taskIds, Long[] bossIds, Integer resourceType)throws BusinessException;

    /**
     * 查找领导关注
     *
     * */
    PageInfo<LeaderFollowVo> findLeaderFollowVos(int start, int pageSize, Long taskType, Long taskId, Long resourceId, boolean isLeader)throws BusinessException;
    /**
     * 查找督察处理记录
     *
     * */
    PageInfo<SupervisionTreatmentVo> findSupervisionTreatmentVos(int start, int pageSize)throws BusinessException;

    /**
     * 查询所有的taskPhaseConfigBean
     *
     * */
    List<TaskPhaseReportConfig> findAllPhaseReportConfig()throws BusinessException;



    /**
     * 查找所有的taskSummaryBean 组装成 Map(taskId,tskSummaryBean)形式
     *
     * @return
     * Map<taskId,tskSummaryBean>
     *
     * */
    Map<Long,TaskSummaryBean> findAllTaskSummaryByMap() throws BusinessException;


    /**
     * 分页查询所有报告模板
     * @param start
     * @param pageSize
     * @return
     */
    ListObject<ReportTemplateBean> findReportTemplateByPageAll(Integer start, Integer pageSize)throws BusinessException;

    /**
     * 新增模板
     * @param templateBean
     * @throws BusinessException
     */
    void addReportTemplate(ReportTemplateBean templateBean)throws BusinessException;

    /**
     * 根据ID查询当前模板详情
     * @param id
     * @return
     * @throws BusinessException
     */
    ReportTemplateBean findReportTemplateById(Long id)throws BusinessException;

    /**
     * 查询所有
     * @return
     * @throws BusinessException
     */
    List<ReportTemplateBean> findReportTemplateByAll()throws BusinessException;

    /**
     * 根据taskId和memberId 查询出memberPhases
     * @param taskId
     * @param memberId
     * @return
     * @throws BusinessException
     */
    List<TaskMemberPhase> findTaskMemberPhaseByTaskIdAndMemberId(Long taskId,Long memberId)throws BusinessException;

    /**
     * 删除模板
     * @param templateId
     * @throws BusinessException
     */
    void deleteReportTemplateById(Long[] templateId)throws BusinessException;

    /**
     * 根据taskid[]与 state[]查找出对应的
     * @param taskIds
     * @param tstate
     * @return state 与 taskIds的映射关系
     */
    Map<Integer,List<TaskSummaryBean>> findTaskSummaryByTaskIdAndTstate(Long[] taskIds,Integer[] tstate)throws BusinessException;


    void updateTaskSummarys(List<TaskSummaryBean> summarys)throws BusinessException;

    PageInfo<SuspendedVo> findSuspendedVos(int start, int pageSize, SuspendedVo bean, List<Long> orgIds)throws BusinessException;

    /**
     * 获取事项查看统计
     * @param taskId
     * @return
     */
    List<Map<String,Object>> findViewCount(String taskId)throws BusinessException;

    /**
     * 获取领导批示统计
     * @param taskId
     * @param personId
     * @return
     */
    List<Map<String,Object>> findInstructionsCount(Long taskId)throws BusinessException;

    /**
     * 获取领导批示和留言的数量
     *
     * @param taskId
     * @param excludedIds
     * @return
     * @throws BusinessException
     */
    List<Map<String,Object>> findInstructionsAndLeavingaMessageCount(Long taskId, List<Long> excludedIds)throws BusinessException;

    /**
     * 获取事项查看相关数据
     * @param taskId 事项id
     * @param type 对应 BehaviorEnum.ViewTask.key
     * @return vo 集合
     */
    List<ViewTaskVo> findViewTaskVos(String taskId, Integer type)throws BusinessException;

    /**
     * 根据事项ID查询当前事项阶段信息
     * @param taskId
     * @return
     * @throws BusinessException
     */
    List<TaskPhase> findTaskPhaseByTaskId(Long taskId)throws BusinessException;

    /**
     * 查询当前事项所有汇总计划
     * @param taskId
     * @param i
     * @return
     * @throws BusinessException
     */
    List<TaskMemberPhase> findTaskMemberPhaseByTaskIdAndType(Long taskId, int i)throws BusinessException;

    /**
     * 修改计划
     * @param phases
     * @throws BusinessException
     */
    void updateTaskPhaseList(List<TaskPhase> phases)throws BusinessException;

    /**
     * 通过id修改阶段计划名称
     * @param phases
     * @throws BusinessException
     */
    void updateTaskPhaseById(String id, String name)throws BusinessException;

    /**
     * 根据事项id与状态stats查询出对应的汇报记录
     * @param taskIds 事项id集合
     * @param status 状态集合
     * @return
     */
    List<TaskReportBean> findTaskReportByTaskIdAndStatus(List<Long> taskIds, List<Integer> status)throws BusinessException;

    /**
     * 根据事项id与状态stats查询出对应的汇报记录
     * @param taskIds 事项id集合
     * @param status 状态集合
     * @return
     */
    List<TaskReportBean> findTaskReportByTaskIdAndStatus(List<Long> taskIds, List<Integer> status, List<Long> deptId)throws BusinessException;

    /**
     *批量汇报上报
     * @param taskIds 事项ids
     * @param cid
     * @param pid
     * @param status 需要更新的状态
     * @param findStatus
     * @throws BusinessException
     */
    List<String> batchReportUp(Long[] taskIds,Long cid, Long pid,Integer status, Integer[] findStatus) throws BusinessException;

    /**
     * 得到授权给指定人员的事项类型
     * @param cid
     * @param pid
     * @return
     */
    List<TaskTypeBean> findTaskTypeByPid(Long cid, Long pid) throws BusinessException;

    /**
     * 根据事项的id查询出事项map (key:事项id,value:事项实体)
     * @param taskIds
     * @return
     */
    Map<Long,TaskSummaryBean> findTaskSummaryByIds(Long [] taskIds)throws BusinessException;

    /**
     * 查询已经超出完成时间的事项
     * @param endDate
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryBeanByEndDate(Date endDate);

    /**
     * 查询当前类型所有状态事项
     * @param typeId
     * @param startDate
     * @param endDate
     * @param key
     * @param type
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummarByType(String typeId, Date startDate, Date endDate, int key, Integer type)throws BusinessException;

    /**
     * 更新事项状态
     * @param taskIds
     * @param state
     */
    void updateTaskSummaryStateById(Collection<Long> taskIds, Integer state) throws BusinessException;

    /**
     * 根據ID查詢事項
     * @param taskId
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryBeanByIds(List<Long> taskId) throws BusinessException;

    /**
     * 根據ID查詢事項(不含其他条件)
     *
     * @param taskId
     * @return
     * @throws BusinessException
     */
    ListObject<TaskSummaryBean> findTaskSummaryByIds(List<Long> taskId, Integer start, Integer pageSize) throws BusinessException;

    /**
     * 查询当前事项所有承办单位
     * @param id
     * @param key
     * @return
     * @throws BusinessException
     */
    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypeAndMstate(Long id, int key) throws BusinessException;
    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypeAndMstate(Long id, int key,int mstate) throws BusinessException;

    /**
     * 找出指定成员类型对应状态的事项成员信息
     * @param taskIds 要查找的事项id
     * @param relationType 指定成员类型 {@link TaskEnum.TaskMemberRelTypeEnum}
     * @param mstate 成员办结情况 {@link TaskEnum.TaskMemberStateEnum}
     * @return
     */
    List<TaskMemberBean> findTaskMembersByTaskIdsAndRelationTypeAndMstate(List<Long> taskIds, Integer relationType,Integer mstate) ;
    /**
     * 删除领导关注事项成员
     * @param personId
     * @throws BusinessException
     */
    void deleteLeaderAttentionMember(Long personId,Long taskId,boolean isLeader) throws BusinessException;

    /**
     * 根据事项ID和成员类型成员角色查询
     * @param id
     * @param key
     * @param key1
     * @return
     */
    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypeAndResourceType(Long id, int key, int key1);

    Map<String,Object>findTaskPhaseTemplateByTaskType(Long taskTypeId) throws BusinessException;

    /**
     * 统计所有事项的留言和批示数量
     * @param id
     * @return
     * @throws BusinessException
     */
    int countTaskProcessSummaryByTaskId(Long id) throws BusinessException;

    /**
     * 统计留言信息
     * @param id
     * @return
     * @throws BusinessException
     */
    List<Map<String,Object>> findLeavingaMessageCount(Long id) throws BusinessException;

    /**
     * 获取下次需要自增的规则相关
     * @param taskTypeId
     * @return
     * @throws BusinessException
     */
    TaskTypeRule findNextTCode(Long taskTypeId)throws BusinessException;

    /**
     * 根据ID获取当前子阶段
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    TaskPhaseReportConfig findTaskPhaseReportConfigById(Long taskPhaseReportConfigId)throws BusinessException;

    /**
     * 根据事项id和当前人的id查询出事项与当前人的关系,目前只会返回两种,督办与承办.
     * @param taskId 事项id
     * @param cid 圈子id
     * @param pid 当前登录人员的id
     * @return TaskMemberRelTypeEnum
     */
    TaskMemberRelTypeEnum findRelationTypeBySummaryId(Long taskId, Long cid, Long pid)throws BusinessException;

    /**
     * 发送短信
     * @param content 短信类容
     * @param numbers 手机号码
     * @return
     */
    void sendSms(String content,List<String> numbers,String currentUserName);

    /**
     * 发送短信
     * @param summary 事项bean
     * @param context 发送内容
     * @throws BusinessException
     */
    void sendSms(TaskSummaryBean summary, String context) throws BusinessException;

    /**
     * 发送短信
     * @param summarys 事项集合
     * @param context 待发送短信前缀内容 如: 督办交办了 督办批示了 督办催办了 督办办结了
     * @throws BusinessException
     */
    void sendSms(List<TaskSummaryBean> summarys, String context) throws BusinessException;

    /**
     * 上报汇报发送短信
     * @param summarys
     * @param context
     * @throws BusinessException
     */
    void sendSmsForReport(List<TaskSummaryBean> summarys, String context) throws BusinessException;

    /**
     * 催办专用
     * @param deptMaps
     * @param content
     * @throws BusinessException
     */
    void sendSmsByUrge(List<Map<String,Object>> deptMaps, String content)throws BusinessException;

    /**
     * 根据部门集合与人员集合查询出person.若是部门id则查询出的人员是部门联系人
     * @param deptids 非必须
     * @param pids 非必须
     * @return List<OrgPersonBean>
     */
    List<OrgPersonBean> findPersonByDeptAndPid(List<Long> deptids, List<Long> pids)throws BusinessException;


    List<TaskTypeBean> findTaskTypesByParentId(Long taskType) throws BusinessException;

    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypeAndResourceType(Long taskId, List<Integer> relationType, List<Integer> resourceType) throws BusinessException;

    List<TaskMemberBean> findTaskMembersByTaskIdAndRelationTypeAndResourceType(List<Long> taskIds, List<Integer> relationType, List<Integer> resourceType) throws BusinessException;

    void updateTaskPhaseReportConfig(List<TaskPhaseReportConfig> list) throws BusinessException;

    /**
     * 批量汇报
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    List<TaskPhaseReportConfig> findTaskPhaseReportConfigByIds(String[] phaseId) throws BusinessException;

    List<TaskReportBean> findAllTaskReportBeanTaskId(Long taskId, Long memberPhaseId, Long memberId, Long departmentId, List<Integer> status) throws BusinessException;
    /**
     * 查询即将超出完成时间的事项
     * @param endDate
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findExpireTaskSummaryBeanByEndDate(Date endDate)throws BusinessException;

    /**
     * 查询所有状态下的事项
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryAll(Integer[] status) throws BusinessException;

    /**
     * 根据事项id查询
     * @param id
     * @return
     * @throws BusinessException
     */
    List<TaskMemberPhaseReportConfig> findTaskMemberPhaseReportConfigByTaskId(Long id) throws BusinessException;
    List<TaskMemberPhaseReportConfig> findTaskMemberPhaseReportConfigByTaskIds(List<Long> ids) throws BusinessException;

    /**
     * 根据ID查询详情
     * @param id
     * @return
     * @throws BusinessException
     */
    TaskMemberPhaseReportConfig findTaskMemberPhaseReportConfigById(long id) throws BusinessException;

    /**
     * 查询当前阶段所有小阶段
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    List<TaskPhaseReportConfig> findTaskPhaseReportConfigByPhaseId(Long phaseId) throws BusinessException;

    /**
     * 查询所有阶段信息
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findTaskMemberPhaseReportConfig() throws BusinessException;

    /**
     * 查询当前人员所选择回报事项
     * @param phaseId
     * @return
     * @throws BusinessException
     */
    List<TaskMemberPhaseReportConfig> findTaskMemberPhaseReportConfigByTaskIdAndPhaseId(Long[] phaseId,Long taskId) throws BusinessException;

    TaskMemberPhaseReportConfig findTargetTaskMemberPhaseReportConfig(Long taskId,Long phaseId,Long memberId,Long phaseReportConfigId);

    /**
     * 更新汇报状态
     * @param list
     * @throws BusinessException
     */
    void updateTaskMemberReportConfig(List<TaskMemberPhaseReportConfig> list) throws BusinessException;

    /**
     * 处理未在阶段中存在的事项
     * @return 返回值为事项ID集合
     */
    List<Map<String, Object>> findTaskMemberPhaseReportConfigByAll() throws BusinessException;

    /**
     * 根据事项ID查询所有小阶段信息
     * @return
     * @throws BusinessException
     */
    List<TaskPhaseReportConfig> findTaskPhaseReportConfigByTaskId(Long taskId,Long phaseId) throws BusinessException;
    List<TaskPhaseReportConfig> findTaskPhaseReportConfigByTaskId(Long taskId) throws BusinessException;

    /**
     * 根据事项ID查询阶段信息
     * @param taskId
     * @return
     * @throws BusinessException
     */
    List<TaskMemberPhase> findTaskMemberPhaseByTaskId(Long taskId) throws BusinessException;

    /**
     * 查询某成员阶段是否已汇报
     * @param taskId
     * @param id
     * @return
     * @throws BusinessException
     */
    TaskReportBean findTaskReportByTaskIdAndReportId(Long taskId, Long id, Long memberId) throws BusinessException;

    /**
     * inspired 根据成员阶段获取最新汇报的情况
     */
    TaskReportBean findNewTaskReportByTaskMemberPhaseReportConfig(TaskMemberPhaseReportConfig bean);

    /**
     * 获取除开暂存汇报之外的最近的一次汇报内容
     * @author inspired
     * @param bean
     * @return TaskReportBean
     */
    TaskReportBean findPrevTaskReportByTaskMemberPhaseReportConfig(TaskMemberPhaseReportConfig bean);


    /**
     * 根据事项状态查询
     * @param key
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryBeanByTstate(Integer[] key) throws BusinessException;

    /**
     * 根据小阶段和MemberID查询当前人员的该阶段信息
     * @param reportConfigId
     * @param memberId
     * @return
     * @throws BusinessException
     */
    TaskMemberPhaseReportConfig findTaskMemberPhaseReportConfigByReportIdAndMemberId(Long reportConfigId, Long memberId) throws BusinessException;


    /**
     * 根据时间查询当前登录人的事项        -- 日程首页使用
     * @param keyParam
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryBeanForschedule(Map<String,Object> keyParam) throws BusinessException;

    /**
     * 查询已经超出完成时间的事项
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryBeanByEndDateNew()throws BusinessException;

    /**
     * 查询即将超出完成时间的事项
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findExpireTaskSummaryBeanByEndDateNew()throws BusinessException;

    /**
     * 根据事项ID和人员ID查询
     * @param id
     * @param departIdList
     * @return
     * @throws BusinessException
     */
    List<TaskMemberBean> findTaskmemberByTaskIdAndResourceId(Long id, List<Long> departIdList)throws BusinessException;
    List<TaskMemberBean> findTaskmemberByTaskIdAndResourceId(Long id, Long departId)throws BusinessException;
    List<TaskMemberBean> findTaskmemberByTaskIdsAndResourceId(List<Long> ids, Long departId)throws BusinessException;

    /**
     * 根据事项ID 和事项成员ID 和 阶段ID 修改事项成员阶段汇报状态（如果所有事项成员都汇报那么则修改事项汇报状态为已汇报）
     *
     * @param report@throws BusinessException
     */
    void updateTaskMemberPhaseReportConfigByTaskIdAndMemberIdAndPhaseId(TaskReportBean report, Integer isReport)throws BusinessException;

    /**
     * 根据阶段ID修改阶段汇总状态
     * @param phaseId
     * @param isReport
     * @throws BusinessException
     */
    void updateTaskPhaseIsGatherById(Long phaseId, Integer IsGather)throws BusinessException;

    void deleteTaskPhaseById(Long phaseId) throws BusinessException;

    /**
     * 查询汇总为进展滞后的事项
     * @param key
     * @param key1
     * @return
     */
    List<TaskSummaryBean> findTasksummaryBeanByReportStateAndTstate(Integer key, Integer key1);

    /**
     * 这个地方是用来在督办立项的时候交办修改了阶段信息做处理的
     * @param taskId
     * @throws BusinessException
     */
    void deleteTaskmemberPhaseReportConfigByTaskId(Long taskId)throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 删除指定资源
     * @createTime 2021/5/13 16:33
     */
    void deleteTaskMemberPhaseReportConfig(Long taskId, Long memberId, Long phaseId)throws BusinessException;

    /**
     * 根据事项ID成员ID查询最新的汇报信息
     * 如果查询最新已经通过的汇报，这个接口尽量不要使用，因此已经通过的数据状态只能是通过和历史状态
     * 如果需要查询最新已经通过的汇报请调用接口findTaskReportByMemberIdAndTaskId
     * @param taskId
     * @param id
     * @return
     * @throws BusinessException
     */
    TaskReportBean findTaskReportByTaskIdAndMemmberId(Long taskId, Long id)throws BusinessException;

    /**
     * 根据类型ID查询
     * @param taskType
     * @return
     * @throws BusinessException
     */
    boolean getTaskTypeByIds(Long[] taskType)throws BusinessException;

    /**
     * 根据事项ID查询
     * @param taskIds
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findTaskMemberByTaskIds(String taskIds)throws BusinessException;

    /**
     * 根据ID查询类型
     * @param taskCategory
     * @return
     * @throws BusinessException
     */
    TipEnumBean getTipEnumById(Long taskCategory)throws BusinessException;

    /**
     * 根据事项ID查询所有任务类型并去重复
     * @param taskIds
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findTipEnumByIds(String taskIds)throws BusinessException;

    /**
     * 定时器接口
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findTaskMemberByReprotStaus()throws BusinessException;

    /**
     * 定时器接口
     * @return
     * @throws BusinessException
     */
    void updateTaskMemberBySummaryState(Integer unitState, Integer overdue)throws BusinessException;
    /**
     * 定时器接口
     * @param unitState
     * @param overdue
     * @throws BusinessException
     */
    void updateTaskFromSlowToNormal()throws BusinessException;

    /**
     * 根据事项ID和角色类型查询
     * @param taskId
     * @param key
     * @return
     * @throws BusinessException
     */
    String findTaskMemberByTaskIdAndRelationType(Long taskId, Integer key)throws BusinessException;
    String findMemberIdsByTaskIdAndRelationType(Long taskId, Integer key)throws BusinessException;

    String findTaskMemberByTaskIdAndRelationTypes(Long taskId, Integer[] key)throws BusinessException;

    /**
     *
     * @param taskId
     * @param parseLong
     * @param key
     * @return
     */
    List<TaskMemberBean> findTaskmemberByTaskIdAndResourceIdAndRelationType(Long taskId, Long parseLong, int key)throws BusinessException;
    List<TaskMemberBean> findTaskmemberByTaskIdAndResourceIdAndRelationType(Long taskId, List<Long> parseLong, int key)throws BusinessException;
    List<TaskMemberBean> findTaskmemberByTaskIdAndResourceIdAndRelationTypes(Long taskId, List<Long> parseLong, List<Integer> keys)throws BusinessException;
    TaskMemberBean findTaskMemberBySummaryIdAndResourceIdAndRelationType(Long taskId, Long parseLong, int key)throws BusinessException;

    /**
     * 获取父任务信息
     * @param taskId
     * @return
     * @throws BusinessException
     */
    TaskSummaryBean  findTaskSummaryBeanBySonId(Long taskId)throws BusinessException;

    /**
     * 查询事项成员
     * @param taskId
     * @param relationKeys
     * @param pid
     * @return
     */
    List<TaskMemberBean> findTaskMembersByTaskIdWithRelationTypeAndPid(Long taskId, List<Integer> relationKeys, Long pid) throws BusinessException, SQLException;

    Map<Long,List<TaskMemberBean>> findTaskMembersByTaskIdWithRelationTypeAndPid(List<Long> taskId, List<Integer> relationKeys, Long pid) throws BusinessException, SQLException;

    /**
     * 根据事项ID和成员ID查询是否存在阶段信息
     * @param taskId
     * @param id
     * @return
     */
    List<TaskMemberPhaseReportConfig> findTaskMemberPhaseReportConfigByTaskIdAndMemberId(Long taskId, Long id) throws BusinessException;

    /**
     * 查询列表图形统计
     * @param bean
     * @return
     */
    ListStatisticsVo getListStatisticsCount(Integer listType, String taskTypeId, String year) throws BusinessException;

    List<TaskSummaryTemporaryBean> findAllTaskSummaryAndSonTask(Long taskId,Long pid) throws BusinessException;

    /**
     * 主要用于查询列表中具体台账具体状态下的操作配置
     * @param params
     * @return
     * @throws BusinessException
     */
    List<Map<String,Object>> findListStatusSetByParams(Map<String,Object> params)throws BusinessException;

    /**
     * 查询指定人指定任务类型下指定台账的设置，最多两条数据
     * @param pid
     * @param taskTypeId
     * @param listType
     * @return
     * @throws BusinessException
     */
    PersonListSetBean findPersonListSetByPidAndTaskTypeIdAndListTypeAndSetType(Long pid, Long taskTypeId, Integer listType,Integer setType)throws BusinessException;

    /**
     * 删除状态设置
     * @param listStatusSetBeans
     * @throws BusinessException
     */
    void deleteListStatusSet(List<ListStatusSetBean> listStatusSetBeans)throws BusinessException;

    void saveOrUpdatePersonListSet(List<PersonListSetBean> personListSet)throws BusinessException;

    void saveOrUpdateListstatusSet(List<ListStatusSetBean> listStatusSet)throws BusinessException;


    List<ListStatusSetBean> findListStatusSetByListSetIdAndListStatus(Long id, Integer listStatus)throws BusinessException;


    List<TemplateFileBean> findTemplateFileBeansByCriterion(Criterion cr, Integer start, Integer pageSize)throws BusinessException;

    void addTemplateFileBean(TemplateFileBean templateFile)throws BusinessException;

    void saveOrupdateTemplateFileBean(List<TemplateFileBean>templateFiles)throws BusinessException;

    TemplateFileBean findTemplateFileBeanById(Long id)throws BusinessException;

    List<TemplateFileBean> findTemplateFileBeansByTaskTypeIdAndType(Long taskTypeId,Integer type)throws BusinessException;

    String findTaskMemberNameByTaskIdAndRelationType(Long summaryId, int key)throws BusinessException;

    /**
     * 查询某个事项某个成员最新汇报信息
     * @param summaryId
     * @param memberId
     * @return
     * @throws BusinessException
     */
    TaskReportBean findNewTaskReportByTaskIdAndMemberId(Long summaryId, Long memberId)throws BusinessException;
    TaskReportBean findNewTaskReportByTaskIdAndMemberIdAndConfigId(Long summaryId, Long memberId, Long phaseReportConfigId)throws BusinessException;

    TaskPhaseTemplate findTaskPhaseTemplateByCriterion(Criterion c)throws BusinessException;

    List<TaskListTemplateBean> findTaskListTemplateByCriterion(Criterion c)throws BusinessException;

    /**
     *
     *根据任务列表进行分页数据
     */
    ListObject<TaskListTemplateBean> findTaskListTemplate(Criterion c)throws BusinessException;

    List<TaskListTmpColRelBean> findTemplateColsByTemplateId(long id)throws BusinessException;

    /**
     * 获取事项默认阶段（非当前阶段）
     * @author inspired
     * @param referenceId
     * @return
     */
    TaskPhase getDefaultPhaseByTaskId(Long referenceId)throws BusinessException;

    /**
     * 获取事项当前阶段（与当前时间对应）
     * @author inspired
     * @param taskId
     * @return
     */
    TaskPhase getNowTaskPhaseByTaskId(Long taskId);

    void saveOrUpdateAll(List<Object> taskProcessSummaryBeans)throws BusinessException;

    Map<String, Integer> countTaskSummaryByRootDep(Map<String, Object> params) throws BusinessException;

    boolean saveOrUpdateTaskSummary(TaskSummaryBean taskSummaryBean);

    /**
     * 查询该任务相关文件
     * @param id
     * @param params 参数条件
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findSpaceFilesByResourceIdsAndParams(List<Long> ids, Map<String, Object> params)throws BusinessException;

    /**
     * 查询正常的和历史的汇报
     * @param taskId
     * @param id
     * @param configId
     * @return
     * @throws BusinessException
     */
    TaskReportBean findNewTaskReportByTaskIdAndMemmberIdAndConfigId(Long taskId, Long id, Long configId)throws BusinessException;

    /**
     * 查询汇报
     * @param ci
     * @return
     * @throws BusinessException
     */
    List<TaskReportBean> findTaskReportByCriterion(Criterion ci)throws BusinessException;

    /**
     * 查询类型
     * @param ci
     * @return
     * @throws BusinessException
     */
    List<TaskTypeBean> findTaskTypeByCriterion(Criterion ci)throws BusinessException;

    /**
     * 是否未事项承办单位,督办，协办,返回memberId
     * @param pid
     * @param taskId
     * @return
     * @throws BusinessException
     */
    List<Long> isTaskManager(Long pid, Long taskId,List<Integer> type)throws BusinessException;

    TaskMemberBean getTaskRoleMember(Long pid, Long taskId,Integer type)throws BusinessException;
    /**
     * 此人在事项中成员角色，主要用于前端获取，其他地方需要请在map中继续封装数据
     * @param taskId
     * @return
     * @throws BusinessException
     */
    Map<String,Object> hasTaskPower(Long taskId,List<Integer> type)throws BusinessException;

    List<Map<String, Object>> findTaskSummaryVideoListByParams(Map<String, Object> params)throws BusinessException;


    List<Map<String, Object>> findTaskSummaryVideoList(Map<String, Object> params)throws BusinessException;

    /**
     * 获取指定人员督办事项数量
     *@param ids 人员ID集合
     * @return
     * @throws BusinessException
     */
    Map<String,Integer> getTaskCountByPersonId(Long [] ids) throws BusinessException;

    /**
     * 获取指定部门所有督办事项数量
     * @param depId 部门ID
     * @return
     * @throws BusinessException
     */
    Map<String,Integer> getTaskCountByDepId(long depId) throws BusinessException;

    /**
     * 获取指定人员督办事项类型及事项数量
     * @param personId 人员ID
     * @return
     * @throws BusinessException
     */
    List<Map<String,Object>> getTaskTypesByPersonId(long personId) throws BusinessException;

    /**
     * 获取指定部门督办事项类型及事项数量
     * @param depId 部门ID
     * @return
     * @throws BusinessException
     */
    List<Map<String,Object>> getTaskTypesByDepId(long depId) throws BusinessException;

    List<String> findAllTaskTypeByOther(List<Long> resourceIds)throws BusinessException;

    /**
     * 插入事项修改serial_num
     */
    void updateSerialNum(Integer serialNum)throws BusinessException;

    /**
     * 查询某个memberId的最新汇报（已通过的）
     * @param memberId
     * @param taskId
     * @return
     */
    TaskReportBean findTaskReportByMemberIdAndTaskId(Long memberId, Long taskId)throws BusinessException;
    /**
     * 查询某个memberId,某个阶段的最新汇报（已通过的）
     * @param memberId
     * @param taskId
     * @return
     */
    TaskReportBean findTaskReportByMemberIdAndTaskIdAndPhaseId(Long memberId, Long taskId, Long phaseId)throws BusinessException;
    List<TaskReportBean> findTaskReportByMemberIdsAndTaskIdAndPhaseId(List<Long> memberIdList, Long taskId, Long phaseId)throws BusinessException;

    Map<Long, TaskReportBean> findTaskReportByMemberIdAndTaskIdMap(List<Long> memberId, Long taskId)throws BusinessException;

    /**
     * 签收任务自动签收该任务下子任务
     * @param id
     */
    void signatureTaskSon(Long id) throws BusinessException;


    Map<String,Object> findTaskOrgBeanbyId(Map<String,Object> params)throws BusinessException;
    /**
     * 查询该任务下的子任务事项的基本信息和最新汇报信息,传个pid，因为多线程调用无法获取到pid,
     * 如果没有多线程的影响，pid直接传null也是可以的
     *
     */

    List<Map<String, Object>> findSonTaskSummaryByTaskId(Long id,Long pid)throws BusinessException;

    /**
     * 查询当前人员承办事项的所有领导批示
     * @param start
     * @param pageSize
     * @return
     * @throws BusinessException
     */
    PageInfo<Map<String,Object>> findLeaderDraftDataByPid( Integer start, Integer pageSize) throws BusinessException;

    List<TaskSummaryBean> findTaskSummaryBeanByReference(Long reference, Long subReference) throws BusinessException;


    /**
     * @desc 获取指定事项下指定附件类型的所有附件
     * @author mssql
     * @date 2019/10/8
     * @param taskIds 事项id集合
     * @param fileTypes 附件类型集合
     * @return
     */
    List<Map<String,Object>> getEnclosureListByTaskIdsAndFileTypes(List<Long> taskIds,String [] fileTypes) throws BusinessException;

    /**
     * @desc 汇总附件
     * @date 2019/10/9
     */
    Map<String,Object> collectAnnex(List<Long> annexIds) throws BusinessException;

    /**
     * 分页获取指定部门督办事项列表
     * @param taskTypeId 任务类型ID
     * @param isKeyProject 是否查询类型为重大项目的任务类型
     * @return
     * @throws BusinessException
     */
    ListObject<TaskSummaryBean> pagedTaskSummarysByTaskTypeIdAndPids(long taskTypeId,boolean isKeyProject,String type,Long [] pids,int start,int range) throws BusinessException;
    /**
     * 获取指定人员督办事项数量
     * @param pids 人员ID集合
     * @param type finish:已完成 overdue:已超期 leaderAssigned:领导批示 leaderFollow:领导关注 传入null查全部
     * @param isKeyProject 是否查询任务类型为重大项目
     * @return
     * @throws BusinessException
     */
    ListObject<TaskSummaryBean> getTaskCountByPersonIds(Long [] pids,String type,boolean isKeyProject,int start, int range) throws BusinessException;

    /**
     * 获取指定人员督办事项数量
     * @param pids 人员ID集合
     * @param type finish:已完成 overdue:已超期 leaderAssigned:领导批示 leaderFollow:领导关注 传入null查全部
     * @param isKeyProject 是否查询任务类型为重大项目
     * @return
     * @throws BusinessException
     */
    int getTaskCountByPersonIds(Long [] pids,String type,boolean isKeyProject) throws BusinessException;
    /**
     *
     * @param summaryBeans
     * @throws BusinessException
     * @describe 把summary的集合的第一个作为其他的父任务
     */
    void firstAsParentInSummaries(List<TaskSummaryBean> summaryBeans) throws BusinessException;

    /**
     *
     * @param parentTaskId
     * @param childTaskId
     * @throws BusinessException
     * @describe 保存事项父子关系
     */
    void saveTaskFatherSonRel(Long parentTaskId,Long childTaskId)throws BusinessException;

    String findOrgNameByTaskMembrId(Long memberId)throws BusinessException;

    /**
     * 生成任务，公共接口，任何转督办都可以使用
     * @param info
     * @param fileId
     * @param cid
     * @param pid
     */
    void addDraftData(Map<String, Object> info, Long fileId, Long cid, Long pid,Integer num)throws BusinessException;

    /**
     * 湖北目标通知锁定操作
     * @param id
     * @throws BusinessException
     */
    Map<String, Object> editTaskTargetStatus(Long id, Integer status) throws BusinessException;

    /**
     * 处理督办首页统计效率问题独有
     * @param summaryBeans
     * @param expireCounts
     * @param overdueCounts
     * @param unSign
     * @param ycq
     * @param taskIds
     * @param jjcq
     * @param unReport
     * @throws BusinessException
     */
    void  dealSearchForPortal(List<TaskSummaryBean> summaryBeans,List<Integer> expireCounts,List<Integer> overdueCounts,Set<Long>unSign,Set<Long> ycq,Set<Long> taskIds,Set<Long> jjcq,Set<Long> unReport) throws BusinessException;

    TaskTypeRelationBean findTaskTypeRelationBeanByTaskId(Long id)throws BusinessException;

    void updateTaskPhaseInfo(List<TaskPhase> taskPhase, List<Long> subTasks,TaskBO bo,Boolean flag)throws BusinessException;

    Map<String, Object> findTaskmemberInfoByTaskIdAndResourceId(Long id, Long personId)throws BusinessException;

    TaskMemberPhase findTaskMemberPhaseByTaskIdAndMemberIdAndPhaseId(Long taskId, Long memberId, Long id)throws BusinessException;

    TaskMemberPhaseReportConfig findTaskMemberPhaseReportConfigByMemberPhaseIdAndConfigId(Long memberPhaseId,Long id)throws BusinessException;

    /**
     * 查询该任务类型所配页签
     * @param taskType
     * @return
     */
    List<Map<String, Object>> findPlugListByTaskType(Long taskType,Long id,Long pid) throws BusinessException;

    /**
     * 办结操作增加验证机制，判断事项是否都汇报，是否都汇报成已完成，如果没有则给出明确的提示
     * 如：A事项存在单位1，单位2未汇报，且单位3汇报状态未选已完成，B事项存在村咋单位4未汇报，
     * C事项存在...等
     * @param id
     * @return
     * @throws BusinessException
     */
    Map<String,Object> checkTaskIsOver(String id)throws BusinessException;

    //是否已办结
    Map<String,Object> checkTaskIsOverByIds(String ids)throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 获取当前单位能统计，且挂在树上的指定类型
     * @createTime 2021/5/12 16:29
     */
    List<TaskTypeBean> findCanCountTaskTypeBeanByNeedShowTree(Integer subType,Long accountId)throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 批量催办 查询未签收，未汇报，即将超期，已超期的 memberIds
     * @createTime 2021/4/22 13:45
     */
    List<String> findTaskMemberResourceIdsByParams(String flag, Map<String, Object> param)throws BusinessException;

    /**
     * 根据事项ID查询所有汇报ID
     * @param id
     * @return
     * @throws BusinessException
     */
    List<Long> findTaskReportByTaskId(Long id)throws BusinessException;

    List<TaskReportBean> findAllTaskReportByTaskId(Long taskId)throws BusinessException;

    List<TaskSummaryBean> findTaskSummaryByParam(Map<String, Object> param)throws BusinessException;

    /**
     * 查询这些任务涉及到的牵头单位和责任单位，主要用于会议模式主子任务成员同步
     * 返回结果Map<String,Object>:key:managerIds:所有子任务牵头单位集合 managerNames:牵头单位姓名
     * 返回结果Map<String,Object>:key:participantIds:所有子任务责任单位集合 participantNames：责任单位名称
     * @param taskIds
     * @return
     * @throws BusinessException
     */
    Map<String,Object> findTaskMemberList(String taskIds,String remark)throws BusinessException;

    List<TaskTypeBean> findSubFrom(Long from) throws BusinessException;

    List<TaskTypeBean> findSubFromById(Long from) throws BusinessException;

    List<TaskTypeBean> findAllTaskType() throws BusinessException;

    List<TaskTypeBean> findAllTaskTypeByAccountId(@NonNull Long orgAccountId) throws BusinessException;

    List<BehSummaryBean> findByBehTypeAndTaskid(String resId, Integer resType, String ext1) throws BusinessException;

    /**
     * 根据类型查询（目标绩效使用）
     * @param key
     * @return
     * @throws BusinessException
     * @deprecated 使用 {@link #findTaskTypeBeansBySubType(Integer,Long)}
     */
    @Deprecated
    List<Map<String, Object>> findTaskTypeBeanBySubType(int key) throws BusinessException;
    List<Map<String, Object>> findTaskTypeBeanBySubTypeAndEqParentId(int key,TaskTypeBean typebean,Long taskTypeId) throws BusinessException;

    /**
     * 初始化类型树,其实是用的 findTaskTypeBeanBySubTypeAndEqParentId（）方法，本方法只做了更方便的查询封装
     * @param params   taskType -> 要查找的类型id  remark -> 要查找的类型备注（起到的作用大概是模糊查询）
     *                 参数二传一即可，一个不传就报错
     *                 subType -> {@link TaskEnum.TaskTypeSub}
     * @return  适配前端ztree组件的数据结果集
     * @throws BusinessException
     */
    List<Map<String, Object>> findTypeTree(Map<String,Object> params) throws BusinessException;

    List<Map<String, Object>> findTaskTypeBeanBySubTypeAndNeparendtId(int key,Long parentId) throws BusinessException;
    List<TaskListTmpColRelBean> findListColumn(Long key) throws BusinessException;

    /**
     * 查询字段名
     * @param tableName 需要查询的表明
     * @param columnId 查询的iD
     * @return
     * @throws BusinessException
     */
    String findMatrixTableByColumnId(String tableName, Long columnId) throws BusinessException;

    /**
     * 查询当前类型下所有子任务
     * @param typeId
     * @return
     * @throws BusinessException
     */
    List<TaskTypeBean> findTaskTypeBeanByParentId(Long typeId) throws BusinessException;
    List<TaskTypeBean> findTaskTypeBeanByParentAndSuType(Long parentId,Integer subType) throws BusinessException;

    /**
     * 根据类型枚举和状态查询
     * @param subType
     * @param status
     * @return
     * @throws BusinessException
     */
    List<TaskTypeBean> findTaskTypeBeanBySubTypeAndStatus(int subType, int status) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param
     * @describe 处理成员汇报预警状态
     * @createTime 2020/9/8 14:27
     */
    void processTaskExpiresData(List<TaskMemberPhaseReportConfig> configs) throws BusinessException;

    /**
     * @author inspired (胡启林)
     * @param summaries
     * @param lampStatus {@link TaskEnum.TaskDynamicLampStatusEnum}
     * @describe 处理动态监控数据， 超期(传 0)和即将超期（传 1）时处理
     * @createTime 2020/9/9 14:27
     */
    void processTaskDynamicMonitoring(List<TaskSummaryBean> summaries, Integer lampStatus);

    List<OrgPersonBean> getReciprocal4Task(Long taskId, Integer taskMemberRelType) throws BusinessException;

    /**
     * 根据父级ID和类型查询
     * @param subType
     * @param parentId
     * @return
     * @throws BusinessException
     */
    TaskTypeBean findTaskTypeBeanBySubTypeAndParentId(int subType, Long parentId) throws BusinessException;

    /**
     * 保存事项模板跟采集表模板的关联关系
     * @param collectionTempId
     * @param taskIds
     * @throws BusinessException
     */
    void saveTaskTempRel(Long collectionTempId,List<Long> taskIds) throws BusinessException;

    /**
     * 通过任务模板id查询关联关系
     * @param taskId
     * @return
     * @throws BusinessException
     */
    TaskRelationship findTaskRelationshipByTaskId(Long taskId) throws BusinessException;

    /**
     * 根据ID查询所有类型数据
     * @param targetTypeId
     * @return
     * @throws BusinessException
     */
    List<TaskTypeBean> findTaskTypebeanByIds(String targetTypeId) throws BusinessException;

    Map<String,Object> batchToDraft(List<Long> taskIds) throws BusinessException;

    /**
     * 通过模板id查询事项
     * @param tempIds 事项的模板的id
     * @return
     * @throws BusinessException
     */
    List<TaskSummaryBean> findTaskSummaryByTempIds(List<Long> tempIds)  throws BusinessException;

    /**
     * 领导首页督察督办 - 我的关注 台账
     * @param pageInfo 分页情况
     * @param map 可扩展参数
     * @return
     * @throws BusinessException
     */
    com.minto.tip.common.util.PageInfo findAllTaskMyAttention(com.minto.tip.common.util.PageInfo pageInfo, Map<String, Object> map) throws BusinessException;


    Boolean addTaskAttr(TaskAttrBean attrBean) throws BusinessException;

    void updateTaskAttr(TaskAttrBean oldBean) throws BusinessException;

    List<TaskAttrBean> findTaskAttr(Long[] taskIds) throws BusinessException;

    TaskAttrBean findTaskAttrByTaskId(Long taskId) throws BusinessException;

    /**
     * 添加评论
     * 2017年12月19日 上午9:45:50
     *
     * addTaskComments
     * @param commentBeans
     * @throws BusinessException
     *void
     * @exception
     * @since  2.0
     */
    void addTaskComments(List<TaskCommentBean> commentBeans) throws BusinessException;

    void addTaskComments(String contentJson, Long pid, Long cid) throws BusinessException;

    /**
     * 查询时间范围内的评价
     * @param dateFrom
     * @param dateTo
     * @return
     * @throws BusinessException
     */
    List<TaskCommentBean> findTaskComments(Date dateFrom, Date dateTo) throws BusinessException;

    /**
     * 查询单位在时间范围内的评价
     * @param deptIds
     * @param DateFrom
     * @param DateTo
     * @return
     * @throws BusinessException
     */
    List<TaskCommentBean> findTaskCommentsByDeptId(Long[] deptIds, Date DateFrom, Date DateTo) throws BusinessException;

    /**
     * 根据任务id和汇报id查询汇报的评价记录
     * @param taskId
     * @param reportId
     * @return
     * @throws BusinessException
     */
    List<TaskCommentBean> findTaskCommentsBeanByTaskIdAndReportId(Long taskId, Long reportId) throws BusinessException;

    /**
     * 领导关注发送消息提醒
     * @param creatorId
     * @param cid
     * @param personId
     * @param taskId
     * @param process
     * @param type
     * @throws BusinessException
     */
    void addTaskAttention(Long creatorId, Long cid, Long personId, Long taskId, String process, String type) throws BusinessException;

    /**
     * 查询任务列表
     * @param redFlag
     * @param doType
     * @param keyword
     * @param keywordShow
     * @param dateFrom
     * @param dateTo
     * @param curentPid
     * @param memberRelTypes
     * @param states
     * @param tCategory
     * @param cid
     * @param pid
     * @param findState
     * @param start
     * @param pageSize
     * @param includeIds
     * @param isContain
     * @return
     * @throws BusinessException
     */
    ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long curentPid, Integer[] memberRelTypes,
                                   Integer[] states, Integer tCategory, Long cid, Long pid, Integer findState, Integer start, Integer pageSize, List<Long> includeIds, boolean isContain) throws BusinessException;


    /**
     * 查询任务列表
     * @param redFlag
     * @param doType
     * @param keyword
     * @param keywordShow
     * @param dateFrom
     * @param dateTo
     * @param curentPid
     * @param memberRelTypes
     * @param states
     * @param tCategory
     * @param cid
     * @param pid
     * @param findState
     * @param start
     * @param pageSize
     * @param includeIds
     * @param isContain
     * @param categoryId
     * @return
     * @throws BusinessException
     */
    ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long curentPid, Integer[] memberRelTypes,
                                   Integer[] states, Integer tCategory, Long cid, Long pid, Integer findState, Integer start, Integer pageSize, List<Long> includeIds, boolean isContain, Integer categoryId) throws BusinessException;

    /**
     * 查询任务列表
     * @param redFlag
     * @param doType
     * @param keyword
     * @param keywordShow
     * @param dateFrom
     * @param dateTo
     * @param personId
     * @param memberRelTypes
     * @param states
     * @param tCategory
     * @param cid
     * @param pid
     * @param findState
     * @param start
     * @param pageSize
     * @param includeIds
     * @param isContain
     * @param categoryId
     * @param typeId 任务类型：任务类别表
     * @param fromId 任务来源：任务类别表
     * @return
     * @throws BusinessException
     */
    ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long personId, Integer[] memberRelTypes, Integer[] states, Integer tCategory, Long cid, Long pid, Integer findState, Integer start, Integer pageSize, List<Long> includeIds, boolean isContain, Integer categoryId, Long typeId, Long fromId) throws BusinessException;

    ListObject<TaskBO> findTaskBos(Integer redFlag, String doType, String keyword, String keywordShow, String dateFrom, String dateTo, Long personId, Integer[] memberRelTypes, Integer[] states, Integer tCategory, Long cid, Long pid, Integer findState, Integer start, Integer pageSize, List<Long> includeIds, boolean isContain, Integer categoryId, Long typeId, Long fromId, String exmineState) throws BusinessException;

    /**
     * 通过taskId,查询出事项的评价列表,map中包括
     * id->事项的id
     * pjr->评价人bean
     * dbrToTaskStr->督办人对单位的评价
     * dbrToDwList->督办人对单位的评价
     * DwToSelfList->单位对自身的评价
     * @param taskId
     * @return
     * @throws BusinessException
     */
    @SuppressWarnings("rawtypes")
    Map findTaskComments(Long taskId, Long curUserId) throws BusinessException;

    /**
     * 查询count Level
     * zhangzy
     * @param id
     * @param i
     * @return
     */
    Long findTaskComments(Long id, int Level) throws BusinessException;

    void addTaskAttention(TaskAttention dzdbAttention)
            throws BusinessException;

    List<TaskAttention> findTaskAttention(Long id)
            throws BusinessException;

    void updateTaskAttention(TaskAttention dzdbAttention)
            throws BusinessException;

    void delTaskAttr(Long taskId) throws BusinessException;

    /**
     * 根据事项id更改状态
     * @param ids
     * @param state
     * @throws BusinessException
     */
    void updateTaskAttrState(Long[] ids, Integer state) throws BusinessException;

    /**
     * 根据事项状态查询指定人作为督办人的“督办事项”信息
     * @param pid 督办人id
     * @param tstate 不包含在内的事项状态，注意：是取的不包含
     * @param jobType 事项类型 参考{@link TaskEnum.JobType}
     * @return
     */
    List<TaskSummaryBean> findTasksByPidAndOuterStatus(Long pid, Integer[] tstate, Integer jobType) throws BusinessException;


    /**
     * 获取事项进度数据
     * @param taskId 事项ID
     * @param ptype 进度类型
     * @param processResourceId 进度资源
     * @return
     * @throws BusinessException
     */
    List<TaskProcessSummaryBean> findTaskProcessBeans(Long taskId, Integer ptype, Long processResourceId) throws BusinessException;

    /**
     * 根据汇报id查找汇报的最新留言
     * @param taskId 事项ID
     * @param processResourceId 汇报id
     * @return
     * @throws BusinessException
     */
    TaskProcessSummaryBean findLatestTaskProcessBean(Long taskId, Long processResourceId) throws BusinessException;

    /**
     * 分页获取事项进度数据
     * @param pageInfo 分页参数
     * @param params 参数
     * @return
     * @throws BusinessException
     */
    com.minto.tip.common.util.PageInfo findTaskProcessBeans(com.minto.tip.common.util.PageInfo pageInfo,Map<String,Object> params) throws BusinessException;

    /**
     * 根据重大项目ID查询是否存在留言数据
     * @param projectId
     * @return
     * @throws BusinessException
     */
    TaskProcessSummaryBean findTaskProcessSummaryByTaskId(Long projectId) throws BusinessException;

    /**
     * 查询该任务节点下的所有子节点
     * @param taskId
     * @return
     */
    List<Map<String, Object>> displayAllSubTasks(Long taskId) throws BusinessException;

    /**
     * 显示关联任务对应的责任单位
     * @param taskId
     * @param relationShip
     * @return
     */
    StringBuffer displayUnit(Long taskId, Integer relationShip) throws BusinessException;

    void restoreTaskQuartzJob() throws BusinessException;

    /**
     * 根据汇报ID查询事项ID,key为汇报ID,value为事项ID
     * @param reportIds
     * @return
     */
    Map<Long, Long> findTaskIdByReportId(List<Long> reportIds) throws BusinessException;

    /**
     * 查询任务下最新的汇报信息
     * @param taskId
     * @param memberId
     * @return
     * @throws BusinessException
     */
    TaskReportBean findTaskReportByTaskIdAndUpdateTime(Long taskId, Long memberId) throws BusinessException;
    /**
     * 根据id和类型状态查询
     * @param ids id
     * @param subType 所属类型
     * @param status 状态
     * @return
     */
    List<TaskTypeBean> findTaskTypebeanByIdsAndSubTypeAndStatus(List<Long> ids, Integer subType, Integer status) throws BusinessException;

    /**
     * 预置绑定基础页签
     * @param taskId
     * @throws BusinessException
     */
    void saveLabels(Long taskId) throws BusinessException;

    /**
     * 任务类别详情或列表字段配置
     * @param taskId
     * @param name
     * @param type
     * @throws BusinessException
     */
    void saveDetailOrListField(Long taskId, String name, String type) throws BusinessException;


    /**
     * 查询任务模板的数据
     *
     * @param pageInfo
     * @param param
     * @return
     */
    com.minto.tip.common.util.PageInfo findTaskSummaryList(com.minto.tip.common.util.PageInfo pageInfo, Map<String, Object> param) throws BusinessException;

    /**
     * 新增消息通知
     * @param map
     * @return
     */
    Map<String, Object> addMessageConfig(Map<String,Object> map);

    /**
     * 删除消息通知
     * @param id
     * @return
     */
    Map<String,Object> delMessageConfig(Long id);

    /**
     * 根据消息提醒设置来发送消息
     * @param param
     */
    Map<String, Object> findSuperviseTasks(Map<String,Object> param) throws BusinessException;

    /**
     * 获取不同状态任务数量
     * @param state
     * @return
     * @throws BusinessException
     */
    Integer findTaskCountByState(Integer state, Long memberId) throws BusinessException;

    void sendMessage(TaskSummaryBean summaryBean, List<TaskMemberBean> memberBeans, int type, Integer notifyType) throws BusinessException;
    void sendMessage(TaskSummaryBean summaryBean, List<TaskMemberBean> memberBeans, int type, Integer notifyType, String message) throws BusinessException;

    /**
     * 根据状态获取任务
     * @param remark
     * @return
     * @throws BusinessException
     */
    List<Map<String, Object>> findTasksByType(String remark) throws BusinessException;

    List<Map<String, Object>> findNotifyMethod(Map<String, Object> name) throws BusinessException;

    /**
     * 组装消息内容
     * @return
     */
    String buildMessageInfo(Map<String, Object> param,String content) throws BusinessException;

    List<Map<String, Object>> findTaskMemberRelType(Map<String, Object> param) throws BusinessException;

    List<Map<String, Object>> findNotifyType(Map<String, Object> param) throws BusinessException;

    Map<String, Object> getTaskMessageConfig(Long taskTypeId, Integer messageType);

    /**
     * 根据类型状态和是否需要审批查询
     * @param subType
     * @param status
     * @param needApproval
     * @return
     */
    List<TaskTypeBean> findTaskTypeBeanBySubTypeAndStatusAndNeedApproval(Integer subType, Integer status, Integer needApproval) throws BusinessException;

    /**
     * 根据项目Id获取所属项目库
     * @param proId
     * @return
     */
    List<TaskTypeBean> findTaskTypeByProjectId(Long proId);

    /**
     * 根据colId获取目标项目库
     * @return
     */
    List<Map<String, Object>> findTaskTypeByColId(Long colId);

    /**
     * 验证事项是不是未交办
     * @param ids 事项ID
     * @return 返回所有为交办ID
     * @throws BusinessException
     */
    List<Long> verificationTaskState(List<Long> ids) throws BusinessException;


    /**
     * 事项交办，事项延期，事项终止，事项删除，事项办结，事项分派
     * create by Wangcs 2019-08-27
     * * 督办事项定时生成汇报待办，签收待办
     */
    Integer saveTaskWaiteDoBeans(List<TaskSummaryBean> tasks,Long pid) throws BusinessException;



    /**
     * 给成员生成汇报阶段的待办
     * @author inspired
     * @param task
     * @param member
     * @return
     * @throws BusinessException
     */
    TipAffair processMemberAffair(TaskSummaryBean task, TaskMemberBean member) throws BusinessException;

    /**
     * 定时任务调用，生成节点待办
     * @author inspired
     * @param
     * @return
     */
    void addMemberAffair(Long taskId,Long taskTypeId,Long reportConfigId,Long memberId,Integer subType,Long pid) throws BusinessException;

    /** 通过taskIds删除待办
     * @throws BusinessException
     */
    void deleteBytaskId(Long[] taskIds) throws BusinessException;

    void packCommonWaiteDos4Goal(Long personId,TaskSummaryBean task,List<TipAffair> commonWaiteDoBeans);

    void deleteAllCommonWaiteDos() throws BusinessException;

    /**
     * 分页查询所有督办任务
     * @param pageInfo 分页信息
     * @param genericParam 用户信息
     * @return 任务信息
     */
    com.minto.tip.common.util.PageInfo<TaskPanelOutput> findAllSuperviseTask4WebPanel(com.minto.tip.common.util.PageInfo pageInfo, GenericParam genericParam);

    /**
     * 查询当前人员所有督办人任务的熟练
     * @param genericParam
     * @return
     */
    int countAllSuperviseTask4WebPanel(GenericParam genericParam);

    /**
     * 分页查询指定组织为承办单位的任务
     * @param pageInfo
     * @param param
     * @return
     */
    com.minto.tip.common.util.PageInfo<TaskPanelOutput> findAllManagerTask4WebPanel(com.minto.tip.common.util.PageInfo pageInfo, GenericParam param);

    /**
     * 查询指定组织为承办单位的任务数量
     * @param param
     * @return
     */
    int countAllManagerTask4WebPanel(GenericParam param);

    /**
     * 查询当前承办人是否有分派回报
     * @param managerId memberId
     * @param deputeFlag 是否是委托分派 1 否(为空则查询委托分派，1 非委托分派)
     * @return
     */
    List<TaskMemberBean> findTaskMemberByParentIdAndDeputeFlag(Long managerId, Integer deputeFlag);

    /**
     * 根据任务ID查询当前任务下有没有正在进行的延期、办结、中止申请
     * @param taskId 任务ID
     * @return
     */
    Map<String,Object> checkingTaskEmail(List<Long> taskId);

    void saveTaskProcessSummaryBeanList(List<TaskProcessSummaryBean> taskProcessSummaryBeans);

    /**
     * 保存或者更新批示、留言的暂存
     *
     * @param tempBean
     * @return
     */
    Long saveOrUpdateTaskProcessTemp(TaskProcessSummaryTempBean tempBean);

    /**
     * 查询暂存的批示、留言信息
     *
     * @param taskId
     * @param personId
     * @return
     */
    TaskProcessSummaryTempBean findTaskProcessTempByTaskAndPerson(Long taskId, Long personId);

    /**
     * 移除暂存的批示、留言信息
     *
     * @param taskId
     * @param personId
     * @return
     */
    void deleteTaskProcessTempByTaskAndPerson(Long taskId, Long personId);

    /**
     * 撤回批示留言
     * @param itemId
     * @param pid
     */
    void deleteTaskProcess(Long itemId,Long pid) throws Exception;

    /**
     * 传阅任务
     * @param taskId
     * @param resourceIds
     */
    void updateTask4Circulate(Long taskId, String[] resourceIds);

    /**
     * 根据id查找任务动态
     * @param processId
     */
    Map<String,Object> findTaskProcessVisibilityInfo(Long processId);

    /**
     * 根据id更新任务动态
     *
     * @param processId
     * @param visibilityScope
     * @param resourceKeys
     * @param pid
     */
    void updateTaskProcessVisibility(Long processId, String visibilityScope, String[] resourceKeys, Long pid);

    /**
     * 根据人员id,获取当前人员看的批示数据Id
     *
     * @param taskId
     * @param pid
     * @return
     */
    List<Long> findTaskProcessVisibilityRunTime(Long taskId, Long pid);
}