智能外呼为接同短信通知修改，外呼统计查询修改

zhongrj

2023-06-29 0e06fd9184c0cda32a8c55ed1f4a295305d647fd

智能外呼为接同短信通知修改，外呼统计查询修改

 skjcmanager/skjcmanager-service-api/skjcmanager-sm-api/src/main/java/cn/gistack/sm/intelligentCall/entity/CallSmsNoticeTask.java

New file
@@ -0,0 +1,61 @@
package cn.gistack.sm.intelligentCall.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * 外呼短息通知任务
 * @author zhongrj
 * @date 2023-06-28
 */
@Data
@TableName("sm_call_sms_notice_task")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "sm_call_sms_notice_task对象", description = "外呼短息通知任务")
public class CallSmsNoticeTask {

    /**
     * 主键id
     */
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    /**
     * 外呼任务ID
     */
    @ApiModelProperty(value = "外呼任务ID")
    private Integer taskId;

    /**
     * 创建人
     */
    @ApiModelProperty(value = "创建人")
    private Long createUser;

    /**
     * 创建时间
     */
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    /**
     * 通知开始时间
     */
    @ApiModelProperty(value = "通知开始时间")
    private Date startTime;

    /**
     * 通知结束时间
     */
    @ApiModelProperty(value = "通知结束时间")
    private Date endTime;
}

 skjcmanager/skjcmanager-service-api/skjcmanager-sm-api/src/main/java/cn/gistack/sm/intelligentCall/feign/OutCallClient.java

@@ -21,6 +21,7 @@
    String CREATE_OUT_CALL_TASK_JOB_HANDLER = API_PREFIX + "/createOutCallTaskJobHandler";
    String CREATE_OUT_CALL_TASK_BY_NOT_CONNECT_JOB_HANDLER = API_PREFIX + "/createOutCallTaskByNotConnectJobHandler";
    String GET_CALL_NOT_FILL_RECORD_INFO = API_PREFIX + "/getCallNotFillRecordInfo";
    String CREATE_CALL_SMS_NOTICE_TASK = API_PREFIX + "/createCallSmsNoticeTask";
    String TEST_OUT_CALL = API_PREFIX + "/testOutCall";

    /**
@@ -66,4 +67,12 @@
     */
    @GetMapping(GET_CALL_NOT_FILL_RECORD_INFO)
    CallNotFillRecord getCallNotFillRecordInfo(@RequestParam("callId") String callId);

    /**
     * 外呼短信通知任务
     * @param taskId 外呼任务id
     * @return
     */
    @GetMapping(CREATE_CALL_SMS_NOTICE_TASK)
    Boolean createCallSmsNoticeTask(@RequestParam("taskId") String taskId);
}

 skjcmanager/skjcmanager-service-api/skjcmanager-sm-api/src/main/java/cn/gistack/sm/intelligentCall/feign/OutCallClientFallback.java

@@ -31,4 +31,9 @@
    public CallNotFillRecord getCallNotFillRecordInfo(String callId) {
        return null;
    }

    @Override
    public Boolean createCallSmsNoticeTask(String taskId) {
        return null;
    }
}

 skjcmanager/skjcmanager-service-api/skjcmanager-sm-api/src/main/java/cn/gistack/sm/intelligentCall/vo/CallSmsNoticeTaskVO.java

New file
@@ -0,0 +1,14 @@
package cn.gistack.sm.intelligentCall.vo;

import cn.gistack.sm.intelligentCall.entity.CallNotFillRecord;
import cn.gistack.sm.intelligentCall.entity.CallSmsNoticeTask;
import lombok.Data;

/**
 * 外呼短息通知任务 vo
 * @author zhongrj
 * @date 2023-06-28
 */
@Data
public class CallSmsNoticeTaskVO extends CallSmsNoticeTask {
}

 skjcmanager/skjcmanager-service-api/skjcmanager-sm-api/src/main/java/cn/gistack/sm/intelligentCall/vo/CallTaskStatistic.java

@@ -163,4 +163,14 @@
     * 排序（升序，降序）
     */
    private String sortOrder;

    /**
     * 市名称
     */
    private String cityName;

    /**
     * 县名称
     */
    private String countyName;
}

 skjcmanager/skjcmanager-service/skjcmanager-alerts/src/main/java/cn/gistack/alerts/sms/mapper/SmsTemplateMapper.java

@@ -26,11 +26,18 @@

    /**
     * 查询当前任务未接通的人员信息（包含水库编号）--MYSQL
     * @param taskId
     * @param taskIdList
     * @param callId
     * @return
     */
    @DS("znwh")
    List<Map<String, Object>> getNotConnectPatrolPersonList(@Param("taskId") String taskId,
    List<Map<String, Object>> getNotConnectPatrolPersonList(@Param("taskIdList") List<String> taskIdList,
                                                            @Param("callId") String callId);

    /**
     * 查询符合当前时间外呼任务id集合
     * @param time
     * @return
     */
    List<String> getTaskIdListByTime(@Param("time") String time);
}

 skjcmanager/skjcmanager-service/skjcmanager-alerts/src/main/java/cn/gistack/alerts/sms/mapper/SmsTemplateMapper.xml

@@ -29,10 +29,29 @@
            TRIM(BOTH '"' FROM JSON_EXTRACT(ctc.call_task_callee_content,'$."$水库名称$"')) as waterName,
            TRIM(BOTH '"' FROM JSON_EXTRACT(ctc.call_task_callee_content,'$."$用户名$"')) as userName
        from call_task_callee ctc left join call_task_result ctr on ctc.call_id = ctr.call_id
        where ctc.task_id = #{taskId}
        where 1=1
        and ctr.call_result!='200000'
        <choose>
            <when test="taskIdList != null and taskIdList.size()>0">
                and ctc.task_id in
                <foreach collection="taskIdList" item="id" separator ="," open="("  close=")">
                    #{id}
                </foreach>
            </when>
            <otherwise>
                and ctc.task_id in ('')
            </otherwise>
        </choose>
        <if test="callId!=null and callId!=''">
            and ctc.call_id = #{callId}
        </if>
    </select>

    <!--查询符合当前时间外呼任务id集合-->
    <select id="getTaskIdListByTime" resultType="java.lang.String">
        select task_id from sm_call_sms_notice_task
        where 1=1
        and date_format(start_time,'%Y-%m-%d %H:%i:%s') &lt;= #{time}
        and date_format(end_time,'%Y-%m-%d %H:%i:%s') >= #{time}
    </select>
</mapper>

 skjcmanager/skjcmanager-service/skjcmanager-alerts/src/main/java/cn/gistack/alerts/sms/service/ISmsTemplateService.java

@@ -31,5 +31,12 @@
     * @return
     */
    @DS("znwh")
    List<Map<String, Object>> getNotConnectPatrolPersonList(String taskId,String callId);
    List<Map<String, Object>> getNotConnectPatrolPersonList(List<String> taskId,String callId);

    /**
     * 查询符合当前时间外呼任务id集合
     * @param time
     * @return
     */
    List<String> getTaskIdListByTime(String time);
}

 skjcmanager/skjcmanager-service/skjcmanager-alerts/src/main/java/cn/gistack/alerts/sms/service/impl/SmsServiceImpl.java

@@ -31,6 +31,7 @@

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -338,66 +339,71 @@
    @Override
    public String sendSmsByOutCallNotConnect(String taskId,String time) {
        String templateId = "2431012249882";
        // 查询当前任务未接通的人员信息（包含水库编号）
        List<Map<String, Object>> list = smsTemplateService.getNotConnectPatrolPersonList(taskId,null);
        SmsTemplate smsTemplate = smsTemplateService.getOne(new QueryWrapper<SmsTemplate>().eq("template_id", templateId));
        if (list.size()>0) {
            List<Map<String, Object>> newList = new ArrayList<>();
            // 比对
            for (Map<String, Object> map : list) {
                // 获取任务id
                String redisByTaskId = bladeRedis.get(MinConstant.is_send_prefix + map.get("callId").toString());
                // 如果为null,并且不能匹配，加入发送短信集合
                if (redisByTaskId == null || !StringUtil.equalsIgnoreCase(redisByTaskId, taskId)) {
                    newList.add(map);
                }
            }
            if (newList.size() > 0) {
                // 组装短信数据
                StringBuilder builder = new StringBuilder();
                // 遍历
                for (Map<String, Object> map : newList) {
                    builder.append(map.get("userPhone") + ",")
                        .append(time + ",")
                        .append(map.get("waterName") + ",")
                        .append(MinConstant.fillWaterInfoUrl +"?" + "callId=" + map.get("callId"))
                        .append(";");
                }
                String datas = builder.toString();
                String title = "手机号码,时间范围,水库名称,访问链接";
                String[] titleArr = title.split(",");
                String[] rows = datas.split(";");
                String[][] dyns = new String[rows.length + 1][titleArr.length];
                dyns[0] = titleArr;
                int rowNum = 1;
                for (String row : rows) {
                    String[] cols = row.split(",");
                    dyns[rowNum++] = cols;
                }
                ComResult<DynSMSSendDataResult> resultComResult = sendDynSMSSendDataResultComResult(templateId, dyns);
                SmsResult smsResult = getSaveSmsResult(templateId, rows, "");
                if (null != smsResult) {
                    List<SmsRecord> smsRecordList = new ArrayList<>();
                    Pattern compile = Pattern.compile("[^0-9]");
                    Integer result = Integer.parseInt(compile.matcher(time).replaceAll("").trim());
                    // 分钟或小时
                    Long validTime = time.contains("分钟") ? 60L * result : 60L * 60 * result;
                    // 遍历保存
                    for (Map<String, Object> map : newList) {
                        // 保存redis
                        // 已发送短信的人员对应呼叫id的过期时间
                        bladeRedis.setEx(MinConstant.is_send_prefix + map.get("callId").toString(), taskId, MinConstant.is_send_time);
                        // 填报过期时间
                        bladeRedis.setEx(MinConstant.fill_info_prefix + map.get("callId").toString(), taskId, validTime);
                        // 封装短息记录数据
                        SmsRecord smsRecord = getSmsRecord(time, templateId, smsTemplate, resultComResult, smsResult, map);
                        // 加入集合
                        smsRecordList.add(smsRecord);
        // 查询符合当前时间外呼任务id集合
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        List<String> taskIdList = smsTemplateService.getTaskIdListByTime(format);
        if (taskIdList.size()>0) {
            // 查询当前任务未接通的人员信息（包含水库编号）
            List<Map<String, Object>> list = smsTemplateService.getNotConnectPatrolPersonList(taskIdList, null);
            SmsTemplate smsTemplate = smsTemplateService.getOne(new QueryWrapper<SmsTemplate>().eq("template_id", templateId));
            if (list.size() > 0) {
                List<Map<String, Object>> newList = new ArrayList<>();
                // 比对
                for (Map<String, Object> map : list) {
                    // 获取任务id
                    String redisByTaskId = bladeRedis.get(MinConstant.is_send_prefix + map.get("callId").toString());
                    // 如果为null,并且不能匹配，加入发送短信集合
                    if (redisByTaskId == null || !StringUtil.equalsIgnoreCase(redisByTaskId, taskId)) {
                        newList.add(map);
                    }
                    // 批量保存记录
                    Integer count = smsRecordService.batchSaveSendRecord(smsRecordList);
                    // 返回
                    return count.toString();
                }
                if (newList.size() > 0) {
                    // 组装短信数据
                    StringBuilder builder = new StringBuilder();
                    // 遍历
                    for (Map<String, Object> map : newList) {
                        builder.append(map.get("userPhone") + ",")
                            .append(time + ",")
                            .append(map.get("waterName") + ",")
                            .append(MinConstant.fillWaterInfoUrl + "?" + "callId=" + map.get("callId"))
                            .append(";");
                    }
                    String datas = builder.toString();
                    String title = "手机号码,时间范围,水库名称,访问链接";
                    String[] titleArr = title.split(",");
                    String[] rows = datas.split(";");
                    String[][] dyns = new String[rows.length + 1][titleArr.length];
                    dyns[0] = titleArr;
                    int rowNum = 1;
                    for (String row : rows) {
                        String[] cols = row.split(",");
                        dyns[rowNum++] = cols;
                    }
                    ComResult<DynSMSSendDataResult> resultComResult = sendDynSMSSendDataResultComResult(templateId, dyns);
                    SmsResult smsResult = getSaveSmsResult(templateId, rows, "");
                    if (null != smsResult) {
                        List<SmsRecord> smsRecordList = new ArrayList<>();
                        Pattern compile = Pattern.compile("[^0-9]");
                        Integer result = Integer.parseInt(compile.matcher(time).replaceAll("").trim());
                        // 分钟或小时
                        Long validTime = time.contains("分钟") ? 60L * result : 60L * 60 * result;
                        // 遍历保存
                        for (Map<String, Object> map : newList) {
                            // 保存redis
                            // 已发送短信的人员对应呼叫id的过期时间
                            bladeRedis.setEx(MinConstant.is_send_prefix + map.get("callId").toString(), taskId, MinConstant.is_send_time);
                            // 填报过期时间
                            bladeRedis.setEx(MinConstant.fill_info_prefix + map.get("callId").toString(), taskId, validTime);
                            // 封装短息记录数据
                            SmsRecord smsRecord = getSmsRecord(time, templateId, smsTemplate, resultComResult, smsResult, map);
                            // 加入集合
                            smsRecordList.add(smsRecord);
                        }
                        // 批量保存记录
                        Integer count = smsRecordService.batchSaveSendRecord(smsRecordList);
                        // 返回
                        return count.toString();
                    }
                }
            }
        }
@@ -499,8 +505,10 @@
        String taskId = bladeRedis.get(MinConstant.fill_info_prefix + callId);
        // 判断
        if (null!=taskId && !taskId.equals("")){
            List<String> taskIdList = new ArrayList<>();
            taskIdList.add(taskId);
            // 通过手机号和外呼任务id 查询水库人员信息
            list = smsTemplateService.getNotConnectPatrolPersonList(taskId,callId);
            list = smsTemplateService.getNotConnectPatrolPersonList(taskIdList,callId);
            // 查询是否填报
            CallNotFillRecord callNotFillRecordInfo = outCallClient.getCallNotFillRecordInfo(callId);
            if (callNotFillRecordInfo != null){

 skjcmanager/skjcmanager-service/skjcmanager-alerts/src/main/java/cn/gistack/alerts/sms/service/impl/SmsTemplateServiceImpl.java

@@ -44,7 +44,17 @@
     */
    @Override
    @DS("znwh")
    public List<Map<String, Object>> getNotConnectPatrolPersonList(String taskId,String callId) {
    public List<Map<String, Object>> getNotConnectPatrolPersonList(List<String> taskId,String callId) {
        return baseMapper.getNotConnectPatrolPersonList(taskId,callId);
    }

    /**
     * 查询符合当前时间外呼任务id集合
     * @param time
     * @return
     */
    @Override
    public List<String> getTaskIdListByTime(String time) {
        return baseMapper.getTaskIdListByTime(time);
    }
}

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/controller/CallController.java

@@ -3,6 +3,7 @@
import cn.gistack.sm.intelligentCall.entity.CallTaskResult;
import cn.gistack.sm.intelligentCall.entity.Scene;
import cn.gistack.sm.intelligentCall.service.CallService;
import cn.gistack.sm.intelligentCall.service.ICallSmsNoticeTaskService;
import cn.gistack.sm.intelligentCall.vo.CallTaskResultVO;
import cn.gistack.sm.intelligentCall.vo.CallTaskStatistic;
import io.swagger.annotations.Api;
@@ -29,14 +30,35 @@

    private final CallService callService;

    private final ICallSmsNoticeTaskService callSmsNoticeTaskService;

    /**
     * 创建任务
     * @return
     */
    @PostMapping("/createCall")
    public R createCall(@RequestBody Map<String,Object> map){
        List<String> task = callService.createTask(map);
        // 创建外呼短信发送任务记录
        createCallSmsNoticeTask(task);
        // 返回
        return R.data(callService.createTask(map));
        return R.data(task);
    }

    /**
     * 创建外呼短信发送任务记录
     * @param result
     */
    private Boolean createCallSmsNoticeTask(List<String> result) {
        Boolean flag = false;
        if (null != result && result.size() > 0) {
            if (result.get(2).equals("true")) {
                // 获取任务id
                String taskId = result.get(1);
                flag = callSmsNoticeTaskService.createCallSmsNoticeTask(taskId);
            }
        }
        return flag;
    }

    /**

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/controller/CallSmsNoticeTaskController.java

New file
@@ -0,0 +1,139 @@
package cn.gistack.sm.intelligentCall.controller;


import cn.gistack.sm.intelligentCall.entity.CallSmsNoticeTask;
import cn.gistack.sm.intelligentCall.service.ICallSmsNoticeTaskService;
import cn.gistack.sm.intelligentCall.vo.CallSmsNoticeTaskVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.Date;

/**
 * 外呼短信通知任务
 *
 * @author zhongrj
 * @date 2023-06-13
 */
@Slf4j
@Api(tags = "外呼短信通知任务")
@RestController
@RequestMapping("/callSmsNoticeTask/callSmsNoticeTask")
@AllArgsConstructor
public class CallSmsNoticeTaskController {

    private final ICallSmsNoticeTaskService callSmsNoticeTaskService;

    /**
     * 分页列表查询
     *
     * @param callSmsNoticeTask
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-分页列表查询", notes = "外呼短信通知任务-分页列表查询")
    @GetMapping(value = "/list")
    public R queryPageList(CallSmsNoticeTask callSmsNoticeTask, Query query) {
        IPage<CallSmsNoticeTask> pageList = callSmsNoticeTaskService.page(Condition.getPage(query), Condition.getQueryWrapper(callSmsNoticeTask));
        return R.data(pageList);
    }


    /**
     * 自定义分页列表查询
     *
     * @param query
     * @param callSmsNoticeTask
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-自定义分页列表查询", notes = "外呼短信通知任务-自定义分页列表查询")
    @GetMapping(value = "/page")
    public R page(CallSmsNoticeTaskVO callSmsNoticeTask, Query query) {
        return R.data(callSmsNoticeTaskService.selectCallSmsNoticeTaskPage(Condition.getPage(query), callSmsNoticeTask));
    }

    /**
     * 获取全部
     */
    @ApiOperation(value = "外呼短信通知任务-获取全部", notes = "外呼短信通知任务-获取全部")
    @GetMapping(value = "/all")
    public R getAll(CallSmsNoticeTask callSmsNoticeTask) {
        return R.data(callSmsNoticeTaskService.list(Condition.getQueryWrapper(callSmsNoticeTask)));
    }

    /**
     * 添加
     *
     * @param callSmsNoticeTask
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-添加", notes = "外呼短信通知任务-添加")
    @PostMapping(value = "/add")
    public R add(@RequestBody CallSmsNoticeTask callSmsNoticeTask) {
        callSmsNoticeTask.setCreateTime(new Date());
        // 判断已插入，防止重复插入的情况
        CallSmsNoticeTask notFillRecord = callSmsNoticeTaskService.getOne(new QueryWrapper<CallSmsNoticeTask>().eq("task_id", callSmsNoticeTask.getTaskId()));
        if (notFillRecord != null){
            return R.data(false);
        }
        return R.data(callSmsNoticeTaskService.save(callSmsNoticeTask));
    }

    /**
     * 编辑
     *
     * @param callSmsNoticeTask
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-编辑", notes = "外呼短信通知任务-编辑")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
    public R edit(@RequestBody CallSmsNoticeTask callSmsNoticeTask) {
        return R.data(callSmsNoticeTaskService.updateById(callSmsNoticeTask));
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-通过id删除", notes = "外呼短信通知任务-通过id删除")
    @PostMapping(value = "/delete")
    public R delete(@RequestParam(name = "id", required = true) String id) {
        return R.data(callSmsNoticeTaskService.removeById(id));
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-批量删除", notes = "外呼短信通知任务-批量删除")
    @PostMapping(value = "/deleteBatch")
    public R deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        return R.data(this.callSmsNoticeTaskService.removeByIds(Arrays.asList(ids.split(","))));
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "外呼短信通知任务-通过id查询", notes = "外呼短信通知任务-通过id查询")
    @GetMapping(value = "/queryById")
    public R queryById(@RequestParam(name = "id", required = true) String id) {
        CallSmsNoticeTask callSmsNoticeTask = callSmsNoticeTaskService.getById(id);
        return R.data(callSmsNoticeTask);
    }

}

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/feign/OutCallImplImplClient.java

@@ -3,6 +3,7 @@
import cn.gistack.sm.intelligentCall.entity.CallNotFillRecord;
import cn.gistack.sm.intelligentCall.service.CallService;
import cn.gistack.sm.intelligentCall.service.ICallNotFillRecordService;
import cn.gistack.sm.intelligentCall.service.ICallSmsNoticeTaskService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -27,6 +28,8 @@
    private final CallService callService;

    private final ICallNotFillRecordService callNotFillerService;

    private final ICallSmsNoticeTaskService callSmsNoticeTaskService;

    @Override
    @GetMapping(CREATE_OUT_CALL_TASK_JOB_HANDLER)
@@ -55,6 +58,8 @@
        map.put("taskScheduleTime",taskScheduleTime);
        map.put("personNumber",personNumber);
        map.put("day",day);
        //外呼短信通知任务创建并返回
        callSmsNoticeTaskService.createCallSmsNoticeTask("2216");
        // 创建定时任务并返回
        return "测试返回成功";
    }
@@ -84,4 +89,16 @@
        // 创建定时任务并返回
        return callNotFillerService.getOne(new QueryWrapper<CallNotFillRecord>().eq("call_id",callId));
    }

    /**
     * 外呼短信通知任务创建
     * @param taskId 外呼任务id
     * @return
     */
    @Override
    @GetMapping(CREATE_CALL_SMS_NOTICE_TASK)
    public Boolean createCallSmsNoticeTask(String taskId) {
        //外呼短信通知任务创建并返回
        return callSmsNoticeTaskService.createCallSmsNoticeTask(taskId);
    }
}

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/mapper/CallSmsNoticeTaskMapper.java

New file
@@ -0,0 +1,33 @@
package cn.gistack.sm.intelligentCall.mapper;

import cn.gistack.sm.intelligentCall.entity.CallSmsNoticeTask;
import cn.gistack.sm.intelligentCall.vo.CallSmsNoticeTaskVO;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.apache.ibatis.annotations.Param;
import java.util.List;

/**
 * @author zhongrj
 * @date 2023-06-28
 */
public interface CallSmsNoticeTaskMapper extends BaseMapper<CallSmsNoticeTask> {

    /**
     * 自定义分页列表查询
     * @param page
     * @param callSmsNoticeTask
     * @return
     */
    List<CallSmsNoticeTaskVO> selectCallSmsNoticeTaskPage(@Param("page")IPage<CallSmsNoticeTaskVO> page,
                                                          @Param("callNotFillRecord") CallSmsNoticeTaskVO callSmsNoticeTask);

    /**
     * 通过外呼任务id 查询任务调度时间
     * @param taskId
     * @return
     */
    @DS("znwh")
    String getTaskScheduleTimeByTaskId(@Param("taskId") String taskId);
}

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/mapper/CallSmsNoticeTaskMapper.xml

New file
@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.gistack.sm.intelligentCall.mapper.CallSmsNoticeTaskMapper">

    <!--自定义分页列表查询-->
    <select id="selectCallSmsNoticeTaskPage" resultType="cn.gistack.sm.intelligentCall.vo.CallSmsNoticeTaskVO">
        select * from YWXT.sm_call_sms_notice_task
        where 1=1
        order by id desc
    </select>

    <!--通过外呼任务id 查询任务调度时间-mysql-->
    <select id="getTaskScheduleTimeByTaskId" resultType="java.lang.String">
        select task_schedule_time from call_task where id = #{taskId}
    </select>

</mapper>

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/mapper/CallTaskMapper.xml

@@ -407,7 +407,13 @@

    <!--查询未接通，拒接的呼叫结果详情列表信息-->
    <select id="getCallNotConnectResultList" resultType="cn.gistack.sm.intelligentCall.vo.CallTaskStatistic">
        select b.*,aab."guid",aab."ad_grad",aab."p_ad_code",aab."ad_name" as adName,bu.real_name as realName,arb."name" as waterName
        select
        b.*,
        aab."guid",aab."ad_grad",aab."p_ad_code",aab."ad_name" as adName,
        bu.real_name as realName,
        REGEXP_SUBSTR (arb."res_loc",'[^-]+',1,2) as cityName,
        REGEXP_SUBSTR (arb."res_loc",'[^-]+',1,3) as countyName,
        arb."name" as waterName
        from (
        select "callee_number",waterCodes,LENGTH(waterCodes)- LENGTH(REPLACE(waterCodes,',','')) num from (
        select  ctr."callee_number",WM_Concat(ctc.waterCode) waterCodes from (

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/service/ICallSmsNoticeTaskService.java

New file
@@ -0,0 +1,28 @@
package cn.gistack.sm.intelligentCall.service;

import cn.gistack.sm.intelligentCall.entity.CallSmsNoticeTask;
import cn.gistack.sm.intelligentCall.vo.CallSmsNoticeTaskVO;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @author zhongrj
 * @date 2023-06-13
 */
public interface ICallSmsNoticeTaskService extends IService<CallSmsNoticeTask> {

    /**
     * 自定义分页列表查询
     * @param page
     * @param callSmsNoticeTask
     * @return
     */
    IPage<CallSmsNoticeTaskVO> selectCallSmsNoticeTaskPage(IPage<CallSmsNoticeTaskVO> page, CallSmsNoticeTaskVO callSmsNoticeTask);

    /**
     * 外呼短信通知任务创建
     * @param taskId 外呼任务id
     * @return
     */
    Boolean createCallSmsNoticeTask(String taskId);
}

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/service/impl/CallServiceImpl.java

@@ -8,6 +8,9 @@
import cn.gistack.sm.intelligentCall.service.CallService;
import cn.gistack.sm.intelligentCall.vo.CallTaskResultVO;
import cn.gistack.sm.intelligentCall.vo.CallTaskStatistic;
import cn.gistack.sm.sjztmd.entity.AttAdBase;
import cn.gistack.sm.sjztmd.service.IAttAdBaseService;
import cn.gistack.sm.sjztmd.vo.AttAdBaseVO;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
@@ -24,6 +27,7 @@
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
@@ -40,6 +44,9 @@

    @Autowired
    private CallTaskMapper callTaskMapper;

    @Autowired
    private IAttAdBaseService attAdBaseService;

    @Autowired
    private RestTemplate restTemplate;
@@ -302,13 +309,17 @@
            CompletableFuture.allOf(callTaskStatisticCompletableFuture,threeDayNotCallConnect,twoDayNotCallConnect,oneDayNotCallConnect).get();
            // 数据处理
            List<CallTaskStatistic> callTaskStatistics = getCallTaskStatistics(callTaskStatisticCompletableFuture, oneDay, threeDayNotCallConnect, twoDayNotCallConnect, oneDayNotCallConnect);
            // 取当前行政区总数据
            List<CallTaskStatistic> totalList = getTotalCallTaskStatistics(callTaskStatistics,callTaskStatistic);
            // 排序
            callTaskStatistics = getCallTaskStatisticsByOrder(callTaskStatistic, callTaskStatistics);
            // 合并数据
            totalList.addAll(callTaskStatistics);
            // 返回数据
            if (null!= callTaskStatistic.getIsPage()) {
                return callTaskStatistics;
                return totalList;
            }else {
                return page.setRecords(callTaskStatistics);
                return page.setRecords(totalList);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
@@ -317,6 +328,52 @@
        }
        // 返回
        return null;
    }

    /**
     * 获取当前行政区总数据
     * @param callTaskStatistics
     * @param callTaskStatisticEntity
     * @return
     */
    private List<CallTaskStatistic> getTotalCallTaskStatistics(List<CallTaskStatistic> callTaskStatistics,CallTaskStatistic callTaskStatisticEntity) {
        List<CallTaskStatistic> statistics = new ArrayList<>();
        CallTaskStatistic callTaskStatistic = new CallTaskStatistic();
        Integer totalCalleeNumberCount = 0;
        Integer totalConnectionCount = 0;
        Integer totalThreeNoConnectCount = 0;
        Integer totalTwoNoConnectCount = 0;
        Integer totalRefuseConnectCount = 0;
        // 遍历
        for (CallTaskStatistic taskStatistic : callTaskStatistics) {
            totalCalleeNumberCount += Integer.parseInt(taskStatistic.getCalleeNumberCount());
            totalConnectionCount += Integer.parseInt(taskStatistic.getConnectionCount());
            totalThreeNoConnectCount += taskStatistic.getThreeNoConnectCount();
            totalTwoNoConnectCount += taskStatistic.getTwoNoConnectCount();
            totalRefuseConnectCount += taskStatistic.getRefuseConnectCount();
        }
        // 设置数据
        callTaskStatistic.setCalleeNumberCount(totalCalleeNumberCount.toString());
        callTaskStatistic.setConnectionCount(totalConnectionCount.toString());
        callTaskStatistic.setThreeNoConnectCount(totalThreeNoConnectCount);
        callTaskStatistic.setTwoNoConnectCount(totalTwoNoConnectCount);
        callTaskStatistic.setRefuseConnectCount(totalRefuseConnectCount);
        callTaskStatistic.setCreateTime(callTaskStatistics.get(0).getCreateTime());
        // 查询当前行政区名称
        AttAdBase attAdBase = new AttAdBase();
        attAdBase.setGuid(callTaskStatisticEntity.getAdCode());
        AttAdBaseVO detail = attAdBaseService.getDetail(attAdBase);
        callTaskStatistic.setAdCode(callTaskStatisticEntity.getAdCode());
        if (null != detail){
            callTaskStatistic.setAdName(detail.getAdName());
        }
        // 计算比例
        //格式化小数
        DecimalFormat df = new DecimalFormat("0.00");
        callTaskStatistic.setCallCompletingRate(df.format((float)totalConnectionCount/totalCalleeNumberCount*100));
        statistics.add(callTaskStatistic);
        // 返回
        return statistics;
    }

    /**
@@ -366,6 +423,7 @@
                List<CallTaskStatistic> outgoingStatisticList = new ArrayList<>();
                // 判断是否分页
                if (null!= callTaskStatistic.getIsPage()){
                    // 不分页
                    outgoingStatisticList = callTaskMapper.getOutgoingStatisticList(null,callTaskStatistic,null);
                }else {
                    // 按天查询数据

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/intelligentCall/service/impl/CallSmsNoticeTaskServiceImpl.java

New file
@@ -0,0 +1,75 @@
package cn.gistack.sm.intelligentCall.service.impl;

import cn.gistack.sm.intelligentCall.entity.CallSmsNoticeTask;
import cn.gistack.sm.intelligentCall.mapper.CallSmsNoticeTaskMapper;
import cn.gistack.sm.intelligentCall.service.ICallSmsNoticeTaskService;
import cn.gistack.sm.intelligentCall.vo.CallSmsNoticeTaskVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author zhongrj
 * @date 2023-06-13
 */
@Service
public class CallSmsNoticeTaskServiceImpl extends ServiceImpl<CallSmsNoticeTaskMapper, CallSmsNoticeTask> implements ICallSmsNoticeTaskService {

    /**
     * 自定义分页列表查询
     * @param page
     * @param callSmsNoticeTask
     * @return
     */
    @Override
    public IPage<CallSmsNoticeTaskVO> selectCallSmsNoticeTaskPage(IPage<CallSmsNoticeTaskVO> page, CallSmsNoticeTaskVO callSmsNoticeTask) {
        return page.setRecords(baseMapper.selectCallSmsNoticeTaskPage(page,callSmsNoticeTask));
    }

    /**
     * 外呼短信通知任务创建
     * @param taskId 外呼任务id
     * @return
     */
    @Override
    public Boolean createCallSmsNoticeTask(String taskId) {
        boolean flag = false;
        CallSmsNoticeTask callSmsNoticeTask = new CallSmsNoticeTask();
        // 判断已插入，防止重复插入的情况
        CallSmsNoticeTask notFillRecord = getOne(new QueryWrapper<CallSmsNoticeTask>().eq("task_id", taskId));
        if (notFillRecord != null){
            return false;
        }
        // 通过外呼任务id 查询任务调度时间
        String scheduleTime = baseMapper.getTaskScheduleTimeByTaskId(taskId);
        // 从调度时间开始往后加2个小时，为结束时间
        if(null!= scheduleTime && !scheduleTime.equals("")){
            long l = 0;
            try {
                l = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(scheduleTime).getTime();
            } catch (ParseException e) {
                e.printStackTrace();
            }
            long m = 2*60*60*1000;
            // 相减得到时间
            Long x = l+m;
            // 设置信息
            callSmsNoticeTask.setTaskId(Integer.parseInt(taskId));
            callSmsNoticeTask.setCreateTime(new Date());
            callSmsNoticeTask.setCreateUser(AuthUtil.getUserId());
            callSmsNoticeTask.setStartTime(new Date(l));
            callSmsNoticeTask.setEndTime(new Date(x));
            // 新增
            flag = save(callSmsNoticeTask);
        }
        return flag;
    }
}

 skjcmanager/skjcmanager-service/skjcmanager-xxljob/src/main/java/cn/gistack/job/executor/jobhandler/OutCallXxlJob.java

@@ -27,9 +27,6 @@
    @Autowired
    private OutCallClient outCallClient;

    @Autowired
    private IXxlJobInfoService xxlJobInfoService;

    /**
     * 智能外呼定时创建任务执行器
     * @param param
@@ -47,30 +44,27 @@
        // 创建外呼任务
        List<String> result = outCallClient.createOutCallTaskJobHandler(isOver,taskScheduleTime,personNumber, day);
        XxlJobLogger.log("任务响应结果..." + result);
        if (result.get(2).equals("true")) {
            Integer jobId = 11;
            // 获取任务id
            String taskId = result.get(1);
            // 修改定时任务
            XxlJobInfo jobInfo = xxlJobInfoService.getById(jobId);
            // 解析参数
            Map mapParams = (Map) jobInfo.getExecutorParam();
            String time = mapParams.get("time").toString();
            XxlJobInfoVO xxlJobInfo = new XxlJobInfoVO();
            xxlJobInfo.setId(jobId);
            Map<String, Object> map = new HashMap<>(2);
            map.put("taskId", taskId);
            map.put("time", time);
            xxlJobInfo.setExecutorParam(map);
            Object o = xxlJobInfoService.updateXxlJobById(xxlJobInfo);
            if (Boolean.parseBoolean(o.toString())) {
                XxlJobLogger.log("外呼未接通短信通知定时任务修改成功！任务ID:" + taskId);
            }else {
                XxlJobLogger.log("外呼未接通短信通知定时任务修改失败！任务ID:" + taskId);
            }
        }
        // 创建外呼短信发送任务记录
        Boolean flag = createCallSmsNoticeTask(result);
        XxlJobLogger.log("外呼短信通知任务创建结果:" + flag);
        XxlJobLogger.log("结束自动创建任务...");
        return ReturnT.SUCCESS;
    }

    /**
     * 创建外呼短信发送任务记录
     * @param result
     */
    private Boolean createCallSmsNoticeTask(List<String> result) {
        Boolean flag = false;
        if (null != result && result.size() > 0) {
            if (result.get(2).equals("true")) {
                // 获取任务id
                String taskId = result.get(1);
                flag = outCallClient.createCallSmsNoticeTask(taskId);
            }
        }
        return flag;
    }

    /**
@@ -86,31 +80,10 @@
        String taskScheduleTime = jsonParam.getString("taskScheduleTime");
        // 创建外呼任务
        List<String> result = outCallClient.createOutCallTaskByNotConnectJobHandler(taskScheduleTime);
        if (null != result && result.size() > 0) {
            if (result.get(2).equals("true")) {
                Integer jobId = 14;
                // 获取任务id
                String taskId = result.get(1);
                // 修改定时任务（前一天未接通今天又呼叫未接的短息通知）
                XxlJobInfo jobInfo = xxlJobInfoService.getById(jobId);
                // 解析参数
                Map mapParams = (Map) jobInfo.getExecutorParam();
                String time = mapParams.get("time").toString();
                XxlJobInfoVO xxlJobInfo = new XxlJobInfoVO();
                xxlJobInfo.setId(jobId);
                Map<String, Object> map = new HashMap<>(2);
                map.put("taskId", taskId);
                map.put("time", time);
                xxlJobInfo.setExecutorParam(map);
                Object o = xxlJobInfoService.updateXxlJobById(xxlJobInfo);
                if (Boolean.parseBoolean(o.toString())) {
                    XxlJobLogger.log("外呼未接通短信通知定时任务修改成功！任务ID:" + taskId);
                } else {
                    XxlJobLogger.log("外呼未接通短信通知定时任务修改失败！任务ID:" + taskId);
                }
            }
        }
        XxlJobLogger.log("任务响应结果..." + result);
        // 创建外呼短信发送任务记录
        Boolean flag = createCallSmsNoticeTask(result);
        XxlJobLogger.log("外呼短信通知任务创建结果:" + flag);
        XxlJobLogger.log("结束自动创建任务...");
        return ReturnT.SUCCESS;
    }
@@ -121,17 +94,17 @@
     * @return
     * @throws Exception
     */
    @XxlJob("testOutCall")
    @XxlJob("testOutCall_0628")
    public ReturnT<String> testOutCall(String param){
        XxlJobLogger.log("开始执行任务...");
//        JSONObject jsonParam = JSON.parseObject(param);
        JSONObject jsonParam = JSON.parseObject(param);
//        String isOver = jsonParam.getString("isOver");
//        String taskScheduleTime = jsonParam.getString("taskScheduleTime");
//        String personNumber = jsonParam.getString("personNumber");
//        String day = jsonParam.getString("day");
        // 创建外呼任务
//        Object result = outCallClient.testOutCall(isOver,taskScheduleTime,personNumber, day);
//        XxlJobLogger.log("任务响应结果：" + result);
        Object result = outCallClient.testOutCall("","","", "");
        XxlJobLogger.log("任务响应结果：" + result);
        XxlJobLogger.log("结束自动创建任务...");
        return ReturnT.SUCCESS;
    }

 skjcmanager/skjcmanager-service/skjcmanager-xxljob/src/main/java/cn/gistack/job/executor/jobhandler/SendSmsXxlJob.java

@@ -33,17 +33,6 @@
        return getStringReturnT(param);
    }

    /**
     * 外呼前一天未接通呼叫又未接通-发送短信(调度时间不一致，参数不一致)
     * @param param
     * @return
     * @throws Exception
     */
    @XxlJob("sendSmsByBeforeOneDayOutCallNotConnect")
    public ReturnT<String> sendSmsByBeforeOneDayOutCallNotConnect(String param){
        return getStringReturnT(param);
    }

    @NotNull
    private ReturnT<String> getStringReturnT(String param) {
        XxlJobLogger.log("开始执行任务...");