snd-escloud/src/main/java/platform/modules/company/service/ProjectApplicationApproveService.java

package platform.modules.company.service;

import java.text.SimpleDateFormat;
import java.util.*;

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.aliyuncs.exceptions.ClientException;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

import org.springframework.util.CollectionUtils;
import platform.common.Constant;
import platform.common.base.service.BaseService;
import platform.common.base.service.DictionaryItemService;
import platform.common.exception.BaseException;
import platform.common.util.AlibabaSMSUtil;
import platform.common.util.DateUtil;
import platform.common.util.ShiroUtils;
import platform.modules.build.dao.CompanyDao;
import platform.modules.build.entity.Company;
import platform.modules.build.entity.CompanyContact;
import platform.modules.build.service.CompanyService;
import platform.modules.company.dao.ProjectApplicationDao;
import platform.modules.company.dto.ProjectApplicationSearchCondition;
import platform.modules.company.dto.ProjectApprovalDto;
import platform.modules.company.dto.StockLandApprovalDto;
import platform.modules.company.entity.ProjectApplication;
import platform.modules.company.entity.StockLand;
import platform.modules.government.dao.ProjectDao;
import platform.modules.government.dto.ApplicationDto;
import platform.modules.government.dto.ParamApplication;
import platform.modules.government.entity.*;
import platform.modules.government.service.ProjectDeclarationService;
import platform.modules.government.service.ProjectTypeService;
import platform.modules.government.service.UserService;
import platform.modules.sys.dao.ApprovalDao;
import platform.modules.sys.entity.Approval;
import platform.modules.sys.entity.Group;
import platform.modules.sys.entity.Message;
import platform.modules.sys.entity.UserGroup;
import platform.modules.sys.service.*;
import tk.mybatis.mapper.entity.Example;

@Service
@Transactional
public class ProjectApplicationApproveService extends BaseService<ProjectApplication> {

    @Autowired
    private ProjectApplicationDao projectApplicationDao;

    @Autowired
    private ProjectApplicationService projectApplicationService;

    @Autowired
    private ApprovalService approvalService;

    @Autowired
    private GroupService groupService;

    @Autowired
    private UserGroupService userGroupService;

    @Autowired
    private ProjectDeclarationService projectDeclarationService;

    @Autowired
    private CompanyService companyService;

    @Autowired
    private MessageService messageService;

    @Autowired
    private UserService userService;

    @Autowired
    private WaitToDoService waitToDoService;

    @Autowired
    private ProjectDao projectDao;

    @Autowired
    private ProjectTypeService projectTypeService;

    @Autowired
    private ApprovalDao approvalDao;

    @Autowired
    private DictionaryItemService dictionaryItemService;

    @Autowired
    private CompanyDao companyDao;

    //根据用户组获取可查询到的项目
    public List<String> getProjectIdsByGroup() {

        List<ProjectApplication> projectLists = new ArrayList<>();

        Integer user_id = ShiroUtils.getUserId();
        Integer department_id = ShiroUtils.getUserEntity().getDepartment_id();

        Example example = new Example(Project.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("del_flag", "0");
        criteria.andEqualTo("department_id", department_id);
        List<Project> projectList = projectDao.selectByExample(example);
        List<String> project_ids = new ArrayList<>();
        if (!CollectionUtils.isEmpty(projectList)) {
            for (Project project : projectList) {
                project_ids.add(project.getId().toString());
            }
        }

        Group group = null;
        List<UserGroup> userGroups = null;
        List<String> apply_status_list = new ArrayList<>();
        List<String> company_ids = new ArrayList<>();
        if (ShiroUtils.getUserType() == Constant.UserType.STREET) {

            Example example2 = new Example(Company.class);
            Example.Criteria criteria2 = example2.createCriteria();
            criteria2.andEqualTo("del_flag", "0");
            criteria2.andEqualTo("street_id", ShiroUtils.getStreetId());
            List<Company> companies = companyDao.selectByExample(example2);
            if (!CollectionUtils.isEmpty(companies)) {
                for (Company company : companies) {
                    company_ids.add(company.getId().toString());
                }
            } else {
                company_ids.add("");
            }

            group = groupService.findByName(Constant.XMSBJDSLZ, null);
            if (null == group) {
                apply_status_list.add("");
            }
            userGroups = userGroupService.findByGroupId(group.getId());
            if (null == userGroups) {
                apply_status_list.add("");
            }
            for (UserGroup userGroup : userGroups) {
                if (Objects.equals(userGroup.getUser_id(), user_id)) {
                    apply_status_list.add(Constant.ProjectProvincesStatus.LOCAL_AUDIT);
                    break;
                }
            }
        }
        if (apply_status_list.size() <= 0) {
            apply_status_list.add("");
        }
        projectLists.addAll(projectApplicationDao.findByProjectIdAndApproveStatus(project_ids, apply_status_list, company_ids));

        List<String> result = new ArrayList<>();
        for (ProjectApplication project : projectLists) {
            result.add(project.getId().toString());
        }
        return result;
    }

    //获取项目申报id 已审批
    public List<String> getProjectIdsy() {

        int currentUserId = ShiroUtils.getUserId();

        List<Approval> approvalList = approvalDao.selectAllApproval(Constant.DictionaryType.PROJECT_APPLICATION);
        Set<String> projectApplicationIds = new HashSet<String>();
        //if (Objects.equals(ShiroUtils.getUserType(), Constant.UserType.GOVERNMENT)) {
        if (!CollectionUtils.isEmpty(approvalList)) {
            for (Approval approval : approvalList) {
                String checkerIds = approval.getChecker() + "";
                if (checkerIds != null && checkerIds != "") {
                    if (Objects.equals(checkerIds, String.valueOf(currentUserId))) {
                        projectApplicationIds.add(approval.getApply_id().toString());
                    }
                }
            }
        }
        //}
        List<String> result = new ArrayList<>(projectApplicationIds);
        return result;
    }

    //获取项目申报id 查看所有
    public List<String> getProjectIdsc() {

        List<String> company_ids = new ArrayList<>();
        if (ShiroUtils.getUserType().equals(Constant.UserType.STREET)) {
            Example example1 = new Example(Company.class);
            Example.Criteria criteria1 = example1.createCriteria();
            criteria1.andEqualTo("street_id", ShiroUtils.getStreetId());
            List<Company> companyList = companyDao.selectByExample(example1);
            for (Company company : companyList) {
                company_ids.add(company.getId() + "");
            }
        }

        List<String> result = new ArrayList<>();
        Example example = new Example(ProjectApplication.class);
        Example.Criteria criteria = example.createCriteria();
        List<String> approve_status = new ArrayList<>();
        criteria.orEqualTo("del_flag", "0");//不显示删除的
        approve_status.add(Constant.ProjectApplicationStatus.NOTIFY);//待通知
        approve_status.add(Constant.ProjectApplicationStatus.LOCAL_AUDIT);//属地初审
        approve_status.add(Constant.ProjectApplicationStatus.CENTRE_AUDIT);//材料审核
        approve_status.add(Constant.ProjectApplicationStatus.DEPARTMENT_AUDIT);//处室（中心）审批
        approve_status.add(Constant.ProjectApplicationStatus.FINANCE_AUDIT);//财政审批
        approve_status.add(Constant.ProjectApplicationStatus.UPLOAD_REPORT);//待上传报告
        approve_status.add(Constant.ProjectApplicationStatus.APPROVED);//通过
        approve_status.add(Constant.ProjectApplicationStatus.REJECT_TO_COMPANY);//退回至企业
        approve_status.add(Constant.ProjectApplicationStatus.REJECT_TO_DEPARTMENT);//退回至处室
        approve_status.add(Constant.ProjectApplicationStatus.NOTAPPROVED);//不通过
        approve_status.add(Constant.ProjectApplicationStatus.UPLOAD_CS);//待财政上传
        approve_status.add(Constant.ProjectApplicationStatus.UPLOAD_CZ);//待处室上传
        approve_status.add(Constant.ProjectApplicationStatus.COMMIT_FILE);//待中心窗口上传
        criteria.andIn("approve_status", approve_status);//待中心窗口上传

        if (ShiroUtils.getUserType().equals(Constant.UserType.STREET)) {
            criteria.andIn("company_id", company_ids);
        }
        List<ProjectApplication> projectList = projectApplicationDao.selectByExample(example);
        for (ProjectApplication project : projectList) {
            result.add(project.getId().toString());
        }
        return result;
    }

    public PageInfo<ApplicationDto> findPage(Integer pageNum, Integer pageSize, ParamApplication paramApplication, String type) {

        paramApplication.setApproval_type(Constant.DictionaryType.PROJECT_APPLICATION);
        if (Objects.equals("1", type)) {
            //paramApplication.setProjectIds(getProjectIdsd()); //原逻辑
            paramApplication.setProjectIds(getProjectIdsByGroup());//新逻辑
        } else if (Objects.equals("0", type)) {
            paramApplication.setProjectIds(getProjectIdsy());
        } else if (Objects.equals("2", type)) {
            if (ShiroUtils.getUserType().equals(Constant.UserType.STREET)) {
                paramApplication.setStreet_id(ShiroUtils.getStreetId() + "");
            }
            paramApplication.setProjectIds(getProjectIdsc());
        }

        String year = paramApplication.getProject_year();
        if (year != null && !year.equals("")) {
            paramApplication.setProject_year_date(year + "-01-01 00:00:00");
        }

        PageHelper.startPage(pageNum, pageSize);
        List<ApplicationDto> applicationDtoList = projectApplicationDao.findPage(paramApplication);

        for (ApplicationDto app : applicationDtoList) {
            if (null != app.getProject_type()) {
                ProjectType projectType = projectTypeService.findById(Integer.parseInt(app.getProject_type()));
                //String type_name = dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.PROJECT_APPLICATION_TYPE, app.getProject_type());
                app.setProject_type(projectType.getType_name());
            }
            if (null != app.getApprove_status()) {
                String status_name = dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.PROJECT_APPROVE_STATUS, app.getApprove_status());
                app.setStatedesc(status_name);
            }
        }

        return new PageInfo<ApplicationDto>(applicationDtoList);
    }

    public PageInfo<ProjectApplication> findPage_backup(Integer pageNum, Integer pageSize, String keyword,
                                                        ProjectApplicationSearchCondition searchCondition) {
        if (ShiroUtils.getUserType().equals(Constant.UserType.STREET)) {
            Integer street_id = ShiroUtils.getStreetId();
            searchCondition.setStreet_id(street_id);
            if (searchCondition.getIsPendingAudit().equals(Constant.PendingAuditStatus.PENDING_AUDIT)) {
                //待属地审核
                searchCondition.setApprove_status(Constant.ProjectApplicationStatus.LOCAL_AUDIT);
                searchCondition.setPendingAuditStatus(Constant.ProjectApplicationStatus.LOCAL_AUDIT);
            } else if (searchCondition.getIsPendingAudit().equals(Constant.PendingAuditStatus.NOT_PENDING_AUDIT)) {
                //属地审核过的
                searchCondition.setPendingAuditStatus(Constant.ProjectApplicationStatus.LOCAL_AUDIT);
                /*String streetName = ShiroUtils.getUserEntity().getStreet_name();
                if (null != streetName) {
                    searchCondition.setAuditDept(streetName);
                }*/
                //街道人员只能看到自己审核过的数据
                searchCondition.setChecker_id(ShiroUtils.getUserId());

            } else if (searchCondition.getIsPendingAudit().equals(Constant.PendingAuditStatus.PENDING_ALL)) {
                //属地所有待审核已审核


            }
        }
        PageHelper.startPage(pageNum, pageSize);
        List<ProjectApplication> list = projectApplicationDao.findApproveList(searchCondition);
        for (ProjectApplication projectApply : list) {
            projectApply = projectApplicationService.getFullApplicationInfo(projectApply);
        }

        return new PageInfo<ProjectApplication>(list);
    }

    public void approve(ProjectApprovalDto approval) {
        if (null != approval.getApply_id()) {
            approval.setApproval_department(ShiroUtils.getUserEntity().getStreet_name());
            ProjectApplication apply = projectApplicationService.findById(approval.getApply_id());
            if (null != apply) {
                //短信所需参数
                Map<String, String> params = new HashMap<>();
                User companyAdmin = userService.findCompanyAdmin(apply.getCompany_id(), approval.getApply_id(), Constant.DictionaryType.PROJECT_APPLICATION);
                params.put("project_no", apply.getApply_no());
                params.put("apply_name", Constant.ProjectType.PROJECT_APPLICATION);

                if (approval.getStatus().equals(Constant.ApproveButtonStatus.APPROVED)) {
                    //通过
                    apply.setApprove_status(Constant.ProjectApplicationStatus.CENTRE_AUDIT);

                    //找出下一审核人
                    String nextChecker = get_XMSBCLSLZ_Checkers();
                    if (StringUtils.isBlank(nextChecker)) {
                        throw new BaseException("项目申报材料受理组没有配置人员，请联系管理员配置!");
                    }
                    insertApproval(apply, Constant.OperType.APPROVED, nextChecker, approval);

                } else if (approval.getStatus().equals(Constant.ApproveButtonStatus.NOTAPPROVED)) {
                    //不通过
                    apply.setApprove_status(Constant.ProjectApplicationStatus.NOTAPPROVED);
                    apply.setApply_status(Constant.ProjectApplyStatus.NOTAPPROVED);
                    String nextChecker = String.valueOf(apply.getCreate_by());
                    insertApproval(apply, Constant.OperType.REJECT, nextChecker, approval);
                    //通知企业，短信。
                    try {
                        String tempCode = Constant.SMS_TemplateCode.RPOJECT_MATTERS_UNPASS;
                        AlibabaSMSUtil.sendSMS(
                                companyAdmin.getPhone(), tempCode, Constant.SINGNAMW, JSONObject.toJSONString(params));
//                        projectDeclarationService.sendProjectSMSToCompany(ShiroUtils.getUserEntity().getStreet_name(), apply, Constant.OperType.NOTAPPROVED);
                    } catch (ClientException | InterruptedException e) {
//                        throw new BaseException("短信接口异常！发送短信失败!");
                    }

                } else if (approval.getStatus().equals(Constant.ApproveButtonStatus.REJECT)) {
                    //退回修改
                    apply.setApprove_status(Constant.ProjectApplicationStatus.REJECT_TO_COMPANY);
                    apply.setApply_status(Constant.ProjectApplyStatus.REJECT);
                    String nextChecker = String.valueOf(apply.getCreate_by());
                    insertApproval(apply, Constant.OperType.REJECT, nextChecker, approval);
                    //通知企业，短信。
                    try {

                        String tempCode = Constant.SMS_TemplateCode.RPOJECT_MATTERS_REJECT;
                        AlibabaSMSUtil.sendSMS(
                                companyAdmin.getPhone(), tempCode, Constant.SINGNAMW, JSONObject.toJSONString(params));
//                        projectDeclarationService.sendProjectSMSToCompany(ShiroUtils.getUserEntity().getStreet_name(), apply, Constant.OperType.REJECT);
                    } catch (ClientException | InterruptedException e) {
//                        throw new BaseException("短信接口异常！发送短信失败!");
                    }

                }
                saveMessage(apply, approval.getStatus());
                projectApplicationService.updateSelective(apply);
            }
        }
    }

    public void saveMessage(ProjectApplication apply, String status) {

        ProjectDeclaration projectDeclaration = projectDeclarationService.findById(apply.getDeclaration_id());
        String projectName = projectDeclaration.getProject_name();
        String message = "";
        Company company = companyService.findById(apply.getCompany_id());

        Message messages = new Message();
        messages.setApply_id(apply.getId());
        messages.setBusiness_type(Constant.Message_Business_type.PROJECT_APPLY);
        if (Constant.ApproveButtonStatus.APPROVED.equals(status)) {
            messages.setTitle("提醒中心审核");

            Group group = groupService.findByNameOnly(Constant.XMSBCLSLZ);
            if (null == group) {
                throw new BaseException("操作失败，项目申报财政审核组没有该项目责任单位的审核人员，请联系管理员配置");
            }
            List<UserGroup> userGroups = userGroupService.findByGroupId(group.getId());
            StringBuffer sb = new StringBuffer("");
            for (UserGroup userGroup : userGroups) {
                User user = userService.findById(userGroup.getUser_id());
                message = user.getUser_name() + "，您好。“" + company.getCompany_name() + "企业”的“" + projectName + "项目”申请需要您审核。谢谢。";
                messages.setContent(message);
                int[] streetArrInt = new int[1];
                streetArrInt[0] = userGroup.getUser_id();
                messageService.saveMessageAndPush(messages, streetArrInt, Constant.UserType.GOVERNMENT);

                waitToDoService.completeAllTODO(apply.getId(), Constant.DictionaryType.PROJECT_APPLICATION);
                waitToDoService.newTODO("项目申报审核", "/projectDeclaration/approve/" + apply.getId(), Constant.WaitToDo_OperType.AUDIT, apply.getId(),
                        Constant.DictionaryType.PROJECT_APPLICATION, apply.getApply_no(), userGroup.getUser_id().toString(), Constant.WaitToDo_IsSerial.IS_SERIAL, false);
            }

        } else if (Constant.ApproveButtonStatus.NOTAPPROVED.equals(status)) {
            messages.setTitle("提醒企业");
            message = company.getCompany_name() + "，您好。您提交的" + projectName + "项目申报，审核不通过，请知悉。";
            messages.setContent(message);
            int[] streetArrInt = new int[1];
            streetArrInt[0] = apply.getCompany_id();
            messageService.saveMessageAndPush(messages, streetArrInt, Constant.UserType.COMPANY);

           /* List<User> users = userService.findUsersByCompanyId(apply.getCompany_id());
            for (User user : users) {
                waitToDoService.newTODO("项目申报审核不通过", "/projectApplication/check/" + apply.getId(), Constant.WaitToDo_OperType.CONFIRM_AND_NOTIFY, apply.getId(),
                        Constant.DictionaryType.PROJECT_APPLICATION, apply.getApply_no(), user.getId().toString(), Constant.WaitToDo_IsSerial.IS_SERIAL, false);
            }*/
        }
        if (Constant.ApproveButtonStatus.REJECT.equals(status)) {
            messages.setTitle("提醒企业");
            message = company.getCompany_name() + "，您好。您提交的" + projectName + "项目申报，请修改后重新提交，谢谢。";
            messages.setContent(message);
            int[] streetArrInt = new int[1];
            streetArrInt[0] = apply.getCompany_id();
            messageService.saveMessageAndPush(messages, streetArrInt, Constant.UserType.COMPANY);

            List<User> users = userService.findUsersByCompanyId(apply.getCompany_id());
            waitToDoService.completeAllTODO(apply.getId(), Constant.DictionaryType.PROJECT_APPLICATION);
            for (User user : users) {
                waitToDoService.newTODO("项目申报编辑", "/projectApprove/approve/" + apply.getId(), Constant.WaitToDo_OperType.EDIT, apply.getId(),
                        Constant.DictionaryType.PROJECT_APPLICATION, apply.getApply_no(), user.getId().toString(), Constant.WaitToDo_IsSerial.IS_SERIAL, false);
            }
        }
    }

    private String get_XMSBCLSLZ_Checkers() {
        //根据工作组名称查出工作组
        Group group = groupService.findByNameAndUserType(Constant.XMSBCLSLZ, null, Constant.UserType.GOVERNMENT, null);
        //如果不为空
        if (null != group) {
            //根据工作组id查出UserGroup
            List<UserGroup> list = userGroupService.findByGroupId(group.getId());
            if (null == list || list.size() == 0) {
                throw new BaseException("项目申报材料受理组暂无审核人员，请联系政府管理员配置!");
            }
            //构建一个StringBuffer 存放下一审核人id
            StringBuffer sb = new StringBuffer("");
            for (UserGroup userGroup : list) {
                Integer userId = userGroup.getUser_id();
                sb.append(userId + ",");
            }
            return sb.toString();
        }
        return null;
    }

    //插审核工作流表
    public void insertApproval(ProjectApplication apply, String oper_type, String nextChecker, ProjectApprovalDto approval) {
        Approval latestApproval = approvalService.getLatestApproval(apply.getId(), Constant.DictionaryType.PROJECT_APPLICATION);
        //设置审核完成时间
        latestApproval.setDeal_time(DateUtil.getTimeString(new Date()));
        approvalService.updateSelective(latestApproval);
        //添加新审核流
        Approval approvalInfo = new Approval();
        approvalInfo.setApply_id(apply.getId());
        approvalInfo.setBefore_approvalstatus(latestApproval.getAfter_approvalstatus());
        approvalInfo.setAfter_approvalstatus(apply.getApprove_status());
        approvalInfo.setApproval_round(latestApproval.getApproval_round());
        approvalInfo.setChecker(ShiroUtils.getUserId());
        approvalInfo.setNextchecker(nextChecker);
        approvalInfo.setType(Constant.DictionaryType.PROJECT_APPLICATION);
        approvalInfo.setOper_type(oper_type);
        approvalInfo.setDepartment(approval.getApproval_department());
        approvalInfo.setApproval_comment(approval.getApproval_comment());
        approvalService.insertAndGetId(approvalInfo);
    }

    //是否当前审核人
    public Boolean isCurrChecker(Integer apply_id, ProjectApprovalDto approval) {
        Boolean isNextChecker = false;
        Approval latestApproval = approvalService.getLatestApproval(apply_id, Constant.DictionaryType.PROJECT_APPLICATION);
        User currUser = ShiroUtils.getUserEntity();
        Integer currUserId = currUser.getId();
        if (null != latestApproval.getNextchecker()) {
            String[] userIds = latestApproval.getNextchecker().split(",");
            if (userIds.length > 0) {
                for (String userId : userIds) {
                    if (userId.equals(String.valueOf(currUserId))) {
                        isNextChecker = true;
                    }
                }
                //跳过是否下级审核人限制
                isNextChecker = true;
                if (isNextChecker) {
                    //当前节点是否已经审核过（两个用户同时审核）
                    if (
                            null != approval.getBefore_approveStatus()
                                    && null != latestApproval.getBefore_approvalstatus()
                                    && approval.getBefore_approveStatus().equals(latestApproval.getBefore_approvalstatus())
                    ) {
                        //已经审核过
                        isNextChecker = false;
                    }
                }
            }
            //不检验了
            return true;
        } else {
            //存在老数据没有下一级审核人
            isNextChecker = true;
        }
        return isNextChecker;
    }

}