日志修改

liusheng

2025-09-15 34a716e48e49743083953113bfc2e8011d52444f

 ruoyi-quartz/src/main/java/com/ruoyi/quartz/task/RyTask.java

@@ -1,28 +1,766 @@
package com.ruoyi.quartz.task;

import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.bean.DtoConversionUtils;
import com.ruoyi.project.domain.*;
import com.ruoyi.project.domain.vo.DingTalkReqVo;
import com.ruoyi.project.service.*;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.service.ISysUserService;
import com.taobao.api.ApiException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 定时任务调度测试
 * 
 *
 * @author ruoyi
 */
@Component("ryTask")
public class RyTask
{
    public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i)
    {
        System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}", s, b, l, d, i));
@Slf4j
public class RyTask {
    @Autowired
    private DingTalkService dingTalkService;

    @Autowired
    private IServiceReimbursementService serviceReimbursementService;

    @Autowired
    private IServiceTasknumService ServiceTasknumService;

    @Autowired
    private IServiceReimbursementSharedService serviceReimbursementSharedService;

    @Autowired
    private IServiceFundSharedService serviceFundSharedService;

    @Autowired
    private IServiceFundflowruleService iServiceFundflowruleService;

    @Autowired
    private IServiceFundService serviceFundService;

    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private IServiceSystemmessageService iServiceSystemmessageService;


    @Autowired
    private IServiceFundflowService fundflowService;

    public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i) {
        System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}" , s, b, l, d, i));
    }

    public void ryParams(String params)
    {
    public void ryParams(String params) {
        System.out.println("执行有参方法：" + params);
    }

    public void ryNoParams()
    {
    public void ryNoParams() {
        System.out.println("执行无参方法");
    }

    public void checkReportInfo() throws ApiException {
        //查出所有被医院退回的Fund数据
        List<ServiceFundShared> serviceFundShareds = serviceFundSharedService.queryFundShareList();
        for (ServiceFundShared serviceFundShared : serviceFundShareds) {
            if (StringUtils.isNotBlank(serviceFundShared.getOabdzt()) && serviceFundShared.getOabdzt().equals("已撤销")) {
                //如果有财务驳回信息说明是退回的
                String[] split = null;
                if (StringUtils.isNotEmpty(serviceFundShared.getCxrjyj())) {
                    split = serviceFundShared.getCxrjyj().split("&");
                }
                String phone = serviceFundShared.getPhone();
                //将分享里的该数据删除
                log.info("checkReportInfo中入参ID为：{}" , serviceFundShared.getId());
                Boolean aBoolean = serviceFundSharedService.delfundsharedInfoById(serviceFundShared.getId(), null);
                log.info("fund分享表里的数据是否删除成功：{}" , aBoolean);
                ServiceFund serviceFund = new ServiceFund();
                serviceFund.setId(serviceFundShared.getSerfunid());
                List<ServiceFund> serviceFunds = serviceFundService.queryInfoById(serviceFund);
                ServiceFund serviceFund1 = serviceFunds.get(0);
                serviceFund1.setFlowlevel(100L);
                serviceFund1.setDel_flag(0);
                serviceFund1.setRecordstatus(-1);
                serviceFund1.setBackflowlevel(199);
                serviceFundService.updateById(serviceFund1);

                SysUser sysUser = sysUserService.selectUserByUserName(serviceFund1.getUserno());
//                sendMeg(split, sysUser.getPhonenumber(), serviceFundShared.getApplytype(), 2, serviceFundShared.getSerfunid());
                //发送信息保存
                ServiceSystemmessage serviceSystemmessage = new ServiceSystemmessage();
                serviceSystemmessage.setFundtype(1);
                serviceSystemmessage.setSenduserno(sysUser.getUserName());
                serviceSystemmessage.setSendusername(sysUser.getNickName());
                serviceSystemmessage.setReceiveuserno(serviceFund.getUserno());
                serviceSystemmessage.setReceiveusername(serviceFund.getUsername());
                serviceSystemmessage.setUpdateTime(new Date());
                serviceSystemmessage.setUpdateBy(sysUser.getNickName());
                serviceSystemmessage.setIsread(0);
                serviceSystemmessage.setMessagetype(1);
                serviceSystemmessage.setMessagetitle("财务系统驳回信息");
                serviceSystemmessage.setMessagecontent(serviceFundShared.getCxrjyj());
                iServiceSystemmessageService.save(serviceSystemmessage);
            } else {
                //不是退回的操作
                if (StringUtils.isNotBlank(serviceFundShared.getZffs()) && serviceFundShared.getSpjg() == 0) {
                    String bh = myMethod();
                    //钱已经到帐,并且审批结果为0，说明审批结束，但数据还没有同步到fund表和fundflow表;对fund表和fundflow表进行更新，并将0改成1
                    ServiceFund serviceFund = new ServiceFund();
                    serviceFund.setBh(serviceFundShared.getBh());
                    serviceFund.setId(serviceFundShared.getSerfunid());
                    serviceFund.setZffs(serviceFundShared.getZffs());
                    if (StringUtils.isNotBlank(serviceFundShared.getPresident())) {
                        serviceFund.setPresident(serviceFundShared.getPresident());
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getFinvicepresident())) {
                        serviceFund.setFinvicepresident(serviceFundShared.getFinvicepresident());
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getBusvicepresident())) {
                        serviceFund.setBusvicepresident(serviceFundShared.getBusvicepresident());
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getOfficedirector())) {
                        serviceFund.setOfficedirector(serviceFundShared.getOfficedirector());
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getFinancedirector())) {
                        serviceFund.setFinancedirector(serviceFundShared.getFinancedirector());
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getFinancechecher())) {
                        serviceFund.setFinancechecher(serviceFundShared.getFinancechecher());
                    }
                    serviceFund.setRiqi(serviceFundShared.getRiqi());
                    boolean b = serviceFundService.updateById(serviceFund);
                    log.info("更新serviceFund里的zffs表是否成功: {}" , b);
                    ServiceFundflow serviceFundflow = new ServiceFundflow();
                    serviceFundflow.setCreateBy("admin");
                    serviceFundflow.setCreateTime(new Date());
                    serviceFundflow.setUpdateBy("admin");
                    serviceFundflow.setUpdateTime(new Date());
                    //用三个审批人，如果都为空，就为空
                    String spname = "";
                    if (StringUtils.isNotBlank(serviceFundShared.getPresident())) {
                        serviceFundflow.setCheckusername(serviceFundShared.getPresident().substring(0, serviceFundShared.getPresident().indexOf(" ")));
                        //更新校验时间
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date parse = new Date();
                        try {
                            parse = simpleDateFormat.parse(serviceFundShared.getPresident().substring(serviceFundShared.getPresident().indexOf(" ") + 1, serviceFundShared.getPresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        serviceFundflow.setCheckTime(parse);
                        spname = spname + serviceFundShared.getPresident() + "  ";
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getFinvicepresident())) {
                        serviceFundflow.setCheckusername(serviceFundShared.getFinvicepresident().substring(0, serviceFundShared.getFinvicepresident().indexOf(" ")));
                        //更新校验时间
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date parse = new Date();
                        try {
                            parse = simpleDateFormat.parse(serviceFundShared.getFinvicepresident().substring(serviceFundShared.getFinvicepresident().indexOf(" ") + 1, serviceFundShared.getFinvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        serviceFundflow.setCheckTime(parse);
                        spname = spname + serviceFundShared.getFinvicepresident() + "  ";
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getBusvicepresident())) {
                        serviceFundflow.setCheckusername(serviceFundShared.getBusvicepresident().substring(0, serviceFundShared.getBusvicepresident().indexOf(" ")));
                        //更新校验时间
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date parse = new Date();
                        try {
                            parse = simpleDateFormat.parse(serviceFundShared.getBusvicepresident().substring(serviceFundShared.getBusvicepresident().indexOf(" ") + 1, serviceFundShared.getBusvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        serviceFundflow.setCheckTime(parse);
                        spname = spname + serviceFundShared.getBusvicepresident() + "  ";
                    }
                    serviceFundflow.setFlowcontent(spname + "审批通过");
                    serviceFundflow.setFlowconclusion(1);
                    serviceFundflow.setFundtype(2);
                    // 999 通过
                    serviceFundflow.setFlowlevel(999);
                    serviceFundflow.setApplytype(serviceFundShared.getApplytype());
                    serviceFundflow.setFundid(serviceFundShared.getSerfunid());
                    serviceFundShared.setSpjg(1);
                    fundflowService.save(serviceFundflow);

                    serviceFundflow.setFlowcontent("已付款 : " + serviceFundShared.getZffs());
                    serviceFundflow.setId(null);
                    fundflowService.save(serviceFundflow);
                    //将审批状态改成1
                    serviceFundSharedService.updateById(serviceFundShared);

                } else if (StringUtils.isNotBlank(serviceFundShared.getZffs()) && serviceFundShared.getSpjg() == 1) {
                    //钱已经到帐,并且审批结果为1，审批结束,就不管那些领导是否签字了
                    continue;
                }

                ServiceFund serviceFund = new ServiceFund();
                serviceFund.setId(serviceFundShared.getSerfunid());
                List<ServiceFund> serviceFunds = serviceFundService.queryList(serviceFund);
                if (!CollectionUtils.isEmpty(serviceFunds)) {
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                    Date parse = new Date();


                    if (StringUtils.isNotBlank(serviceFundShared.getPresident())) {
                        //先查询一下fund是否已经更新President，如果没有更新，则进行更新，并往fundflow表里插一条数据
                        if (StringUtils.isEmpty(serviceFunds.get(0).getPresident())) {
                            try {
                                parse = simpleDateFormat.parse(serviceFundShared.getPresident().substring(serviceFundShared.getPresident().indexOf(" ") + 1, serviceFundShared.getPresident().length()));
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            serviceFund.setPresident(serviceFundShared.getPresident());
                            serviceFundService.updateById(serviceFund);

                            //将操作保存到fundflow表中
                            ServiceFundflow serviceFundflow = new ServiceFundflow();
                            serviceFundflow.setCreateBy("admin");
                            serviceFundflow.setCreateTime(new Date());
                            serviceFundflow.setUpdateBy("admin");
                            serviceFundflow.setUpdateTime(new Date());
                            serviceFundflow.setCheckusername(serviceFundShared.getPresident().substring(0, serviceFundShared.getPresident().indexOf(" ")));
                            serviceFundflow.setFlowcontent(serviceFundShared.getPresident().substring(0, serviceFundShared.getPresident().indexOf(" ")) + "审批通过");
                            serviceFundflow.setFlowconclusion(1);
                            serviceFundflow.setFundtype(2);
                            serviceFundflow.setFlowlevel(999);
                            serviceFundflow.setApplytype(serviceFundShared.getApplytype());
                            serviceFundflow.setFundid(serviceFundShared.getSerfunid());
                            serviceFundflow.setCheckTime(parse);
                            fundflowService.save(serviceFundflow);

                        }
                        //如果已经更新则不在处理

                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getFinvicepresident())) {
                        try {
                            parse = simpleDateFormat.parse(serviceFundShared.getFinvicepresident().substring(serviceFundShared.getFinvicepresident().indexOf(" ") + 1, serviceFundShared.getFinvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        //先查询一下fund是否已经更新Finvicepresident，如果没有更新，则进行更新，并往fundflow表里插一条数据
                        if (StringUtils.isEmpty(serviceFunds.get(0).getFinvicepresident())) {
                            serviceFund.setFinvicepresident(serviceFundShared.getFinvicepresident());
                            serviceFundService.updateById(serviceFund);

                            //将操作保存到fundflow表中
                            ServiceFundflow serviceFundflow = new ServiceFundflow();
                            serviceFundflow.setCreateBy("admin");
                            serviceFundflow.setCreateTime(new Date());
                            serviceFundflow.setUpdateBy("admin");
                            serviceFundflow.setUpdateTime(new Date());
                            serviceFundflow.setCheckusername(serviceFundShared.getFinvicepresident().substring(0, serviceFundShared.getFinvicepresident().indexOf(" ")));
                            serviceFundflow.setFlowcontent(serviceFundShared.getFinvicepresident().substring(0, serviceFundShared.getFinvicepresident().indexOf(" ")) + "审批通过");
                            serviceFundflow.setFlowconclusion(1);
                            serviceFundflow.setFundtype(2);
                            serviceFundflow.setFlowlevel(999);
                            serviceFundflow.setApplytype(serviceFundShared.getApplytype());
                            serviceFundflow.setFundid(serviceFundShared.getSerfunid());
                            serviceFundflow.setCheckTime(parse);
                            fundflowService.save(serviceFundflow);

                        }
                        //如果已经更新则不在处理
                    }
                    if (StringUtils.isNotBlank(serviceFundShared.getBusvicepresident())) {
                        try {
                            parse = simpleDateFormat.parse(serviceFundShared.getBusvicepresident().substring(serviceFundShared.getBusvicepresident().indexOf(" ") + 1, serviceFundShared.getBusvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        //先查询一下fund是否已经更新Busvicepresident，如果没有更新，则进行更新，并往fundflow表里插一条数据
                        if (StringUtils.isEmpty(serviceFunds.get(0).getBusvicepresident())) {
                            serviceFund.setBusvicepresident(serviceFundShared.getBusvicepresident());
                            serviceFundService.updateById(serviceFund);

                            //将操作保存到fundflow表中
                            ServiceFundflow serviceFundflow = new ServiceFundflow();
                            serviceFundflow.setCreateBy("admin");
                            serviceFundflow.setCreateTime(new Date());
                            serviceFundflow.setUpdateBy("admin");
                            serviceFundflow.setUpdateTime(new Date());
                            serviceFundflow.setCheckusername(serviceFundShared.getBusvicepresident().substring(0, serviceFundShared.getBusvicepresident().indexOf(" ")));
                            serviceFundflow.setFlowcontent(serviceFundShared.getBusvicepresident().substring(0, serviceFundShared.getBusvicepresident().indexOf(" ")) + "通过");
                            serviceFundflow.setFlowconclusion(1);
                            serviceFundflow.setFundtype(2);
                            serviceFundflow.setFlowlevel(999);
                            serviceFundflow.setApplytype(serviceFundShared.getApplytype());
                            serviceFundflow.setFundid(serviceFundShared.getSerfunid());
                            serviceFundflow.setCheckTime(parse);
                            fundflowService.save(serviceFundflow);

                        }
                        //如果已经更新则不在处理
                    }
                }
            }
        }


        //查出所有被医院退回的Reimbursement数据
        List<ServiceReimbursementShared> serviceReimbursementShareds = serviceReimbursementSharedService.queryReShareList();
        for (ServiceReimbursementShared serviceReimbursementShared : serviceReimbursementShareds) {
            if (StringUtils.isNotBlank(serviceReimbursementShared.getOabdzt()) && serviceReimbursementShared.getOabdzt().equals("已撤销")) {
                String phone = serviceReimbursementShared.getPhone();
                String[] split = null;
                log.info("serviceReimbursementShared.getCxrjyj(): {}" , serviceReimbursementShared.getCxrjyj());
                if (StringUtils.isNotBlank(serviceReimbursementShared.getCxrjyj())) {
                    split = serviceReimbursementShared.getCxrjyj().split("&");
                }

                //将分享里的该数据删除
                Boolean aBoolean = serviceReimbursementSharedService.delResharedInfoById(serviceReimbursementShared.getId());
                log.info("将分享里的该数据删除: {}" , aBoolean);
                //将Flowlevel 设置为0;
                ServiceReimbursement serviceReimbursement = new ServiceReimbursement();
                serviceReimbursement.setId(serviceReimbursementShared.getReimid());
                List<ServiceReimbursement> serviceReimbursementList = serviceReimbursementService.queryList(serviceReimbursement);
                ServiceReimbursement serviceReimbursement1 = serviceReimbursementList.get(0);
                serviceReimbursement1.setFlowlevel(100L);
                serviceReimbursement1.setDelFlag(0);
                serviceReimbursement1.setUploadStates(0);
                serviceReimbursement1.setBackflowlevel(199L);
                serviceReimbursement1.setRecordstatus(-1);
                serviceReimbursementService.updateById(serviceReimbursement1);

                SysUser sysUser = sysUserService.selectUserByUserName(serviceReimbursement1.getUserno());
                //发送信息保存
//                sendMeg(split, sysUser.getPhonenumber(), "0" , 1, serviceReimbursementShared.getReimid());
                ServiceSystemmessage serviceSystemmessage = new ServiceSystemmessage();
                serviceSystemmessage.setFundtype(1);
                serviceSystemmessage.setSenduserno(sysUser.getUserName());
                serviceSystemmessage.setSendusername(sysUser.getNickName());
                serviceSystemmessage.setReceiveuserno(serviceReimbursement1.getUserno());
                serviceSystemmessage.setReceiveusername(serviceReimbursement1.getUsername());
                serviceSystemmessage.setUpdateTime(new Date());
                serviceSystemmessage.setUpdateBy(sysUser.getNickName());
                serviceSystemmessage.setIsread(0);
                serviceSystemmessage.setMessagetype(1);
                serviceSystemmessage.setMessagetitle("财务系统驳回信息");
                serviceSystemmessage.setMessagecontent(serviceReimbursementShared.getCxrjyj());
                iServiceSystemmessageService.save(serviceSystemmessage);
            } else {
                //不是退回的操作

                if (StringUtils.isNotBlank(serviceReimbursementShared.getZffs()) && serviceReimbursementShared.getSpjg() == 0) {
                    String bh = myMethod();
                    //钱已经到帐,并且审批结果为0(0为审批中)，说明审批结束，但数据还没有同步到fund表和fundflow表;对fund表和fundflow表进行更新，并将0改成1（1审批结束）
                    ServiceReimbursement serviceReimbursement = new ServiceReimbursement();
                    serviceReimbursement.setId(serviceReimbursementShared.getReimid());
                    serviceReimbursement.setZffs(serviceReimbursementShared.getZffs());
                    serviceReimbursement.setRiqi(serviceReimbursementShared.getRiqi());
                    serviceReimbursement.setBh(serviceReimbursementShared.getBh());
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getPresident())) {
                        serviceReimbursement.setPresident(serviceReimbursementShared.getPresident());
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getFinvicepresident())) {
                        serviceReimbursement.setFinvicepresident(serviceReimbursementShared.getFinvicepresident());
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getBusvicepresident())) {
                        serviceReimbursement.setBusvicepresident(serviceReimbursementShared.getBusvicepresident());
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getOfficedirector())) {
                        serviceReimbursement.setOfficedirector(serviceReimbursementShared.getOfficedirector());
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getFinancedirector())) {
                        serviceReimbursement.setFinancedirector(serviceReimbursementShared.getFinancedirector());
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getFinancechecher())) {
                        serviceReimbursement.setFinancechecher(serviceReimbursementShared.getFinancechecher());
                    }
                    boolean b = serviceReimbursementService.updateById(serviceReimbursement);
                    log.info("更新serviceReimbursement里的zffs表是否成功: {}" , b);
                    ServiceFundflow serviceFundflow = new ServiceFundflow();
                    serviceFundflow.setCreateBy("admin");
                    serviceFundflow.setCreateTime(new Date());
                    serviceFundflow.setUpdateBy("admin");
                    serviceFundflow.setUpdateTime(new Date());
                    //用三个审批人，如果都为空，就为空
                    String spName = "";

                    if (StringUtils.isNotBlank(serviceReimbursementShared.getPresident())) {
                        serviceFundflow.setCheckusername(serviceReimbursementShared.getPresident().substring(0, serviceReimbursementShared.getPresident().indexOf(" ")));
                        //更新校验时间
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date parse = new Date();
                        try {
                            parse = simpleDateFormat.parse(serviceReimbursementShared.getPresident().substring(serviceReimbursementShared.getPresident().indexOf(" ") + 1, serviceReimbursementShared.getPresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        serviceFundflow.setCheckTime(parse);
                        spName = spName + serviceReimbursementShared.getPresident() + "  ";
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getFinvicepresident())) {
                        serviceFundflow.setCheckusername(serviceReimbursementShared.getFinvicepresident().substring(0, serviceReimbursementShared.getFinvicepresident().indexOf(" ")));
                        //更新校验时间
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date parse = new Date();
                        try {
                            parse = simpleDateFormat.parse(serviceReimbursementShared.getFinvicepresident().substring(serviceReimbursementShared.getFinvicepresident().indexOf(" ") + 1, serviceReimbursementShared.getFinvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        serviceFundflow.setCheckTime(parse);
                        spName = spName + serviceReimbursementShared.getFinvicepresident() + "  ";
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getBusvicepresident())) {
                        serviceFundflow.setCheckusername(serviceReimbursementShared.getBusvicepresident().substring(0, serviceReimbursementShared.getBusvicepresident().indexOf(" ")));
                        //更新校验时间
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date parse = new Date();
                        try {
                            parse = simpleDateFormat.parse(serviceReimbursementShared.getBusvicepresident().substring(serviceReimbursementShared.getBusvicepresident().indexOf(" ") + 1, serviceReimbursementShared.getBusvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        serviceFundflow.setCheckTime(parse);
                        spName = spName + serviceReimbursementShared.getBusvicepresident() + "  ";
                    }
                    serviceFundflow.setFlowcontent(spName + "审批通过");
                    serviceFundflow.setFlowconclusion(1);
                    serviceFundflow.setFundtype(1);
                    // 999 通过
                    serviceFundflow.setFlowlevel(999);
                    serviceFundflow.setApplytype("0");
                    serviceFundflow.setFundid(serviceReimbursementShared.getReimid());

                    serviceReimbursementShared.setSpjg(1);
                    fundflowService.save(serviceFundflow);
                    serviceFundflow.setFlowcontent("已付款 : " + serviceReimbursementShared.getZffs());
                    serviceFundflow.setId(null);
                    fundflowService.save(serviceFundflow);
                    serviceReimbursementSharedService.updateById(serviceReimbursementShared);

                } else if (StringUtils.isNotBlank(serviceReimbursementShared.getZffs()) && serviceReimbursementShared.getSpjg().equals("1")) {
                    //钱已经到帐,并且审批结果为1，审批结束,就不管那些领导是否签字了
                    continue;
                }

                ServiceReimbursement reimbursement = new ServiceReimbursement();
                reimbursement.setId(serviceReimbursementShared.getReimid());
                List<ServiceReimbursement> serviceReimbursementList = serviceReimbursementService.queryList(reimbursement);
                if (!CollectionUtils.isEmpty(serviceReimbursementList)) {
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                    Date parse = new Date();

                    if (StringUtils.isNotBlank(serviceReimbursementShared.getPresident())) {
                        try {
                            parse = simpleDateFormat.parse(serviceReimbursementShared.getPresident().substring(serviceReimbursementShared.getPresident().indexOf(" ") + 1, serviceReimbursementShared.getPresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        //先查询一下fund是否已经更新President，如果没有更新，则进行更新，并往fundflow表里插一条数据
                        if (StringUtils.isEmpty(serviceReimbursementList.get(0).getPresident())) {
                            reimbursement.setPresident(serviceReimbursementShared.getPresident());

                            serviceReimbursementService.updateById(reimbursement);

                            //将操作保存到fundflow表中
                            ServiceFundflow serviceFundflow = new ServiceFundflow();
                            serviceFundflow.setCreateBy("admin");
                            serviceFundflow.setCreateTime(new Date());
                            serviceFundflow.setUpdateBy("admin");
                            serviceFundflow.setUpdateTime(new Date());
                            serviceFundflow.setCheckusername(serviceReimbursementShared.getPresident().substring(0, serviceReimbursementShared.getPresident().indexOf(" ")));
                            serviceFundflow.setFlowcontent(serviceReimbursementShared.getPresident().substring(0, serviceReimbursementShared.getPresident().indexOf(" ")) + "审批通过");
                            serviceFundflow.setFlowconclusion(1);
                            serviceFundflow.setFundtype(1);
                            serviceFundflow.setFlowlevel(999);
                            serviceFundflow.setApplytype("0");
                            serviceFundflow.setFundid(serviceReimbursementShared.getReimid());
                            serviceFundflow.setCheckTime(parse);
                            fundflowService.save(serviceFundflow);

                        }
                        //如果已经更新则不在处理

                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getFinvicepresident())) {
                        try {
                            parse = simpleDateFormat.parse(serviceReimbursementShared.getFinvicepresident().substring(serviceReimbursementShared.getFinvicepresident().indexOf(" ") + 1, serviceReimbursementShared.getFinvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        //先查询一下fund是否已经更新Finvicepresident，如果没有更新，则进行更新，并往fundflow表里插一条数据
                        if (StringUtils.isEmpty(serviceReimbursementList.get(0).getFinvicepresident())) {
                            reimbursement.setFinvicepresident(serviceReimbursementShared.getFinvicepresident());
                            serviceReimbursementService.updateById(reimbursement);

                            //将操作保存到fundflow表中
                            ServiceFundflow serviceFundflow = new ServiceFundflow();
                            serviceFundflow.setCreateBy("admin");
                            serviceFundflow.setCreateTime(new Date());
                            serviceFundflow.setUpdateBy("admin");
                            serviceFundflow.setUpdateTime(new Date());
                            serviceFundflow.setCheckusername(serviceReimbursementShared.getFinvicepresident().substring(0, serviceReimbursementShared.getFinvicepresident().indexOf(" ")));
                            serviceFundflow.setFlowcontent(serviceReimbursementShared.getFinvicepresident().substring(0, serviceReimbursementShared.getFinvicepresident().indexOf(" ")) + "审批通过");
                            serviceFundflow.setFlowconclusion(1);
                            serviceFundflow.setFundtype(1);
                            serviceFundflow.setFlowlevel(999);
                            serviceFundflow.setApplytype("0");
                            serviceFundflow.setCheckTime(parse);
                            serviceFundflow.setFundid(serviceReimbursementShared.getReimid());
                            fundflowService.save(serviceFundflow);

                        }
                        //如果已经更新则不在处理
                    }
                    if (StringUtils.isNotBlank(serviceReimbursementShared.getBusvicepresident())) {
                        try {
                            parse = simpleDateFormat.parse(serviceReimbursementShared.getBusvicepresident().substring(serviceReimbursementShared.getBusvicepresident().indexOf(" ") + 1, serviceReimbursementShared.getBusvicepresident().length()));
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        //先查询一下fund是否已经更新Busvicepresident，如果没有更新，则进行更新，并往fundflow表里插一条数据
                        if (StringUtils.isEmpty(serviceReimbursementList.get(0).getBusvicepresident())) {
                            reimbursement.setBusvicepresident(serviceReimbursementShared.getBusvicepresident());
                            serviceReimbursementService.updateById(reimbursement);

                            //将操作保存到fundflow表中
                            ServiceFundflow serviceFundflow = new ServiceFundflow();
                            serviceFundflow.setCreateBy("admin");
                            serviceFundflow.setCreateTime(new Date());
                            serviceFundflow.setUpdateBy("admin");
                            serviceFundflow.setUpdateTime(new Date());
                            serviceFundflow.setCheckusername(serviceReimbursementShared.getBusvicepresident().substring(0, serviceReimbursementShared.getBusvicepresident().indexOf(" ")));
                            serviceFundflow.setFlowcontent(serviceReimbursementShared.getBusvicepresident().substring(0, serviceReimbursementShared.getBusvicepresident().indexOf(" ")) + "审批通过");
                            serviceFundflow.setFlowconclusion(1);
                            serviceFundflow.setFundtype(1);
                            serviceFundflow.setFlowlevel(999);
                            serviceFundflow.setApplytype("0");
                            serviceFundflow.setCheckTime(parse);
                            serviceFundflow.setFundid(serviceReimbursementShared.getReimid());

                            serviceFundflow.setCheckTime(parse);
                            fundflowService.save(serviceFundflow);
                        }
                        //如果已经更新则不在处理
                    }
                }
            }
        }
    }


    public void sendMeg(String[] split, String phone, String applyType, Integer fundType, Long fundId) throws ApiException {
        String content = null;
        String time = null;
        String people = null;

        if (split.length >= 1) {
            people = split[0];
        }
        if (split.length >= 2) {
            time = split[1];
        }
        if (split.length >= 3) {
            content = split[2];
        }

        //记录操作记录
        ServiceFundflow serviceFundflow = new ServiceFundflow();

        serviceFundflow.setCreateBy(people);
        serviceFundflow.setUpdateBy(people);
        serviceFundflow.setCheckusername(people);
        serviceFundflow.setCreateTime(new Date());
        serviceFundflow.setUpdateTime(new Date());
        serviceFundflow.setFlowcontent(content);
        serviceFundflow.setFlowconclusion(2);
        serviceFundflow.setFundtype(fundType);
        serviceFundflow.setFlowlevel(100);
        serviceFundflow.setApplytype(applyType);
        serviceFundflow.setFundid(fundId);
        fundflowService.save(serviceFundflow);

        ArrayList<ConcurrentHashMap<String, Object>> contentList = new ArrayList<>();
        ConcurrentHashMap map = new ConcurrentHashMap();
        map.put("审批人：" , people);
        try {
            boolean validDateTime = isValidDateTime(time);
            if (validDateTime) map.put("审批时间：" , new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time));
            else map.put("审批时间：" , new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time + ":00"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        map.put("意见：" , content);
        contentList.add(map);
        DingTalkReqVo dingTalkReqVo = new DingTalkReqVo();
        dingTalkReqVo.setTitle("财务系统驳回信息");
        dingTalkReqVo.setNumber(phone);
        dingTalkReqVo.setContents(contentList);
        log.info("钉钉发送消息:{}" , dingTalkReqVo);
        dingTalkService.sendNotification(dingTalkReqVo);
    }

    public boolean isValidDateTime(String dateTime) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime.parse(dateTime, formatter);
            return true;
        } catch (DateTimeParseException e) {
            return false;
        }
    }

    private ReentrantLock lock = new ReentrantLock();

    public String myMethod() {
        lock.lock();
        String bh = null;
        try {
            // 代码块
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMM");
            String format = simpleDateFormat.format(new Date());
            ServiceTasknum serviceTasknum = new ServiceTasknum();
            serviceTasknum.setYearmonth(format);
            //CW  财务
            serviceTasknum.setApptype("CW");
            List<ServiceTasknum> serviceTasknums = ServiceTasknumService.queryList(serviceTasknum);
            long nums = 1;
            if (CollectionUtils.isEmpty(serviceTasknums)) {
                //进行插入操作
                serviceTasknum.setSerialnumber(nums);
                ServiceTasknumService.save(serviceTasknum);
                bh = serviceTasknum.getYearmonth() + "0" + nums;
            } else {
                //获取唯一值的最大值
                nums = serviceTasknums.stream().mapToLong(ServiceTasknum::getSerialnumber).max().getAsLong() + 1;

                ServiceTasknum serviceTasknum1 = serviceTasknums.get(0);
                serviceTasknum1.setSerialnumber(nums);
                //对该条数据的唯一值加1
                ServiceTasknumService.updateById(serviceTasknum1);
                //将生成的编号返回
                if (nums < 10) {
                    bh = serviceTasknums.get(0).getYearmonth() + "0" + nums;
                } else {
                    bh = serviceTasknums.get(0).getYearmonth() + nums;
                }
            }
        } catch (Exception e) {
            log.error("获取编号失败了{}" , e.getStackTrace());
        } finally {
            lock.unlock();
        }
        return bh;
    }


    /**
     * 将数据存到分享表中
     */
    public void addDataShared() {
        ServiceFundflowrule serviceFundflowrule = new ServiceFundflowrule();
        //处理差旅报销
        serviceFundflowrule.setApplytype("0");
        List<ServiceFundflowrule> serviceFundflowrules = iServiceFundflowruleService.queryList(serviceFundflowrule);
        log.info("差旅的最高等级:{}" , serviceFundflowrules.get(0).getTotallevel());
        ServiceReimbursement serviceReimbursement = new ServiceReimbursement();
        serviceReimbursement.setFlowlevel(serviceFundflowrules.get(0).getTotallevel().longValue());
        serviceReimbursement.setUploadStates(1);
        serviceReimbursement.setDelFlag(0);
        List<ServiceReimbursement> serviceReimbursementList = serviceReimbursementService.queryList(serviceReimbursement);
        for (ServiceReimbursement serviceReimbursement1 : serviceReimbursementList) {
            try {
                log.info("插入分享表的ID为：{}" , serviceReimbursement1.getId());
                Boolean aBoolean = serviceReimbursementService.addSharedData(serviceReimbursement1.getId());
                if (aBoolean) {
                    ServiceReimbursement serviceReimbursement3 = new ServiceReimbursement();
                    serviceReimbursement3.setId(serviceReimbursement1.getId());
                    serviceReimbursement3.setUploadStates(2);
                    boolean b = serviceReimbursementService.updateById(serviceReimbursement3);
                    log.info("serviceReimbursement是否插入成功{},{}" , aBoolean, b);
                }
            } catch (Exception e) {
                ServiceReimbursement serviceReimbursement2 = new ServiceReimbursement();
                serviceReimbursement2.setId(serviceReimbursement1.getId());
                serviceReimbursement2.setNotes("插入分享表失败");
                serviceReimbursementService.updateById(serviceReimbursement2);
            }
        }

        //专家劳务费申请
        serviceFundflowrule.setApplytype("1");
        List<ServiceFundflowrule> serviceFundflowrules2 = iServiceFundflowruleService.queryList(serviceFundflowrule);
        log.info("专家劳务的最高等级:{}" , serviceFundflowrules2.get(0).getTotallevel());
        addFundShared(serviceFundflowrules2.get(0).getTotallevel().longValue(), "1");

        //伦理专家劳务费申请
        serviceFundflowrule.setApplytype("2");
        List<ServiceFundflowrule> serviceFundflowrules3 = iServiceFundflowruleService.queryList(serviceFundflowrule);
        log.info("伦理专家劳务费申请:{}" , serviceFundflowrules3.get(0).getTotallevel());
        addFundShared(serviceFundflowrules3.get(0).getTotallevel().longValue(), "2");

        //医学成本报销
        serviceFundflowrule.setApplytype("3");
        List<ServiceFundflowrule> serviceFundflowrules4 = iServiceFundflowruleService.queryList(serviceFundflowrule);
        log.info("医学成本报销:{}" , serviceFundflowrules4.get(0).getTotallevel());
        addFundShared(serviceFundflowrules4.get(0).getTotallevel().longValue(), "3");

        //办公费用报销
        serviceFundflowrule.setApplytype("4");
        List<ServiceFundflowrule> serviceFundflowrules5 = iServiceFundflowruleService.queryList(serviceFundflowrule);
        log.info("办公费用报销:{}" , serviceFundflowrules5.get(0).getTotallevel());
        addFundShared(serviceFundflowrules5.get(0).getTotallevel().longValue(), "4");

        //绩效审批报销
        serviceFundflowrule.setApplytype("5");
        List<ServiceFundflowrule> serviceFundflowrules6 = iServiceFundflowruleService.queryList(serviceFundflowrule);
        log.info("办公费用报销:{}" , serviceFundflowrules6.get(0).getTotallevel());
        addFundShared(serviceFundflowrules6.get(0).getTotallevel().longValue(), "5");

    }

    private void addFundShared(Long totallevel, String applyType) {
        ServiceFund serviceFund = new ServiceFund();
        serviceFund.setFlowlevel(totallevel);
        serviceFund.setUploadStates(1);
        serviceFund.setDel_flag(0);
        serviceFund.setApplytype(applyType);
        List<ServiceFund> serviceFundList = serviceFundService.queryList(serviceFund);
        for (ServiceFund serviceFund1 : serviceFundList) {
            try {
                log.info("插入分享表的FundID为：{}" , serviceFund1.getId());
                Boolean aBoolean = serviceFundService.addFundSharedInfo(serviceFund1.getId());
                if (aBoolean) {
                    ServiceFund serviceFund2 = new ServiceFund();
                    serviceFund2.setId(serviceFund1.getId());
                    serviceFund2.setUploadStates(2);
                    serviceFund2.setUpdateTime(new Date());
                    boolean b = serviceFundService.updateById(serviceFund2);
                    log.info("serviceReimbursement是否插入成功{},{}" , aBoolean, b);
                }
            } catch (Exception e) {
                e.printStackTrace();
                ServiceFund serviceFund2 = new ServiceFund();
                serviceFund2.setId(serviceFund1.getId());
                serviceFund2.setUploadStates(1);
                serviceFund2.setNotes("插入fund分享表失败");
                serviceFundService.updateById(serviceFund2);
            }
        }
    }

}