Merge branch 'wq1' of SH-Arbitrate/Mediation-Backend into dev

ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysMenuController.java

 package com.ruoyi.web.controller.system;
 
-import java.util.List;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.DeleteMapping;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.PutMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
 import com.ruoyi.common.annotation.Log;
 import com.ruoyi.common.constant.UserConstants;
 import com.ruoyi.common.core.controller.BaseController;
 import com.ruoyi.common.enums.BusinessType;
 import com.ruoyi.common.utils.StringUtils;
 import com.ruoyi.system.service.ISysMenuService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
 
 /**
  * 菜单信息
         }
         return toAjax(menuService.deleteMenuById(menuId));
     }
+    /**
+     * 根据用户查询菜单权限字符
+     */
+   @GetMapping("/getMenuPermsByUser")
+    public AjaxResult getMenuPermsByUser()
+    {
+
+        return menuService.getMenuPermsByUser();
+    }
 }

ruoyi-admin/src/main/java/com/ruoyi/web/controller/wisdomarbitrate/miniprogress/WeChatUserController.java

         }
         return weChatUserService.sendCode(userVO);
     }
+    /**
+     * 获取邮箱验证码
+     * @param email
+     * @return
+     */
+    @Anonymous
+    @GetMapping("/sendEmailCode")
+    public AjaxResult sendEmailCode(  @RequestParam("email") String email)
+    {
+        return weChatUserService.sendEmailCode(email);
+    }
     @Anonymous
     @GetMapping("/roles")
     public AjaxResult roles()

ruoyi-admin/src/main/java/com/ruoyi/web/controller/wisdomarbitrate/mscase/MsCaseApplicationController.java

 import com.ruoyi.common.core.page.TableDataInfo;
 import com.ruoyi.common.exception.EsignDemoException;
 import com.ruoyi.common.utils.IdCardUtils;
-import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
 import com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseApplication;
 import com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseAttach;
 import com.ruoyi.wisdomarbitrate.domain.vo.mscase.*;
     /**
      * 新增案件
      */
-    // todo 重复提交校验
     @PostMapping("/insert")
     public AjaxResult insert(@RequestBody MsCaseApplicationVO caseApplication )
     {
-        if( caseApplication.getAffiliate()==null|| caseApplication.getOrganizeFlag()==null){
+        if( caseApplication.getAffiliate()==null){
             error("参数校验失败");
         }
         AjaxResult ajaxResult = AjaxResult.success();
 
         return  success(videoService.reserveConferenceList(caseId));
     }
-    /**
-     * 查询短信发送记录
-     * @param smsSendRecord
-     * @return
-     */
-    @PostMapping("/smsRecord")
-    public TableDataInfo getSmsSendRecord(@RequestBody SmsSendRecord smsSendRecord){
-        startPage();
-        List<SmsSendRecord> list = caseApplicationService.getSmsSendRecord(smsSendRecord);
-        return getDataTable(list);
-    }
+
     /**
      * 保存onlyOffice在线编辑的文件
      * @param

ruoyi-admin/src/main/java/com/ruoyi/web/controller/wisdomarbitrate/mscase/MsVideoConferenceController.java

                 .useId(SecurityUtils.getUserId())
                 .useAccount(SecurityUtils.getUsername())
                 .build();
+        // 先删除之前的附件
+        msCaseAttachMapper.deleteCaseAttachByCasedIdAndType(caseId,annexType);
         msCaseAttachMapper.save(caseAttach);
         return caseAttach.getAnnexId();
     }

ruoyi-admin/src/main/java/com/ruoyi/web/controller/wisdomarbitrate/sendrecord/ShortMessageController.java

 package com.ruoyi.web.controller.wisdomarbitrate.sendrecord;
 
+import cn.hutool.core.collection.CollectionUtil;
 import com.ruoyi.common.annotation.Anonymous;
+import com.ruoyi.common.core.controller.BaseController;
 import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.common.core.page.TableDataInfo;
+import com.ruoyi.system.domain.entity.sms.MsSmsSendRecordParam;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam;
+import com.ruoyi.system.mapper.sms.MsSmsSendHistoryRecordParamMapper;
+import com.ruoyi.system.mapper.sms.MsSmsSendRecordParamMapper;
 import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
 import com.ruoyi.wisdomarbitrate.domain.vo.shortmessage.ReSendMessageVO;
 import com.ruoyi.wisdomarbitrate.mapper.sendrecord.SmsRecordMapper;
 import com.ruoyi.wisdomarbitrate.service.shortmessage.ShortMessageService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
+import tk.mybatis.mapper.entity.Example;
 
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.List;
 
 @RestController
 @RequestMapping("/shortMessage")
-public class ShortMessageController {
+public class ShortMessageController extends BaseController {
     @Autowired
     private SmsRecordMapper smsRecordMapper;
     @Autowired
     private ShortMessageService shortMessageService;
+    @Autowired
+    MsSmsSendRecordParamMapper recordParamMapper;
+    @Autowired
+    MsSmsSendHistoryRecordParamMapper historyRecordParamMapper;
+    /**
+     * 查询短信发送记录
+     * @param smsSendRecord
+     * @return
+     */
+    @GetMapping("/recordList")
+    public TableDataInfo smsSendRecordList( SmsSendRecord smsSendRecord){
+        startPage();
+        List<SmsSendRecord> list = shortMessageService.smsSendRecordList(smsSendRecord);
+        return getDataTable(list);
+    }
 
     @Anonymous
     @PostMapping("/updateSendContent")
     public AjaxResult update(@RequestBody SmsSendRecord smsSendRecord) {
-        if (smsSendRecord != null && smsSendRecord.getId() != null) {
-            SmsSendRecord oldSendRecord = smsRecordMapper.selectById(smsSendRecord.getId());
-            smsSendRecord.setUpdateTime(new Date());
-            smsRecordMapper.updateSendContent(smsSendRecord);
-            shortMessageService.insertShortMessageHistoryRecord(oldSendRecord);
-            return AjaxResult.success();
+        if(smsSendRecord == null|| smsSendRecord.getId() == null || CollectionUtil.isEmpty(smsSendRecord.getTemplateParams())){
+            return AjaxResult.error("参数校验失败");
+        }
+             // 查询当前版本记录
+        SmsSendRecord oldSendRecord = smsRecordMapper.selectById(smsSendRecord.getId());
+        smsSendRecord.setUpdateTime(new Date());
+            //  更新短信内容，先删除短信记录参数表
+            Example recordParamExam = new Example(MsSmsSendRecordParam.class);
+            recordParamExam.createCriteria().andEqualTo("smsRecordId", smsSendRecord.getId());
+            recordParamMapper.deleteByExample(recordParamExam);
+            // 新增短信记录参数表
+        List<MsSmsSendRecordParam> recordParams = new ArrayList<>();
+        for (MsSmsTemplateParam templateParam : smsSendRecord.getTemplateParams()) {
+            MsSmsSendRecordParam recordParam = new MsSmsSendRecordParam();
+            recordParam.setSmsRecordId(smsSendRecord.getId());
+            recordParam.setParamValue(templateParam.getParamValue());
+            recordParams.add(recordParam);
         }
-        return AjaxResult.error("更新失败");
+            recordParamMapper.batchInsert(recordParams);
+            shortMessageService.insertShortMessageHistoryRecord(oldSendRecord,recordParams);
+            return AjaxResult.success();
+
     }
 
     /**

ruoyi-admin/src/main/java/com/ruoyi/web/controller/wisdomarbitrate/sms/SMSTemplateController.java

+package com.ruoyi.web.controller.wisdomarbitrate.sms;
+
+import com.ruoyi.common.core.controller.BaseController;
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.common.core.page.TableDataInfo;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplate;
+import com.ruoyi.wisdomarbitrate.service.sms.SMSTemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 短信模板控制器
+ */
+@RestController
+@RequestMapping("/smsTemplate")
+public class SMSTemplateController extends BaseController {
+    @Autowired
+    private SMSTemplateService templateService;
+
+    /**
+     * 查询
+     * @param
+     * @return
+     */
+    @GetMapping("/page")
+    public TableDataInfo page( ){
+        startPage();
+        List<MsSmsTemplate> list = templateService.page();
+        return getDataTable(list);
+    }
+    /**
+     * 新增或者修改
+     * @param
+     * @return
+     */
+    @PostMapping("/insert")
+    public AjaxResult insert(@RequestBody MsSmsTemplate template){
+        return templateService.insert(template);
+    }
+    /**
+     * 删除
+     * @param
+     * @return
+     */
+    @PostMapping("/delete")
+    public AjaxResult delete(@RequestBody MsSmsTemplate template){
+        if(template.getId()==null){
+            return AjaxResult.warn("id不能为空");
+        }
+        return templateService.delete(template.getId());
+    }
+
+}

ruoyi-common/src/main/java/com/ruoyi/common/constant/CacheConstants.java

      */
     public static final String PWD_ERR_CNT_KEY = "pwd_err_cnt:";
     public static final String  WE_CHAT_SMS_VERIFY_CODE_KEY="we_chat_sms_verify_code:";
+    public static final String  EMAIL_VERIFY_CODE_KEY="email_verify_code:";
     /**
      * 案件 redis key
      */

ruoyi-common/src/main/java/com/ruoyi/common/constant/UserConstants.java

      * 用户名长度限制
      */
     public static final int USERNAME_MIN_LENGTH = 2;
-    public static final int USERNAME_MAX_LENGTH = 20;
+    public static final int USERNAME_MAX_LENGTH = 50;
 
     /**
      * 密码长度限制

ruoyi-common/src/main/java/com/ruoyi/common/utils/EmailOutUtil.java

 //    private static String fromOut;
     @Value("${spring.mail.host}")
     private String hostOut;
-//    @Value("${spring.mail.username}")
-//    private String usernameOut;
-    private String usernameOut="wq18792927508@163.com";
-//    @Value("${spring.mail.password}")
-//    private String passwordOut;
-    private String passwordOut= "WDFHKSEMCKVRELEA";
+    @Value("${spring.mail.username}")
+    private String usernameOut;
+
+    @Value("${spring.mail.password}")
+    private String passwordOut;
+
     @Value("${spring.mail.port}")
     private Integer portOut;
 
     public Boolean sendMessage(String to, String subject, String content, String from, JavaMailSender mailSender) {
         try {
             if(mailSender==null){
-                rebuildMailSender();
+                mailSender=  rebuildMailSender();
             }
             // 创建一个邮件对象
             SimpleMailMessage msg = new SimpleMailMessage();
             return false;
         }
         return true;
-        ////System.out.println("发送成功：" + from + ":to:" + to);
     }
 
     /**

ruoyi-common/src/main/java/com/ruoyi/common/utils/SmsUtils.java

-package com.ruoyi.common.utils;
-
-import cn.hutool.json.JSONObject;
-import com.ruoyi.common.enums.SMSStatusEnum;
-import com.tencentcloudapi.common.Credential;
-import com.tencentcloudapi.common.exception.TencentCloudSDKException;
-import com.tencentcloudapi.sms.v20210111.SmsClient;
-import com.tencentcloudapi.sms.v20210111.models.SendSmsResponse;
-import com.tencentcloudapi.sms.v20210111.models.SendStatus;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import lombok.var;
-
-import java.util.Objects;
-
-@Slf4j
-public class SmsUtils {
-    //应用id
-    private static final String SDK_APP_ID = "1400854852";
-    //API的SecretId
-    private static final String SECRET_ID = "AKIDeEf2A8uX1HSainvvnXAc3X9ZlhtyvkMp";
-    //API的SecretKey
-    private static final String SECRET_KEY = "QjphKo8zkHZigT8j9PVtFPJyfIvO3d6V";
-    //签名内容
-    private static final String SIGN_NAME = "乙巢智慧仲裁网";
-
-    public static JSONObject sendSms(SendSmsRequest request) {
-        JSONObject jsonObject = new JSONObject();
-        Credential cred = new Credential(SECRET_ID, SECRET_KEY );
-
-        SmsClient client = new SmsClient(cred, "ap-guangzhou");
-
-        final var req = new com.tencentcloudapi.sms.v20210111.models.SendSmsRequest();
-        req.setPhoneNumberSet(new String[]{"+86" + request.getPhone()});
-        req.setSmsSdkAppId(SDK_APP_ID );
-        req.setSignName(SIGN_NAME);
-        req.setTemplateId(request.getTemplateId());
-        req.setTemplateParamSet(request.getTemplateParamSet());
-        SendSmsResponse res = null;
-        try {
-            res = client.SendSms(req);
-        } catch (TencentCloudSDKException e) {
-            log.error("发送短信出错：", e);
-            jsonObject.set("status", SMSStatusEnum.FAIL.getCode());
-            return jsonObject;
-        }
-        SendStatus sendStatus = res.getSendStatusSet()[0];
-        log.info("发送短信结果：Code={}, Message={}", sendStatus.getCode(), sendStatus.getMessage());
-
-        if (Objects.nonNull(res.getSendStatusSet()) && res.getSendStatusSet().length > 0 && "Ok".equals(res.getSendStatusSet()[0].getCode())){
-            jsonObject.set("status", SMSStatusEnum.SENDING.getCode());
-        }else {
-            jsonObject.set("status", SMSStatusEnum.FAIL.getCode());
-        }
-        jsonObject.set("sid", sendStatus.getSerialNo());
-        return jsonObject;
-    }
-    public static JSONObject sendSms(Long caseId,String templateId,String phone,String[] templateParamSet) {
-        JSONObject jsonObject = new JSONObject();
-        SendSmsRequest request = new SendSmsRequest(phone,templateId,templateParamSet,caseId);
-        Credential cred = new Credential(SECRET_ID, SECRET_KEY );
-
-        SmsClient client = new SmsClient(cred, "ap-guangzhou");
-
-        final var req = new com.tencentcloudapi.sms.v20210111.models.SendSmsRequest();
-        req.setPhoneNumberSet(new String[]{"+86" + request.getPhone()});
-        req.setSmsSdkAppId(SDK_APP_ID );
-        req.setSignName(SIGN_NAME);
-        req.setTemplateId(request.getTemplateId());
-        req.setTemplateParamSet(request.getTemplateParamSet());
-        SendSmsResponse res = null;
-        try {
-            res = client.SendSms(req);
-        } catch (TencentCloudSDKException e) {
-            jsonObject.set("status", SMSStatusEnum.FAIL.getCode());
-            return jsonObject;
-        }
-        SendStatus sendStatus = res.getSendStatusSet()[0];
-        log.info("发送短信结果：Code={}, Message={}", sendStatus.getCode(), sendStatus.getMessage());
-        // todo 短信发送时，需要将SerialNo存到数据库，在短信回调时去更新短信发送状态，以及失败原因写到数据库，发送时状态统一为发送中
-        if (Objects.nonNull(res.getSendStatusSet()) && res.getSendStatusSet().length > 0 && "Ok".equals(res.getSendStatusSet()[0].getCode())){
-            jsonObject.set("status", SMSStatusEnum.SENDING.getCode());
-        }else {
-            jsonObject.set("status", SMSStatusEnum.FAIL.getCode());
-        }
-        jsonObject.set("sid", sendStatus.getSerialNo());
-        return jsonObject;
-    }
-    /**
-     * 参数对象
-     */
-    @Data
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public static class SendSmsRequest {
-        /**
-         * 电话
-         */
-        private String phone;
-
-        /**
-         * 模板 ID: 必须填写已审核通过的模板 ID
-         */
-        private String templateId;
-
-        /**
-         * 模板参数: 模板参数的个数需要与 TemplateId 对应模板的变量个数保持一致，若无模板参数，则设置为空
-         */
-        private String[] templateParamSet;
-        private Long caseId;
-
-    }
-}

ruoyi-common/src/main/java/com/ruoyi/common/utils/WordUtil.java

 package com.ruoyi.common.utils;
 
 
-import cn.hutool.core.io.resource.ClassPathResource;
 import com.deepoove.poi.XWPFTemplate;
 import com.deepoove.poi.config.Configure;
 import com.deepoove.poi.data.*;
 import com.deepoove.poi.data.style.ParagraphStyle;
 import com.deepoove.poi.data.style.Style;
-import com.deepoove.poi.policy.PictureRenderPolicy;
 import com.deepoove.poi.util.PoitlIOUtils;
-import org.apache.commons.io.FileUtils;
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.CellType;
-import org.apache.poi.ss.usermodel.Row;
-import org.apache.poi.ss.usermodel.Sheet;
-import org.apache.poi.wp.usermodel.Paragraph;
 import org.apache.poi.xwpf.usermodel.*;
 
-import javax.print.Doc;
-import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import java.io.*;
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
         }
     }
 
+    /**
+     * 替换标签内容
+     * @param map
+     * @param templatePath 模板路径
+     * @param outputPath 文件输出路径
+     */
+    public static void render(Map<String, Object> map,String templatePath,String outputPath){
+        XWPFTemplate template = XWPFTemplate.compile(templatePath).render(map);
+        try {
+            FileOutputStream out = new FileOutputStream(outputPath);
+            template.write(out);
+            out.flush();
+            out.close();
+            template.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
 
 
 }

ruoyi-system/src/main/java/com/ruoyi/system/domain/entity/log/MsRequestLog.java

+
 package com.ruoyi.system.domain.entity.log;
 
 import lombok.Getter;

ruoyi-system/src/main/java/com/ruoyi/system/domain/entity/shortmessage/MsSmsSendHistoryRecord.java

 package com.ruoyi.system.domain.entity.shortmessage;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.Table;
 import java.util.Date;
-import javax.persistence.*;
-
-import lombok.*;
 
 @Data
 @AllArgsConstructor
      */
     @Column(name = "case_appli_id")
     private Long caseAppliId;
+    /**
+     * 短信模板表主键id
+     */
+    @Column(name = "ms_sms_template_id")
+    private Long msSmsTemplateId;
 
     /**
      * 案件编号
     @Column(name = "send_status")
     private Long sendStatus;
 
-    /**
-     * 发送内容
-     */
-    @Column(name = "send_content")
-    private String sendContent;
 
     /**
      * 创建时间

ruoyi-system/src/main/java/com/ruoyi/system/domain/entity/sms/MsSmsSendHistoryRecordParam.java

+package com.ruoyi.system.domain.entity.sms;
+
+import javax.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString
+@Table(name = "ms_sms_send_history_record_param")
+public class MsSmsSendHistoryRecordParam {
+    @Id
+    @GeneratedValue(generator = "JDBC")
+    private Long id;
+
+    /**
+     * 短信历史记录表id
+     */
+    @Column(name = "sms_record_history_id")
+    private Long smsRecordHistoryId;
+
+    /**
+     * 参数值
+     */
+    @Column(name = "param_value")
+    private String paramValue;
+}

ruoyi-system/src/main/java/com/ruoyi/system/domain/entity/sms/MsSmsSendRecordParam.java

+package com.ruoyi.system.domain.entity.sms;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import javax.persistence.Column;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Getter
+@Setter
+@ToString
+@Table(name = "ms_sms_send_record_param")
+public class MsSmsSendRecordParam {
+    @Id
+    @GeneratedValue(generator = "JDBC")
+    private Integer id;
+
+    /**
+     * 短信记录表id
+     */
+    @Column(name = "sms_record_id")
+    private Long smsRecordId;
+
+
+    /**
+     * 参数值
+     */
+    @Column(name = "param_value")
+    private String paramValue;
+}

ruoyi-system/src/main/java/com/ruoyi/system/domain/entity/sms/MsSmsTemplate.java

+package com.ruoyi.system.domain.entity.sms;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import javax.persistence.*;
+import java.util.List;
+
+@Getter
+@Setter
+@ToString
+@Table(name = "ms_sms_template")
+public class MsSmsTemplate {
+    @Id
+    @GeneratedValue(generator = "JDBC")
+    private Long id;
+
+    /**
+     * 腾讯云模板id
+     */
+    @Column(name = "template_id")
+    private String templateId;
+
+    /**
+     * 模板名称
+     */
+    private String name;
+    /**
+     * 模板内容
+     */
+    private String content;
+    /**
+     * 模板参数
+     */
+    @Transient
+    private List<MsSmsTemplateParam> templateParams;
+}

ruoyi-system/src/main/java/com/ruoyi/system/domain/entity/sms/MsSmsTemplateParam.java

+package com.ruoyi.system.domain.entity.sms;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import javax.persistence.*;
+
+@Getter
+@Setter
+@ToString
+@Table(name = "ms_sms_template_param")
+public class MsSmsTemplateParam {
+    @Id
+    @GeneratedValue(generator = "JDBC")
+    private Long id;
+
+    /**
+     * ms_sms_template表id
+     */
+    @Column(name = "sms_template_id")
+    private Long smsTemplateId;
+
+    /**
+     * 参数
+     */
+    private String param;
+    /**
+     * 参数名
+     */
+    @Column(name = "param_name")
+    private String paramName;
+    /**
+     * 参数值
+     */
+    @Transient
+    private String paramValue;
+}

ruoyi-system/src/main/java/com/ruoyi/system/mapper/sms/MsSmsSendHistoryRecordParamMapper.java

+package com.ruoyi.system.mapper.sms;
+
+import com.ruoyi.system.domain.entity.sms.MsSmsSendHistoryRecordParam;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import tk.mybatis.mapper.common.Mapper;
+
+import java.util.List;
+
+public interface MsSmsSendHistoryRecordParamMapper extends Mapper<MsSmsSendHistoryRecordParam> {
+    /**
+     * 批量新增
+     * @param historyRecordParams
+     */
+    @Select("<script> INSERT INTO ms_sms_send_history_record_param (sms_record_history_id, param_value)\n" +
+            "       VALUES\n" +
+            "       <foreach item=\"item\" index=\"index\" collection=\"list\" separator=\",\">\n" +
+            "           (#{item.smsRecordHistoryId}, #{item.paramValue})\n" +
+            "       </foreach> " +
+            "</script>")
+    void batchInsert(@Param("list") List<MsSmsSendHistoryRecordParam> historyRecordParams);
+}

ruoyi-system/src/main/java/com/ruoyi/system/mapper/sms/MsSmsSendRecordParamMapper.java

+package com.ruoyi.system.mapper.sms;
+
+import com.ruoyi.system.domain.entity.sms.MsSmsSendRecordParam;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import tk.mybatis.mapper.common.Mapper;
+
+import java.util.List;
+
+public interface MsSmsSendRecordParamMapper extends Mapper<MsSmsSendRecordParam> {
+    /**
+     * 批量插入
+     * @param list
+     */
+    @Select("<script> INSERT INTO ms_sms_send_record_param (sms_record_id, param_value)\n" +
+            "       VALUES\n" +
+            "       <foreach item=\"item\" index=\"index\" collection=\"list\" separator=\",\">\n" +
+            "           (#{item.smsRecordId}, #{item.paramValue})\n" +
+            "       </foreach> " +
+            "</script>")
+    void batchInsert(@Param("list") List<MsSmsSendRecordParam> list);
+}

ruoyi-system/src/main/java/com/ruoyi/system/mapper/sms/MsSmsTemplateMapper.java

+package com.ruoyi.system.mapper.sms;
+
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplate;
+import tk.mybatis.mapper.common.Mapper;
+
+public interface MsSmsTemplateMapper extends Mapper<MsSmsTemplate> {
+}

ruoyi-system/src/main/java/com/ruoyi/system/mapper/sms/MsSmsTemplateParamMapper.java

+package com.ruoyi.system.mapper.sms;
+
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import tk.mybatis.mapper.common.Mapper;
+
+import java.util.List;
+
+public interface MsSmsTemplateParamMapper extends Mapper<MsSmsTemplateParam> {
+    @Select("<script> INSERT INTO ms_sms_template_param (sms_template_id, param,param_name)\n" +
+            "       VALUES\n" +
+            "       <foreach item=\"item\" index=\"index\" collection=\"list\" separator=\",\">\n" +
+            "           (#{item.smsTemplateId}, #{item.param}, #{item.paramName})\n" +
+            "       </foreach> " +
+            "</script>")
+    void batchInsert(@Param("list") List<MsSmsTemplateParam> templateParams);
+}

ruoyi-system/src/main/java/com/ruoyi/system/service/ISysMenuService.java

 package com.ruoyi.system.service;
 
+import com.ruoyi.common.core.domain.AjaxResult;
 import com.ruoyi.common.core.domain.TreeSelect;
 import com.ruoyi.common.core.domain.entity.SysMenu;
 import com.ruoyi.system.domain.vo.RouterVo;
      */
 
     Set<String> selectAdminMenu();
+
+    /**
+     * 根据用户查询菜单权限字符
+     * @return
+     */
+    AjaxResult getMenuPermsByUser();
 }

ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDeptServiceImpl.java

 package com.ruoyi.system.service.impl;
 
+import cn.hutool.core.collection.CollectionUtil;
 import com.ruoyi.common.annotation.DataScope;
 import com.ruoyi.common.constant.CacheConstants;
 import com.ruoyi.common.constant.UserConstants;
 import com.ruoyi.system.mapper.SysDeptMapper;
 import com.ruoyi.system.mapper.SysRoleMapper;
 import com.ruoyi.system.service.ISysDeptService;
+import com.ruoyi.wisdomarbitrate.mapper.mscase.MsCaseApplicationMapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
     private SysRoleMapper roleMapper;
     @Autowired
     private RedisCache redisCache;
+    @Autowired
+    MsCaseApplicationMapper caseApplicationMapper;
 
     /**
      * 查询部门管理数据
     @Override
     public int deleteDeptById(Long deptId)
     {
+        // 查询部门是否与案件有关
+       List<Long> caseList = caseApplicationMapper.selectCaseByDeptId(deptId);
+       if(CollectionUtil.isNotEmpty(caseList)){
+           throw new ServiceException("该部门有关联案件，不允许删除");
+       }
         SysDept sysDept = deptMapper.selectDeptById(deptId);
         if(sysDept!=null) {
             // 删除缓存

ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysMenuServiceImpl.java

 import cn.hutool.core.collection.CollectionUtil;
 import com.ruoyi.common.constant.Constants;
 import com.ruoyi.common.constant.UserConstants;
+import com.ruoyi.common.core.domain.AjaxResult;
 import com.ruoyi.common.core.domain.TreeSelect;
 import com.ruoyi.common.core.domain.entity.SysMenu;
 import com.ruoyi.common.core.domain.entity.SysRole;
         return permsSet;
     }
 
+    @Override
+    public AjaxResult getMenuPermsByUser() {
+        AjaxResult result = AjaxResult.success();
+        List<String> perms = menuMapper.selectMenuPermsByUserId(SecurityUtils.getUserId());
+        result.put("perms",perms);
+        return result;
+    }
+
     /**
      * 根据用户ID查询菜单
      * 

ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysUserServiceImpl.java

 import com.ruoyi.system.mapper.*;
 import com.ruoyi.system.service.ISysConfigService;
 import com.ruoyi.system.service.ISysUserService;
+import com.ruoyi.wisdomarbitrate.mapper.mscase.MsCaseApplicationMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 
 import javax.validation.Validator;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
     protected Validator validator;
     @Autowired
     private RedisCache redisCache;
+    @Autowired
+    MsCaseApplicationMapper msCaseApplicationMapper;
 
     /**
      * 根据条件分页查询用户列表
     @Transactional
     public int deleteUserById(Long userId) {
         // 删除用户与角色关联
-        userRoleMapper.deleteUserRoleByUserId(userId);
+       // userRoleMapper.deleteUserRoleByUserId(userId);
         // 删除用户与岗位表
-        userPostMapper.deleteUserPostByUserId(userId);
+       // userPostMapper.deleteUserPostByUserId(userId);
+        // 与案件有关的人员不能删除
+        List<Long> userIds = new ArrayList<>();
+        userIds.add(userId);
+        List<Long> caseIds= msCaseApplicationMapper.countCasePerson(userIds);
+        if(CollectionUtil.isNotEmpty(caseIds)){
+            throw new ServiceException("该人员已参与案件，不能删除");
+        }
         int i = userMapper.deleteUserById(userId);
         // 删除缓存
         redisCache.deleteObject(CacheConstants.USER_KEY+userId);
     @Override
     @Transactional
     public int deleteUserByIds(Long[] userIds) {
+        // 校验是否与案件关联
+        if(userIds==null || userIds.length==0){
+            throw new ServiceException("请选择删除的用户");
+        }
+        List<Long> caseIds= msCaseApplicationMapper.countCasePerson(new ArrayList<>(Arrays.asList(userIds)));
+        if(CollectionUtil.isNotEmpty(caseIds)){
+            throw new ServiceException("删除人员中存在与案件关联的人员，不能删除");
+        }
         for (Long userId : userIds) {
             checkUserAllowed(new SysUser(userId));
             checkUserDataScope(userId);

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/domain/dto/miniprogress/IdentityAuthentication.java

      * 短信验证码
      */
     private String VerifyCode;
+    /**
+     * email验证码
+     */
+    private String emailVerifyCode;
     private String passWord;
     private String phone;
     /**
     /** 认证状态 */
     private Integer certificationStatus;
 
+    public String getEmailVerifyCode() {
+        return emailVerifyCode;
+    }
+
+    public void setEmailVerifyCode(String emailVerifyCode) {
+        this.emailVerifyCode = emailVerifyCode;
+    }
+
     public Integer getCertificationStatus() {
         return certificationStatus;
     }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/domain/dto/sendrecord/SmsSendRecord.java

 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.ruoyi.common.core.domain.BaseEntity;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.util.Date;
+import java.util.List;
 
 @Data
 @AllArgsConstructor
      * ID
      */
     private Long id;
+    /**
+     * 短信模板主键id
+     */
+    private Long msSmsTemplateId;
     /**
      * 案件申请id
      */
      */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date sendTime;
-    /**
-     * 发送内容
-     */
-    private String sendContent;
 
     /**
      * 发送状态
      * 失败原因
      */
     private String reason;
+    /**
+     * 短信内容
+     */
+    private String sendContent;
+    /**
+     * 腾讯云模板id
+     */
+    private String templateId;
+    /**
+     * 模板内容
+     */
+    private String templateContent;
+    private List<MsSmsTemplateParam> templateParams;
 
     public SmsSendRecord(Long caseId, String caseNum, String phone, Date sendTime, String sendContent,String sid) {
         this.caseId = caseId;

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/domain/entity/mscase/MsCaseAffiliate.java

      */
     @Transient
     private String code;
+    /**
+     * 用户名
+     */
+    @Transient
+    private String userName;
 
     /**
      * 法定代表人
      */
     @Column(name = "operator_flag")
     private Integer operatorFlag=1;
+    /**
+     * 是否机构申请，0-自然人，1-申请机构,默认0
+     */
+    @Column(name = "organize_flag")
+    private Integer organizeFlag=0;
     /**
      * 电话
      */
      */
     @Transient
     private String applicantOrgName;
+    /**
+     * 角色id
+     */
+    @Transient
+    private Long roleId;
 
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/domain/entity/mscase/MsCaseApplication.java

      */
     @Column(name = "is_reconci")
     private Integer isReconci;
-    /**
-     * 是否机构申请，0-自然人，1-申请机构,默认0
-     */
-    @Column(name = "organize_flag")
-    private Integer organizeFlag;
+
     /**
      * 案件来源，YC-乙巢，空字符串-北明
      */
      */
     @Transient
     private String rejectReason;
+    @Transient
+    private Integer organizeFlag=0;
 
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/domain/vo/shortmessage/ReSendMessageVO.java

 package com.ruoyi.wisdomarbitrate.domain.vo.shortmessage;
 
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
      * 手机号
      */
     private String phone;
+    /**
+     * 短信id
+     */
+    private Long id;
     /**
      * 短信模版参数值
      */
-    private List<String> paramValues;
+    private List<MsSmsTemplateParam> templateParams;
 
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/mapper/mscase/MsCaseApplicationMapper.java

     Long selectMaxRoomId();
 
     List<CaseToDoCount> todoCount(@Param("req")MsCaseApplicationReq req, @Param("caseFlowIds") List<Integer> caseFlowIds, @Param("roleIds") List<Long> roleIds);
+
+    /**
+     * 根据用户id查询是否和案件有关
+     * @param userIds
+     * @return
+     */
+    List<Long> countCasePerson(@Param("userIds") List<Long> userIds);
+
+    /**
+     * 查询部门是否与案件有关
+     * @param deptId
+     * @return
+     */
+    List<Long> selectCaseByDeptId(@Param("deptId") Long deptId);
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/mapper/sendrecord/SmsRecordMapper.java

     SmsSendRecord selectBySId(@Param("sid") String sid);
     void updateStatus (SmsSendRecord smsSendRecord);
 
-    /**
-     * 更新短信发送内容
-     * @param smsSendRecord
-     * @return
-     */
-    int updateSendContent(SmsSendRecord smsSendRecord);
     /**
      * 通过id查询短信发送记录
      */
     SmsSendRecord selectById(@Param("id") Long id);
+
+    void update(SmsSendRecord smsSendRecord);
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/miniprogress/WeChatUserService.java

 
 
     AjaxResult registerUser(IdentityAuthentication ientityAuthentication);
+
+    /**
+     * 获取邮箱验证码
+     * @param email
+     * @return
+     */
+
+    AjaxResult sendEmailCode(String email);
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/miniprogress/impl/WeChatUserServiceImpl.java

 import com.ruoyi.common.core.domain.entity.SysUser;
 import com.ruoyi.common.core.redis.RedisCache;
 import com.ruoyi.common.enums.SMSStatusEnum;
+import com.ruoyi.common.utils.EmailOutUtil;
 import com.ruoyi.common.utils.SecurityUtils;
-import com.ruoyi.common.utils.SmsUtils;
 import com.ruoyi.common.utils.StringUtils;
 import com.ruoyi.common.utils.spring.SpringUtils;
 import com.ruoyi.system.mapper.SysRoleMapper;
 import com.ruoyi.wisdomarbitrate.domain.vo.miniprogress.WeChatUserVO;
 import com.ruoyi.wisdomarbitrate.mapper.miniprogress.IdentityAuthenticationMapper;
 import com.ruoyi.wisdomarbitrate.service.miniprogress.WeChatUserService;
+import com.ruoyi.wisdomarbitrate.utils.SmsUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
     private IdentityAuthenticationMapper identityAuthenticationMapper;
     @Autowired
     private RedisCache redisCache;
+    @Autowired
+    private EmailOutUtil emailOutUtil;
 
     @Override
     public AjaxResult sendCode(WeChatUserVO userVO) {
         request.setTemplateParamSet(new String[]{ code});
         JSONObject resultObj = SmsUtils.sendSms(request);
         if(resultObj.get("status")!=null && !resultObj.get("status").equals(SMSStatusEnum.FAIL.getCode())){
-            setCodeCache(userVO.getPhone(),code);
+            setCodeCache(CacheConstants.WE_CHAT_SMS_VERIFY_CODE_KEY + userVO.getPhone(),code);
             return AjaxResult.success("短信发送成功");
         }else {
             return AjaxResult.warn("短信发送失败");
         }
     }
+    @Override
+    public AjaxResult sendEmailCode(String email) {
+        Random random = new Random();
+        String code = "";
+        for (int i = 0; i < 6; i++) {
+
+            code += random.nextInt(10);
+        }
+
+        try {
+            emailOutUtil.sendMessage(email, "调解系统邮箱验证", "尊敬的用户，您好，您的邮箱验证码为："+code+"，有效期为5分钟。", null, null);
+        } catch (Exception e) {
+           return AjaxResult.warn("邮件发送失败");
+        }
+
+        //  1954926 普通短信 短信验证码 验证码：，为了保证您的账户安全，请勿想他人泄露验证码信息。如非本人操作，请忽略本短信。
+        setCodeCache(CacheConstants.EMAIL_VERIFY_CODE_KEY +email,code);
+        return AjaxResult.success("邮件发送成功");
+    }
     /**
      * 设置验证码缓存
      *
      */
     public static void setCodeCache(String key, String code)
     {
-        SpringUtils.getBean(RedisCache.class).setCacheObject(getVerifyCodeCacheKey(key), code, 5,TimeUnit.MINUTES);
+        SpringUtils.getBean(RedisCache.class).setCacheObject( key, code, 5,TimeUnit.MINUTES);
     }
 
 
      */
     public static String getCodeCache(String key)
     {
-        String codeCache = SpringUtils.getBean(RedisCache.class).getCacheObject(getVerifyCodeCacheKey(key));
+        String codeCache = SpringUtils.getBean(RedisCache.class).getCacheObject( key);
         if (StringUtils.isNotNull(codeCache))
         {
             return codeCache;
         return null;
     }
 
-    private static String getVerifyCodeCacheKey(String key) {
-        return CacheConstants.WE_CHAT_SMS_VERIFY_CODE_KEY + key;
-    }
     @Transactional
     @Override
     public AjaxResult registerUser(IdentityAuthentication ientityAuthentication) {
-        String codeCache = getCodeCache(ientityAuthentication.getPhone());
+        String codeCache = getCodeCache(CacheConstants.WE_CHAT_SMS_VERIFY_CODE_KEY + ientityAuthentication.getPhone());
         // 校验短信验证码
         if(StrUtil.isEmpty(codeCache)){
             return AjaxResult.warn("验证码校验失败");
         }else if(!codeCache.equals(ientityAuthentication.getVerifyCode())){
             return AjaxResult.warn("验证码校验失败");
         }
+        // 校验邮箱验证码
+        String emailCodeCache = getCodeCache(CacheConstants.EMAIL_VERIFY_CODE_KEY +ientityAuthentication.getEmail());
+        if(StrUtil.isEmpty(emailCodeCache)){
+            return AjaxResult.warn("验证码校验失败");
+        }else if(!emailCodeCache.equals(ientityAuthentication.getEmailVerifyCode())){
+            return AjaxResult.warn("验证码校验失败");
+        }
         // 根据用户名或者邮箱或者手机号查询系统用户表中是否存在该用户
         SysUser sysUserName=sysUserMapper.checkUserNameUnique(ientityAuthentication.getUserName());
         if(sysUserName!=null){
         return AjaxResult.success("注册成功");
     }
 
+
+
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/mscase/MsCaseApplicationService.java

 import com.alibaba.fastjson.JSONObject;
 import com.ruoyi.common.core.domain.AjaxResult;
 import com.ruoyi.common.core.domain.entity.SMSNotice;
-import com.ruoyi.common.core.domain.entity.SMSNoticeDO;
 import com.ruoyi.common.core.domain.entity.SysDictData;
 import com.ruoyi.common.core.domain.entity.SysUser;
 import com.ruoyi.common.enums.PushCaseStatusEnum;
 import com.ruoyi.common.exception.EsignDemoException;
 import com.ruoyi.system.domain.entity.flow.MsCaseFlow;
-import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
 import com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseAffiliate;
 import com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseApplication;
 import com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseAttach;
      */
     AjaxResult batchInsert(MsCaseBatchInsertVO vo);
 
-    /**
-     * 新增申请机构代理人
-     * @param affiliate
-     */
-    void insertAgentUser(MsCaseAffiliate affiliate);
+
 
     /**
      * 修改案件
      * @return
      */
     AjaxResult generateApplication(MsCaseApplicationReq req);
+    /**
+     * 生成调解申请书
+     * @param req
+     * @return
+     */
+    AjaxResult generateApplication1(MsCaseApplicationReq req);
 
     /**
      * 根据批次号和流程id查找未锁定的案件
      * @param dictDataList 内置字段
      */
      void createMediateApplication(MsCaseApplication application, List<MsCaseAffiliate> affiliates, String templatePath, List<String> bookmarkList, List<SysDictData> dictDataList, Integer templateType) ;
+     void createMediateApplication1(MsCaseApplication application, List<MsCaseAffiliate> affiliates, String templatePath, List<String> bookmarkList, List<SysDictData> dictDataList, Integer templateType) ;
     /**
      * 调解书上传到onlyoffice服务器
      * @param annexPath
      * 根据登录人返回用户信息
      */
     SysUser getUserInfo();
-    /**
-     * 查询短信发送记录
-     * @param smsSendRecord
-     * @return
-     */
-    List<SmsSendRecord> getSmsSendRecord(SmsSendRecord smsSendRecord);
+
     /**
      * 保存onlyOffice在线编辑的文件
      * @param
      */
 
     AjaxResult saveOnlyOfficeFile(MsCaseAttach caseAttach);
-    /**
-     * 发送短信
-     * @param smsFlag 短信是否发送成功
-     * @param application 案件基本信息
-     * @param affiliate 案件人员
-     * @param sendContent 发送内容
-     */
-    public void sendSMS(cn.hutool.json.JSONObject jsonObject ,MsCaseApplication application, MsCaseAffiliate affiliate, String sendContent);
+
     /**
      * 发送邮件
      * @param application 案件基本信息
      * @param affiliates
      */
     public void sendHearDateSms(MsCaseApplication application, List<MsCaseAffiliate> affiliates);
-    /**
-     * 发送短信
-     * @param application
-     * @param affiliate
-     * @param notice
-     */
-    public void sendNotice(MsCaseApplication application, MsCaseAffiliate affiliate,
-                           SMSNoticeDO notice);
+
     /**
      * 申请操作人/被申操作人发送通知
      * @param application

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/mscase/MsCasePaymentService.java

 
     public void confirmPayment(MsCaseFlow currentFlow,MsCaseFlow nextFlow, MsCaseApplication application, CaseConfirmPayDTO dto);
 
-    /**
-     * 发送受理短信
-     * @param dto
-     * @param caseAppllication
-     */
-    public void sendAcceptSms(CaseConfirmPayDTO dto, MsCaseApplication caseAppllication,String userName,String phone );
+
 }

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/mscase/impl/MsCasePaymentServiceImpl.java

 import com.ruoyi.common.core.redis.RedisCache;
 import com.ruoyi.common.enums.AnnexTypeEnum;
 import com.ruoyi.common.enums.PaymentStatusEnum;
-import com.ruoyi.common.enums.SMSStatusEnum;
 import com.ruoyi.common.enums.YesOrNoEnum;
 import com.ruoyi.common.exception.ServiceException;
 import com.ruoyi.common.utils.SecurityUtils;
 import com.ruoyi.dto.PayResponse;
 import com.ruoyi.system.domain.entity.flow.MsCaseFlow;
 import com.ruoyi.system.mapper.flow.MsCaseFlowMapper;
+import com.ruoyi.system.mapper.sms.MsSmsSendRecordParamMapper;
+import com.ruoyi.system.mapper.sms.MsSmsTemplateMapper;
 import com.ruoyi.wisdomarbitrate.domain.dto.mscase.CaseConfirmPayDTO;
 import com.ruoyi.wisdomarbitrate.domain.dto.mscase.CasePayDTO;
-import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
 import com.ruoyi.wisdomarbitrate.domain.entity.mscase.*;
 import com.ruoyi.wisdomarbitrate.domain.vo.mscase.PaymentDetailVO;
 import com.ruoyi.wisdomarbitrate.mapper.mscase.*;
 import com.ruoyi.wisdomarbitrate.service.mscase.MsCaseApplicationService;
 import com.ruoyi.wisdomarbitrate.service.mscase.MsCasePaymentService;
 import com.ruoyi.wisdomarbitrate.utils.CaseLogUtils;
+import com.ruoyi.wisdomarbitrate.utils.SmsUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
     private RedisCache redisCache;
     @Autowired
     private MsCaseAuditMapper auditMapper;
+    @Autowired
+    MsSmsTemplateMapper templateMapper;
+    @Autowired
+    MsSmsSendRecordParamMapper recordParamMapper;
 
 
     @Override
         }
         JSONObject jsonObject = new JSONObject();
         jsonObject.set("totalFee", totalFee);
-     //   jsonObject.set("applicationOrganName", affiliate.getApplicationName());
         return AjaxResult.success(jsonObject);
     }
 
         caseApplicationMapper.updateByPrimaryKeySelective(application);
         if (dto.getApplicantConfirm() && dto.getYesOrNo().equals(YesOrNoEnum.YES.getCode())) {
             // 申请人确认缴费后将该案件存放到redis,5日之内如果案件状态还是待受理状态，则发送不受理通知书并自动结束
-//            redisCache.setCacheObject(CacheConstants.CASE_KEY+application.getId(), application, Constants.CASE_ACCEPT_EXPIRATION, TimeUnit.DAYS);
             SpringUtils.getBean(RedisCache.class).setCacheObject(getVerifyCodeCacheKey(String.valueOf(application.getId())), application, Constants.CASE_ACCEPT_EXPIRATION, TimeUnit.DAYS);
 
         }
             throw new ServiceException("未找到案件操作人员");
         }
         if(dto.getApplicantConfirm()) {
+            List<String> appPhones=new ArrayList<>();
+
             // 申请人确认缴费
             for (MsCaseAffiliate affiliate : operatorList) {
                 // 发送缴费通知
                 if (affiliate.getRoleType() == null) {
                     continue;
                 }
-                if (affiliate.getRoleType().equals(1) || affiliate.getRoleType().equals(2)) {
-                    JSONObject jsonObject = new JSONObject();
-                    SmsSendRecord smsSendRecord = null;
+                if (!appPhones.contains(affiliate.getPhone())&&(affiliate.getRoleType().equals(1) || affiliate.getRoleType().equals(2))) {
+                    appPhones.add(affiliate.getPhone());
                     if (dto.getYesOrNo().equals(YesOrNoEnum.YES.getCode())) {
+
                         // 缴费通过
-                        // todo 短信
-//                        jsonObject = SmsUtils.sendSms(affiliate.getCaseAppliId(), "2051914", affiliate.getPhone(), new String[]{affiliate.getName()});
-                        smsSendRecord = new SmsSendRecord(caseAppllication.getId(), caseAppllication.getCaseNum(), affiliate.getPhone(), new Date(), "尊敬的" + affiliate.getName() + ",您的调解申请费用已缴费成功。",jsonObject.get("sid")!=null?jsonObject.get("sid").toString():null);
+                        SmsUtils.sendSms(caseAppllication, "2051914", affiliate.getPhone(), new String[]{affiliate.getName()});
                     } else {
-                        // todo 短信
-//                        jsonObject = SmsUtils.sendSms(affiliate.getCaseAppliId(), "2074402", affiliate.getPhone(), new String[]{affiliate.getName(), caseAppllication.getCaseNum(), dto.getReason()});
                         // 2074402	调解系统确认缴费不通过通知   尊敬的{1}用户，您的{2}案件，确认缴费未通过，理由为{3}，请知晓，如非本人操作，请忽略本短信
-                        smsSendRecord = new SmsSendRecord(caseAppllication.getId(), caseAppllication.getCaseNum(), affiliate.getPhone(), new Date(), "尊敬的" + affiliate.getName() + "用户，您的" + caseAppllication.getCaseNum() + "案件，确认缴费未通过，理由为" + dto.getReason() + "，请知晓，如非本人操作，请忽略本短信",jsonObject.get("sid")!=null?jsonObject.get("sid").toString():null);
+                         SmsUtils.sendSms(caseAppllication, "2074402", affiliate.getPhone(), new String[]{affiliate.getName(), caseAppllication.getCaseNum(), dto.getReason()});
                     }
-                    // 新增短信记录
-                    if (jsonObject.get("ststus")!=null && !jsonObject.get("ststus").equals(SMSStatusEnum.FAIL)) {
-                        smsSendRecord.setSendStatus(SMSStatusEnum.SENDING.getCode());
-                    } else {
-                        smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
-                    }
-                    smsRecordMapper.saveSmsSendRecord(smsSendRecord);
                 }
             }
         }else {
+            List<String> resPhones=new ArrayList<>();
+            List<String> resAcceptPhones=new ArrayList<>();
             // 被申请人确认缴费
             for (MsCaseAffiliate affiliate : operatorList) {
                 // 发送缴费通知
                 if (affiliate.getRoleType() == null) {
                     continue;
                 }
-                if (affiliate.getRoleType().equals(3) || affiliate.getRoleType().equals(4)) {
-                    JSONObject jsonObject = new JSONObject();
-                    SmsSendRecord smsSendRecord = null;
+                if (!resPhones.contains(affiliate.getPhone())&&(affiliate.getRoleType().equals(3) || affiliate.getRoleType().equals(4)) ) {
+                    resPhones.add(affiliate.getPhone());
                     if (dto.getYesOrNo().equals(YesOrNoEnum.YES.getCode())) {
-                        // todo 短信
                         // 缴费通过
-//                        jsonObject = SmsUtils.sendSms(affiliate.getCaseAppliId(), "2051914", affiliate.getPhone(), new String[]{affiliate.getName()});
-                        smsSendRecord = new SmsSendRecord(caseAppllication.getId(), caseAppllication.getCaseNum(), affiliate.getPhone(), new Date(), "尊敬的" + affiliate.getName() + ",您的调解申请费用已缴费成功。",jsonObject.get("sid")!=null?jsonObject.get("sid").toString():null);
+                        SmsUtils.sendSms(caseAppllication, "2051914", affiliate.getPhone(), new String[]{affiliate.getName()});
                     } else {
-                        // todo 短信
-//                        jsonObject = SmsUtils.sendSms(affiliate.getCaseAppliId(), "2074402", affiliate.getPhone(), new String[]{affiliate.getName(), caseAppllication.getCaseNum(), dto.getReason()});
                         // 2074402	调解系统确认缴费不通过通知   尊敬的{1}用户，您的{2}案件，确认缴费未通过，理由为{3}，请知晓，如非本人操作，请忽略本短信
-                        smsSendRecord = new SmsSendRecord(caseAppllication.getId(), caseAppllication.getCaseNum(), affiliate.getPhone(), new Date(), "尊敬的" + affiliate.getName() + "用户，您的" + caseAppllication.getCaseNum() + "案件，确认缴费未通过，理由为" + dto.getReason() + "，请知晓，如非本人操作，请忽略本短信",jsonObject.get("sid")!=null?jsonObject.get("sid").toString():null);
-                    }
-                    // 新增短信记录
-                    if (jsonObject.get("status")!=null && !jsonObject.get("status").equals(SMSStatusEnum.FAIL)) {
-                        smsSendRecord.setSendStatus(SMSStatusEnum.SENDING.getCode());
-                    } else {
-                        smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
+                        SmsUtils.sendSms(caseAppllication, "2074402", affiliate.getPhone(), new String[]{affiliate.getName(), caseAppllication.getCaseNum(), dto.getReason()});
                     }
-                    smsRecordMapper.saveSmsSendRecord(smsSendRecord);
                 }
                 // 被申请人确认缴费，发送受理通知
-                if( dto.getYesOrNo().equals(YesOrNoEnum.YES.getCode())) {
-                    // 申请人发送受理短信
-                    casePaymentService.sendAcceptSms(dto, caseAppllication, affiliate.getName(), affiliate.getPhone());
+                if( dto.getYesOrNo().equals(YesOrNoEnum.YES.getCode()) && !resAcceptPhones.contains(affiliate.getPhone())) {
+                    resAcceptPhones.add(affiliate.getPhone());
+                    // 申请人被申请人发送受理通知书 2073601    尊敬的{1}用户，您的{2}案件，已成功受理，请知晓，如非本人操作，请忽略本短信。
+                    SmsUtils.sendSms(caseAppllication, "2073601", affiliate.getPhone(), new String[]{affiliate.getName(), caseAppllication.getCaseNum()});
 
                 }
             }
 
 
 
-    /**
-     * 发送受理短信
-     * @param dto
-     * @param caseAppllication
-     */
-    @Transactional
-    public void sendAcceptSms(CaseConfirmPayDTO dto, MsCaseApplication caseAppllication,String userName,String phone ) {
-            // 申请人被申请人发送受理通知书 2073601    尊敬的{1}用户，您的{2}案件，已成功受理，请知晓，如非本人操作，请忽略本短信。
-        // todo 短信
-
-//        JSONObject jsonObject = SmsUtils.sendSms(caseAppllication.getId(), "2073601", phone, new String[]{userName, caseAppllication.getCaseNum()});
-        JSONObject jsonObject = new JSONObject();
-        SmsSendRecord smsSendRecord = new SmsSendRecord(caseAppllication.getId(), caseAppllication.getCaseNum(), phone, new Date(), "尊敬的" + userName + "用户，您的" + caseAppllication.getCaseNum() +  "案件，已成功受理，请知晓，如非本人操作，请忽略本短信。",jsonObject.get("sid")!=null?jsonObject.get("sid").toString():null);
-            // 新增短信记录
-            if (jsonObject.get("status")!=null && !jsonObject.get("status").equals(SMSStatusEnum.FAIL)) {
-                smsSendRecord.setSendStatus(SMSStatusEnum.SENDING.getCode());
-            } else {
-                smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
-            }
-            smsRecordMapper.saveSmsSendRecord(smsSendRecord);
 
-    }
 
     /**
      * 确认缴费
         application.setPayType(dto.getPayType());
         // 修改缴费附件
         if (CollectionUtil.isNotEmpty(dto.getPayOrderList())) {
-
-
             for (MsCaseAttach caseAttach : dto.getPayOrderList()) {
                 // 先删除之前的缴费
                 if(currentFlow.getButtonAuthFlag().equals("caseManagement:list:pay")){

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/mscase/impl/MsSignSealServiceImpl.java

 import com.ruoyi.common.utils.StringUtils;
 import com.ruoyi.common.utils.file.SaaSAPIFileUtils;
 import com.ruoyi.system.domain.entity.flow.MsCaseFlow;
+import com.ruoyi.system.domain.entity.shortmessage.MsSendMailHistoryRecord;
 import com.ruoyi.system.domain.vo.flow.MsCaseFlowVO;
-import com.ruoyi.system.mapper.SysRoleMapper;
 import com.ruoyi.system.mapper.SysUserMapper;
 import com.ruoyi.system.mapper.flow.MsCaseFlowMapper;
+import com.ruoyi.system.mapper.shortmessage.MsSendMailHistoryRecordMapper;
 import com.ruoyi.system.service.impl.BeiMingInterfaceService;
 import com.ruoyi.wisdomarbitrate.domain.dto.dept.DeptIdentify;
 import com.ruoyi.wisdomarbitrate.domain.dto.dept.SealManage;
 import com.ruoyi.wisdomarbitrate.service.mscase.MsSignSealService;
 import com.ruoyi.wisdomarbitrate.utils.CaseLogUtils;
 import com.ruoyi.wisdomarbitrate.utils.SignAward;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
     @Autowired
     private SendMailRecordMapper sendMailRecordMapper;
-    @Autowired
-    private SysRoleMapper roleMapper;
+    @Value("${spring.mail.username}")
+    private String emailFrom;
     // 北明配置
     @Value("${BMConfig.userName}")
     private String BMUserName;
     private String BMSyncSource;
     @Autowired
     BeiMingInterfaceService beiMingInterfaceService;
+    @Autowired
+    private MsSendMailHistoryRecordMapper sendMailHistoryRecordMapper;
 
 
 
                             String annexPath = caseAttach.getAnnexPath();
                             String path = "/home/ruoyi/uploadPath/" + annexPath.substring(startIndex+1);
                             File file = new File(path);
-                            // todo 部署放开
                             if (!file.exists()) {
                                 Gson gson = new Gson();
                                 MsSealSignRecord sealSignRecord = new MsSealSignRecord();
                     }
                     boolean appEmailFlag = sendCaseEmail(caseApplication1, affiliate.getEmail(), caseAttachList);
 
-                    SendMailRecord sendMailRecord = new SendMailRecord();
-                    sendMailRecord.setCaseId(id);
-                    sendMailRecord.setMailAddress(affiliate.getEmail());
-                    sendMailRecord.setMailContent("您好，审核后的调解书在附件中请查阅");
-                    sendMailRecord.setMailName("签署后的调解书");
-                    sendMailRecord.setSendTime(new Date());
-                    sendMailRecord.setCreateBy(SecurityUtils.getUsername());
-                    if (appEmailFlag) {
-                        sendMailRecord.setSendStatus(1);
-                    } else {
-                        sendMailRecord.setSendStatus(0);
-                    }
-                    sendMailRecordMapper.saveSendMailRecord(sendMailRecord);
-                }
 
-//                if(!appEmailFlag&&!resEmailFlag){
-//                    throw new ServiceException("调解书发送失败");
-//                }
-//                if(!appEmailFlag){
-//                    throw new ServiceException("申请人调解书发送失败");
-//                }
-//                if(!resEmailFlag){
-//                    throw new ServiceException("被申请人调解书发送失败");
-//                }
+                }
 
                 CaseLogUtils.insertCaseLog(caseApplication1.getId(), currentFlow.getNodeId(), currentFlow.getCaseStatusName(),"");
 
     @Transactional
     public AjaxResult msCaseSign(MsSignSealDTO dto) {
         Long caseId = dto.getCaseId();
-        MsCaseAffiliate caseAffiliate = msCaseAffiliateMapper.selectByPrimaryKey(caseId);
+       //  MsCaseAffiliate caseAffiliate = msCaseAffiliateMapper.selectByPrimaryKey(caseId);
         MsCaseApplication caseApplicationselect = msCaseApplicationMapper.selectByPrimaryKey(caseId);
         // 查询当前节点
         MsCaseFlow currentFlow = caseFlowMapper.selectByPrimaryKey(caseApplicationselect.getCaseFlowId());
         if (currentFlow == null) {
             return AjaxResult.error("当前流程不存在");
         }
-//        if (dto.getIsSignApply() != null && dto.getIsSignApply().intValue() == 1) {
-//            caseAffiliate.setIsSignApply(1);
-//            msCaseAffiliateMapper.updateByPrimaryKeySelective(caseAffiliate);
-//            if (caseAffiliate.getIsSignRespon() != null && caseAffiliate.getIsSignRespon().intValue() == 1) {
-//                // 根据流程id查找下一个流程节点
-//                MsCaseFlow nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
-//                caseApplicationselect.setCaseFlowId(nextFlow.getId());
-//                caseApplicationselect.setCaseStatusName(nextFlow.getCaseStatusName());
-//                caseApplicationMapper.updateByPrimaryKeySelective(caseApplicationselect);
-//                CaseLogUtils.insertCaseLog(caseApplicationselect.getId(), nextFlow.getNodeId(), nextFlow.getCaseStatusName(),"签收");
-//            }
-//        }
-        if (dto.getIsSignApply() != null && dto.getIsSignApply().intValue() == 1) {
-            // todo 签收不要该字段
-            //    caseAffiliate.setIsSignApply(1);
-            // todo 签收不要该字段
-            //   msCaseAffiliateMapper.updateByPrimaryKeySelective(caseAffiliate);
-
+        if (dto.getIsSignApply() != null && dto.getIsSignApply().equals(1) ) {
             // 根据流程id查找下一个流程节点
             MsCaseFlow nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
             caseApplicationselect.setCaseFlowId(nextFlow.getId());
             caseApplicationMapper.updateByPrimaryKeySelective(caseApplicationselect);
             CaseLogUtils.insertCaseLog(caseApplicationselect.getId(), currentFlow.getNodeId(), currentFlow.getCaseStatusName(),null);
         }
-//        if (dto.getIsSignRespon() != null && dto.getIsSignRespon().intValue() == 1) {
-//            caseAffiliate.setIsSignRespon(1);
-//            msCaseAffiliateMapper.updateByPrimaryKeySelective(caseAffiliate);
-//            if (caseAffiliate.getIsSignApply() != null && caseAffiliate.getIsSignApply().intValue() == 1) {
-//                // 根据流程id查找下一个流程节点
-//                MsCaseFlow nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
-//                caseApplicationselect.setCaseFlowId(nextFlow.getId());
-//                caseApplicationselect.setCaseStatusName(nextFlow.getCaseStatusName());
-//                caseApplicationMapper.updateByPrimaryKeySelective(caseApplicationselect);
-//                CaseLogUtils.insertCaseLog(caseApplicationselect.getId(), nextFlow.getNodeId(), nextFlow.getCaseStatusName(),"签收");
-//            }
-//        }
-
-        if (dto.getIsSignRespon() != null && dto.getIsSignRespon().intValue() == 1) {
-            // todo 签收不要该字段
-//            caseAffiliate.setIsSignRespon(1);
-            // todo 签收不要该字段
-//            msCaseAffiliateMapper.updateByPrimaryKeySelective(caseAffiliate);
+
+        if (dto.getIsSignRespon() != null && dto.getIsSignRespon().equals(1)) {
 
             // 根据流程id查找下一个流程节点
             MsCaseFlow nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
             caseApplicationMapper.updateByPrimaryKeySelective(caseApplicationselect);
             CaseLogUtils.insertCaseLog(caseApplicationselect.getId(), currentFlow.getNodeId(), currentFlow.getCaseStatusName(),null);
             CaseLogUtils.insertCaseLog(caseApplicationselect.getId(), 17, "结束", null);
-            // todo 被申请人签收结束对接北明，为调解成功状态
+            //  被申请人签收结束对接北明，为调解成功状态
             if(StrUtil.isEmpty(caseApplicationselect.getCaseSource())) {
                 applicationService.pushStatusToBM(caseApplicationselect, PushCaseStatusEnum.SUCCESS);
             }
 
     @Override
     public AjaxResult msCaseSignUrlApplyPC(MsSignSealDTO dto) throws EsignDemoException {
-        // todo
         Long caseId = dto.getCaseId();
-        //MsCaseAffiliate caseAffiliate = msCaseAffiliateMapper.selectByPrimaryKey(caseId);
         List<MsCaseAffiliate> affiliates = applicationService.selectAffliatesByCaseId(caseId);
         if(CollectionUtil.isEmpty(affiliates)){
             return AjaxResult.error("未找到案件相关人员");
 
         }
         if(resOpt.get().getUserId()!=null && resOpt.get().getUserId().equals(userId)){
-
+            // 被申
             SealSignRecord sealSignRecordres = new SealSignRecord();
             MsSealSignRecord mssealSignRecord = new MsSealSignRecord();
             mssealSignRecord.setCaseAppliId(caseId);
             }
         }
         if(mediatorCount>0){
+            // 调解员
             SealSignRecord sealSignRecordres = new SealSignRecord();
             MsSealSignRecord mssealSignRecord = new MsSealSignRecord();
             mssealSignRecord.setCaseAppliId(caseId);
             Integer caseNode = currentFlow.getNodeId();
             String caseStatusName = currentFlow.getCaseStatusName();
             if("SIGN_MISSON_COMPLETE".equals(action) && signResult==2){
-                if(mediaResult.intValue()==1){
+                if(mediaResult.equals(1)){
                     //调解
                     if(StringUtils.isNotEmpty(accountMobile)&&accountMobile.equals(pensonAccountApply)){
                         //申请人签名
                         operLog.setCaseNode(caseNode);
                         operLog.setCreateTime(dateOperate);
                         caseLogRecordMapper.insert(operLog);
-                        if(signStatusResponse!=null&&signStatusResponse.intValue()==1&&
-                                signStatusMediator!=null&&signStatusMediator.intValue()==1){
+                        if(signStatusResponse!=null&&signStatusResponse.equals(1)&&
+                                signStatusMediator!=null&&signStatusMediator.equals(1)){
                             // 根据流程id查找下一个流程节点
                             MsCaseFlow nextFlow=null;
                             if(caseApplicationselect.getSealFlag()!=null&&caseApplicationselect.getSealFlag()==1) {
                                 // 需要用印
-                                 nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId().intValue());
+                                 nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
                             }else {
                                 // 不需要用印
-                                nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId().intValue());
+                                nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId());
                             }
                             MsCaseApplication application = new MsCaseApplication();
                             application.setId(caseApplicationselect.getId());
                         operLog.setCaseNode(caseNode);
                         operLog.setCreateTime(dateOperate);
                         caseLogRecordMapper.insert(operLog);
-                        if(signStatusApply!=null&&signStatusApply.intValue()==1&&
-                                signStatusMediator!=null&&signStatusMediator.intValue()==1){
+                        if(signStatusApply!=null&&signStatusApply.equals(1)&&
+                                signStatusMediator!=null&&signStatusMediator.equals(1)){
                             // 根据流程id查找下一个流程节点
                             // 根据流程id查找下一个流程节点
                             MsCaseFlow nextFlow=null;
                             if(caseApplicationselect.getSealFlag()!=null&&caseApplicationselect.getSealFlag()==1) {
                                 // 需要用印
-                                nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId().intValue());
+                                nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
                             }else {
                                 // 不需要用印
-                                nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId().intValue());
+                                nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId());
                             }
                             MsCaseApplication application = new MsCaseApplication();
                             application.setId(caseApplicationselect.getId());
                         operLog.setCaseNode(caseNode);
                         operLog.setCreateTime(dateOperate);
                         caseLogRecordMapper.insert(operLog);
-                        if(signStatusApply!=null&&signStatusApply.intValue()==1&&
-                                signStatusResponse!=null&&signStatusResponse.intValue()==1){
+                        if(signStatusApply!=null&&signStatusApply.equals(1)&&
+                                signStatusResponse!=null&&signStatusResponse.equals(1)){
                             // 根据流程id查找下一个流程节点
                             // 根据流程id查找下一个流程节点
                             MsCaseFlow nextFlow=null;
                             if(caseApplicationselect.getSealFlag()!=null&&caseApplicationselect.getSealFlag()==1) {
                                 // 需要用印
-                                nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId().intValue());
+                                nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
                             }else {
                                 // 不需要用印
-                                nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId().intValue());
+                                nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId());
                             }
                             MsCaseApplication application = new MsCaseApplication();
                             application.setId(caseApplicationselect.getId());
                         caseLogRecordMapper.insert(operLog);
 
                         // 根据流程id查找下一个流程节点
-                        MsCaseFlow nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId().intValue());
+                        MsCaseFlow nextFlow = caseFlowMapper.nextFlow(caseApplicationselect.getCaseFlowId());
                         MsCaseApplication application = new MsCaseApplication();
                         application.setId(caseApplicationselect.getId());
                         application.setCaseFlowId(nextFlow.getId());
 
                     }
 
-                }else if(mediaResult.intValue()==5){
+                }else if(mediaResult.equals(5)){
                     //和解
                     if(StringUtils.isNotEmpty(accountMobile)&&accountMobile.equals(pensonAccountApply)){
                         //申请人签名
                         operLog.setCaseNode(caseNode);
                         operLog.setCreateTime(dateOperate);
                         caseLogRecordMapper.insert(operLog);
-                        if(signStatusResponse!=null&&signStatusResponse.intValue()==1){
-                            MsCaseFlow nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId().intValue());
+                        if(signStatusResponse!=null&&signStatusResponse.equals(1)){
+                            MsCaseFlow nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId());
                             MsCaseApplication application = new MsCaseApplication();
                             application.setId(caseApplicationselect.getId());
                             application.setCaseFlowId(nextFlow.getId());
                                 String day = String.format("%02d", now.getDayOfMonth());
                                 String saveFolderPath = "/home/ruoyi/uploadPath/upload/" + year + "/" + month + "/" + day;
                                 String fileName = UUID.randomUUID().toString().replace("-", "") + ".pdf";
-//                                String saveName = "/profile/upload/" + year + "/" + month + "/" + day + "/" + fileName;
-//                                String savePath = "/home/ruoyi/uploadPath/upload/";
                                 String saveName = fileName;
                                 String savePath = "/profile/upload/" + year + "/" + month + "/" + day + "/" + fileName;
 
                                     if(StrUtil.isEmpty(caseApplicationselect.getCaseSource())){
                                         List<MsCaseAttach> existAttach = msCaseAttachMapper.listCaseAttachByCaseIdAndType(caseAppliId, AnnexTypeEnum.MEDIATE_BOOK.getCode());
                                         if(CollectionUtil.isNotEmpty(existAttach)){
-                                            // todo 对接北明，同步案件状态，删除
+                                            //  对接北明，同步案件状态，删除
                                             for (MsCaseAttach msCaseAttach : existAttach) {
                                                 if(StrUtil.isEmpty(msCaseAttach.getOtherSysFileId())||StrUtil.isEmpty(msCaseAttach.getAnnexPath())){
                                                     continue;
                                     caseAttach.setAnnexPath(savePath);
                                     caseAttach.setAnnexName(saveName);
                                     caseAttachMapper.save(caseAttach);
-                                    // todo 对接北明，调用上传附件接口
+                                    //  对接北明，调用上传附件接口
                                     if(StrUtil.isEmpty(caseApplicationselect.getCaseSource()) ) {
                                         String templatePath = "/home/ruoyi" + savePath;
                                         File file = new File(templatePath.replace("/profile", "/uploadPath"));
                         operLog.setCaseNode(caseNode);
                         operLog.setCreateTime(dateOperate);
                         caseLogRecordMapper.insert(operLog);
-                        if(signStatusApply!=null&&signStatusApply.intValue()==1){
-                            MsCaseFlow nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId().intValue());
+                        if(signStatusApply!=null&&signStatusApply.equals(1)){
+                            MsCaseFlow nextFlow = caseFlowMapper.nextFlow1(caseApplicationselect.getCaseFlowId());
                             MsCaseApplication application = new MsCaseApplication();
                             application.setId(caseApplicationselect.getId());
                             application.setCaseFlowId(nextFlow.getId());
                                 String day = String.format("%02d", now.getDayOfMonth());
                                 String saveFolderPath = "/home/ruoyi/uploadPath/upload/" + year + "/" + month + "/" + day;
                                 String fileName = UUID.randomUUID().toString().replace("-", "") + ".pdf";
-//                                String saveName = "/profile/upload/" + year + "/" + month + "/" + day + "/" + fileName;
-//                                String savePath = "/home/ruoyi/uploadPath/upload/";
                                 String saveName = fileName;
                                 String savePath = "/profile/upload/" + year + "/" + month + "/" + day + "/" + fileName;
 
                                     if(StrUtil.isEmpty(caseApplicationselect.getCaseSource())){
                                         List<MsCaseAttach> existAttach = msCaseAttachMapper.listCaseAttachByCaseIdAndType(caseAppliId, AnnexTypeEnum.MEDIATE_BOOK.getCode());
                                         if(CollectionUtil.isNotEmpty(existAttach)){
-                                            // todo 对接北明，同步案件状态，删除
+                                            //  对接北明，同步案件状态，删除
                                             for (MsCaseAttach msCaseAttach : existAttach) {
                                                 if(StrUtil.isEmpty(msCaseAttach.getOtherSysFileId())||StrUtil.isEmpty(msCaseAttach.getAnnexPath())){
                                                     continue;
                                     caseAttach.setAnnexPath(savePath);
                                     caseAttach.setAnnexName(saveName);
 
-                                    // todo 对接北明，调用上传附件接口
+                                    //  对接北明，调用上传附件接口
 
                                     if(StrUtil.isEmpty(caseApplicationselect.getCaseSource()) ) {
                                         String templatePath = "/home/ruoyi" + savePath;
             String day = String.format("%02d", now.getDayOfMonth());
             String saveFolderPath = "/home/ruoyi/uploadPath/upload/" + year + "/" + month + "/" + day;
             String fileName = UUID.randomUUID().toString().replace("-", "") + ".pdf";
-//                                String saveName = "/profile/upload/" + year + "/" + month + "/" + day + "/" + fileName;
-//                                String savePath = "/home/ruoyi/uploadPath/upload/";
             String saveName = fileName;
             String savePath = "/profile/upload/" + year + "/" + month + "/" + day + "/" + fileName;
 
                 if(StrUtil.isEmpty(caseApplicationselect.getCaseSource())){
                     List<MsCaseAttach> existAttach = msCaseAttachMapper.listCaseAttachByCaseIdAndType(caseAppliId, AnnexTypeEnum.MEDIATE_BOOK.getCode());
                     if(CollectionUtil.isNotEmpty(existAttach)){
-                        // todo 对接北明，同步案件状态，删除
+                        //  对接北明，同步案件状态，删除
                         for (MsCaseAttach msCaseAttach : existAttach) {
                             if(StrUtil.isEmpty(msCaseAttach.getOtherSysFileId())||StrUtil.isEmpty(msCaseAttach.getAnnexPath())){
                                 continue;
                 caseAttach.setAnnexPath(savePath);
                 caseAttach.setAnnexName(saveName);
                 caseAttachMapper.save(caseAttach);
-                // todo 对接北明，调用上传附件接口
+                //  对接北明，调用上传附件接口
                 if(StrUtil.isEmpty(caseApplicationselect.getCaseSource()) ) {
                     String templatePath = "/home/ruoyi" + savePath;
                     File file = new File(templatePath.replace("/profile", "/uploadPath"));
     /**
      * 通过邮件发送裁决书文件
      *
-     * @param caseApplication1
+     * @param caseApplication
      */
-    private boolean sendCaseEmail(MsCaseApplication caseApplication1, String email, List<MsCaseAttach> caseAttachList) {
+    private boolean sendCaseEmail(MsCaseApplication caseApplication, String email, List<MsCaseAttach> caseAttachList) {
         List<File> fileList = new ArrayList<>();
         File file = null;
+        Long fileId = null;
         if (caseAttachList != null && caseAttachList.size() > 0) {
             for (MsCaseAttach caseAttach : caseAttachList) {
                 if (caseAttach.getAnnexType() == AnnexTypeEnum.MEDIATE_BOOK.getCode()) {
-//                    String annexName = caseAttach.getAnnexName();
-//                    String prefix = "/profile/upload/";
-//                    int startIndex = prefix.length();
-//                    String path = caseAttach.getAnnexPath() + annexName.substring(startIndex);
                     String prefix = "/profile";
                     int startIndex = prefix.length();
                     String annexPath = caseAttach.getAnnexPath();
                     String path = "/home/ruoyi/uploadPath/" + annexPath.substring(startIndex+1);
-                    // todo 部署放开
                     file = new File(path);
                     fileList.add(file);
+                    fileId=caseAttach.getAnnexId();
                     System.out.println("文件长度==================:" + file.length());
                 }
             }
         }
+        SendMailRecord sendMailRecord = new SendMailRecord();
+        sendMailRecord.setCaseId(caseApplication.getId());
+        sendMailRecord.setMailAddress(email);
+        sendMailRecord.setMailContent("您好，审核后的调解书在附件中请查阅");
+        sendMailRecord.setMailName("签署后的调解书");
+        sendMailRecord.setSendTime(new Date());
+        sendMailRecord.setMailSubject("签署后的调解书");
+        sendMailRecord.setFileIds(fileId!=null?fileId.toString():null);
+        sendMailRecord.setCreateBy(SecurityUtils.getUsername());
+        sendMailRecord.setCreateTime(new Date());
+        sendMailRecord.setMailFromAddress(emailFrom);
 
         if (file != null && file.exists()) {
             try {
                 Boolean aBoolean = emailOutUtil.sendEmil(email, "您好，审核后的调解书在附件中请查阅", "签署后的调解书", fileList, null);
 
                 if (aBoolean) {
+                    sendMailRecord.setSendStatus(1);
+                    sendMailRecordMapper.saveSendMailRecord(sendMailRecord);
+                    MsSendMailHistoryRecord msSendMailHistoryRecord = new MsSendMailHistoryRecord();
+                    BeanUtils.copyProperties(sendMailRecord, msSendMailHistoryRecord);
+                    msSendMailHistoryRecord.setParentId(sendMailRecord.getId());
+                    msSendMailHistoryRecord.setId(null);
+                    sendMailHistoryRecordMapper.insertSelective(msSendMailHistoryRecord);
                     return Boolean.TRUE;
                 }
             } catch (Exception e) {
                 System.out.println("邮件发送失败++++++++++++++++++++++++++++++++");
                 System.out.println(e.toString());
+                sendMailRecord.setSendStatus(0);
+                MsSendMailHistoryRecord msSendMailHistoryRecord = new MsSendMailHistoryRecord();
+                BeanUtils.copyProperties(sendMailRecord, msSendMailHistoryRecord);
+                msSendMailHistoryRecord.setParentId(sendMailRecord.getId());
+                msSendMailHistoryRecord.setId(null);
+                sendMailHistoryRecordMapper.insertSelective(msSendMailHistoryRecord);
+                sendMailRecordMapper.saveSendMailRecord(sendMailRecord);
                 return Boolean.FALSE;
             }
         }
     }
 
 
-    private MsCaseLogRecordVO getNextCaseLogRecord(String nodeName) {
-        MsCaseLogRecordVO caseLogRecord = new MsCaseLogRecordVO();
-        switch (nodeName) {
-            case "提交案件":
-                caseLogRecord.setCaseNodeName("提交案件");
-                caseLogRecord.setContent("申请人将进行提交案件");
-                break;
-            case "缴费":
-                caseLogRecord.setCaseNodeName("缴费");
-                caseLogRecord.setContent("申请人将进行缴费");
-                break;
-            case "确认缴费":
-                caseLogRecord.setCaseNodeName("确认缴费");
-                caseLogRecord.setContent("财务将进行确认缴费");
-                break;
-            case "受理分配":
-                caseLogRecord.setCaseNodeName("受理分配");
-                caseLogRecord.setContent("法律顾问将进行受理分配");
-                break;
-            case "选择调解员":
-                caseLogRecord.setCaseNodeName("选择调解员");
-                caseLogRecord.setContent("申请人将进行选择调解员");
-                break;
-            case "核实调解员":
-                caseLogRecord.setCaseNodeName("核实调解员");
-                caseLogRecord.setContent("法律顾问将进行核实调解员");
-                break;
-            case "确认调解员":
-                caseLogRecord.setCaseNodeName("确认调解员");
-                caseLogRecord.setContent("部门长将进行确认调解员");
-                break;
-            case "确定调解时间":
-                caseLogRecord.setCaseNodeName("确定调解时间");
-                caseLogRecord.setContent("法律顾问将进行确定调解时间");
-                break;
-            case "调解":
-                caseLogRecord.setCaseNodeName("调解");
-                caseLogRecord.setContent("法律顾问将进行调解");
-                break;
-            case "确认调解书":
-                caseLogRecord.setCaseNodeName("确认调解书");
-                caseLogRecord.setContent("法律顾问将进行确认调解书");
-                break;
-            case "签名":
-                caseLogRecord.setCaseNodeName("签名");
-                caseLogRecord.setContent("申请人、被申请人将进行签名");
-                break;
-            case "用印申请":
-                caseLogRecord.setCaseNodeName("用印申请");
-                caseLogRecord.setContent("法律顾问将进行用印申请");
-                break;
-            case "用印":
-                caseLogRecord.setCaseNodeName("用印");
-                caseLogRecord.setContent("部门长将进行用印");
-                break;
-            case "归档":
-                caseLogRecord.setCaseNodeName("归档");
-                caseLogRecord.setContent("法律顾问将进行提交归档");
-                break;
-            case "签收":
-                caseLogRecord.setCaseNodeName("签收");
-                caseLogRecord.setContent("申请人、被申请人将进行签收");
-                break;
-            case "申请人签收":
-                caseLogRecord.setCaseNodeName("申请人签收");
-                caseLogRecord.setContent("申请人将进行签收");
-                break;
-            case "被申请人签收":
-                caseLogRecord.setCaseNodeName("被申请人签收");
-                caseLogRecord.setContent("被申请人将进行签收");
-                break;
-            case "结束":
-                caseLogRecord.setCaseNodeName("结束");
-                caseLogRecord.setContent("结束");
-                break;
-            default:
-                caseLogRecord.setNextRoleName("没有下一节点角色");
-
-        }
-        return caseLogRecord;
-    }
-
-    private CaseLogRecord getNextRole(String nodeName) {
-        CaseLogRecord caseLogRecord = new CaseLogRecord();
-        switch (nodeName) {
-            case "提交案件":
-                caseLogRecord.setNextRoleName("下一节点角色：申请人");
-                break;
-            case "缴费":
-                caseLogRecord.setNextRoleName("下一节点角色：申请人");
-                break;
-            case "确认缴费":
-                caseLogRecord.setNextRoleName("下一节点角色：财务");
-                break;
-            case "受理分配":
-                caseLogRecord.setNextRoleName("下一节点角色：法律顾问");
-                break;
-            case "选择调解员":
-                caseLogRecord.setNextRoleName("下一节点角色：申请人、被申请人");
-                break;
-            case "核实调解员":
-                caseLogRecord.setNextRoleName("下一节点角色：法律顾问");
-                break;
-            case "确认调解员":
-                caseLogRecord.setNextRoleName("下一节点角色：部门长");
-                break;
-            case "确定调解时间":
-                caseLogRecord.setNextRoleName("下一节点角色：法律顾问");
-                break;
-            case "调解":
-                caseLogRecord.setNextRoleName("下一节点角色：法律顾问");
-                break;
-            case "确认调解书":
-                caseLogRecord.setNextRoleName("下一节点角色：申请人、被申请人");
-                break;
-            case "签名":
-                caseLogRecord.setNextRoleName("下一节点角色：申请人、被申请人");
-                break;
-            case "用印申请":
-                caseLogRecord.setNextRoleName("下一节点角色：法律顾问");
-                break;
-            case "用印":
-                caseLogRecord.setNextRoleName("下一节点角色：部门长");
-                break;
-            case "归档":
-                caseLogRecord.setNextRoleName("下一节点角色：法律顾问");
-                break;
-            case "签收":
-                caseLogRecord.setNextRoleName("下一节点角色：申请人、被申请人");
-                break;
-            default:
-                caseLogRecord.setNextRoleName("没有下一节点角色");
-
-        }
-        return caseLogRecord;
-    }
-
-    private CaseLogRecord getInCasenode(String nodeName) {
-        CaseLogRecord caseLogRecord = new CaseLogRecord();
-        switch (nodeName) {
-            case "提交案件":
-                caseLogRecord.setCaseNodeName("提交案件");
-                caseLogRecord.setContent("申请人正在进行提交案件");
-                break;
-            case "缴费":
-                caseLogRecord.setCaseNodeName("缴费");
-                caseLogRecord.setContent("申请人正在进行缴费");
-                break;
-            case "确认缴费":
-                caseLogRecord.setCaseNodeName("确认缴费");
-                caseLogRecord.setContent("财务正在进行缴费确认");
-                break;
-            case "受理分配":
-                caseLogRecord.setCaseNodeName("受理分配");
-                caseLogRecord.setContent("法律顾问将进行受理分配");
-                break;
-            case "选择调解员":
-                caseLogRecord.setCaseNodeName("选择调解员");
-                caseLogRecord.setContent("申请人正在进行选择调解员");
-                break;
-            case "核实调解员":
-                caseLogRecord.setCaseNodeName("核实调解员");
-                caseLogRecord.setContent("法律顾问正在进行核实调解员");
-                break;
-            case "确认调解员":
-                caseLogRecord.setCaseNodeName("确认调解员");
-                caseLogRecord.setContent("部门长正在进行确认调解员");
-                break;
-            case "调解":
-                caseLogRecord.setCaseNodeName("调解");
-                caseLogRecord.setContent("法律顾问正在进行调解");
-                break;
-            case "确认调解书":
-                caseLogRecord.setCaseNodeName("确认调解书");
-                caseLogRecord.setContent("法律顾问正在进行确认调解书");
-                break;
-            case "签名":
-                caseLogRecord.setCaseNodeName("签名");
-                caseLogRecord.setContent("申请人、被申请人正在进行签名");
-                break;
-            case "用印申请":
-                caseLogRecord.setCaseNodeName("用印申请");
-                caseLogRecord.setContent("法律顾问正在进行确认用印申请");
-                break;
-            case "用印":
-                caseLogRecord.setCaseNodeName("用印");
-                caseLogRecord.setContent("部门长正在进行用印");
-                break;
-            case "归档":
-                caseLogRecord.setCaseNodeName("归档");
-                caseLogRecord.setContent("法律顾问正在进行归档");
-                break;
-            case "签收":
-                caseLogRecord.setCaseNodeName("签收");
-                caseLogRecord.setContent("申请人、被申请人正在进行签收");
-                break;
-            default:
-                caseLogRecord.setCaseNodeName("无案件状态");
-                caseLogRecord.setContent("无操作内容");
-
-        }
-        return caseLogRecord;
-
-    }
-
 
 
 

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/mscase/impl/VideoConferenceServiceImpl.java

                     String reportStatus = jsonObject.getStr("report_status");
                     String description = jsonObject.getStr("description");
                     System.out.println(description);
-                    // 查询sid对应的短信，更新短信状态
-                 //   SmsSendRecord smsSendRecord=  smsRecordMapper.selectBySId(jsonObject.getStr("sid"));
-                 //   if(smsSendRecord!=null){
-                     //   if(jsonObject.get("report_status")!=null && jsonObject.getStr("report_status").equals("SUCCESS")){
-                    //        smsSendRecord.setSendStatus(SMSStatusEnum.SUCCESS.getCode());
-                    //    }else {
-                      //      smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
-                     //   }
-                //    }
                 }
             }
         }
             if(StrUtil.isEmpty(caseApplication.getCaseSource())){
                 List<MsCaseAttach> existAttach = caseAttachMapper.listCaseAttachByCaseIdAndType(reservedConferenceVO.getCaseId(), AnnexTypeEnum.MEDIATE.getCode());
                 if(CollectionUtil.isNotEmpty(existAttach)){
-                    // todo 对接北明，同步案件状态，删除
+                    //  对接北明，同步案件状态，删除
                     for (MsCaseAttach msCaseAttach : existAttach) {
                         if(StrUtil.isEmpty(msCaseAttach.getOtherSysFileId())||StrUtil.isEmpty(msCaseAttach.getAnnexPath())){
                             continue;
                     .annexPath(fileName)
                     .annexType(AnnexTypeEnum.MEDIATE.getCode())
                     .build();
-            // todo 对接北明，调用上传附件接口
+            //  对接北明，调用上传附件接口
 
             if(StrUtil.isEmpty(caseApplication.getCaseSource()) ) {
                 String templatePath = "/home/ruoyi" + caseAttach.getAnnexPath();
                                 .annexPath(annexName)
                                 .annexType(AnnexTypeEnum.MEETING_VIDEO.getCode())
                                 .build();
-                        // todo 对接北明，调用上传附件接口
+                        //  对接北明，调用上传附件接口
 
                         if(StrUtil.isEmpty(caseApplication.getCaseSource()) ) {
                             String templatePath = "/home/ruoyi" + caseAttach.getAnnexPath();

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/shortmessage/ShortMessageService.java

 package com.ruoyi.wisdomarbitrate.service.shortmessage;
 
 import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.system.domain.entity.sms.MsSmsSendRecordParam;
 import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
 import com.ruoyi.wisdomarbitrate.domain.vo.shortmessage.MeetingInfoVO;
 import com.ruoyi.wisdomarbitrate.domain.vo.shortmessage.ReSendMessageVO;
 
+import java.util.List;
+
 public interface ShortMessageService {
+    public List<SmsSendRecord> smsSendRecordList(SmsSendRecord smsSendRecord);
+
     /**
      * 新增发送历史记录
      */
-    void insertShortMessageHistoryRecord(SmsSendRecord smsSendRecord);
+    void insertShortMessageHistoryRecord(SmsSendRecord smsSendRecord,List<MsSmsSendRecordParam> recordParams);
 
     /**
      * 重新发送短信

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/shortmessage/impl/ShortMessageServiceImpl.java

 package com.ruoyi.wisdomarbitrate.service.shortmessage.impl;
 
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.json.JSONObject;
 import com.ruoyi.common.constant.Constants;
 import com.ruoyi.common.core.domain.AjaxResult;
 import com.ruoyi.common.enums.SMSStatusEnum;
-import com.ruoyi.common.utils.SmsUtils;
 import com.ruoyi.system.domain.entity.shortmessage.MeetingInfo;
 import com.ruoyi.system.domain.entity.shortmessage.MsSmsSendHistoryRecord;
+import com.ruoyi.system.domain.entity.sms.MsSmsSendHistoryRecordParam;
+import com.ruoyi.system.domain.entity.sms.MsSmsSendRecordParam;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplate;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam;
 import com.ruoyi.system.mapper.shortmessage.MeetingInfoMapper;
 import com.ruoyi.system.mapper.shortmessage.MsSmsSendHistoryRecordMapper;
+import com.ruoyi.system.mapper.sms.MsSmsSendHistoryRecordParamMapper;
+import com.ruoyi.system.mapper.sms.MsSmsSendRecordParamMapper;
+import com.ruoyi.system.mapper.sms.MsSmsTemplateMapper;
+import com.ruoyi.system.mapper.sms.MsSmsTemplateParamMapper;
 import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
 import com.ruoyi.wisdomarbitrate.domain.vo.shortmessage.MeetingInfoVO;
 import com.ruoyi.wisdomarbitrate.domain.vo.shortmessage.ReSendMessageVO;
+import com.ruoyi.wisdomarbitrate.mapper.sendrecord.SmsRecordMapper;
 import com.ruoyi.wisdomarbitrate.service.shortmessage.ShortMessageService;
+import com.ruoyi.wisdomarbitrate.utils.SmsUtils;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tk.mybatis.mapper.entity.Example;
 
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
+import java.text.MessageFormat;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @Service
 public class ShortMessageServiceImpl implements ShortMessageService {
     MsSmsSendHistoryRecordMapper msSmsSendHistoryRecordMapper;
     @Autowired
     MeetingInfoMapper meetingInfoMapper;
+    @Autowired
+    SmsRecordMapper smsRecordMapper;
+    @Autowired
+    MsSmsTemplateMapper templateMapper;
+    @Autowired
+    MsSmsTemplateParamMapper templateParamMapper;
+    @Autowired
+    MsSmsSendRecordParamMapper recordParamMapper;
+    @Autowired
+    MsSmsSendHistoryRecordParamMapper historyRecordParamMapper;
+
+    @Override
+    public List<SmsSendRecord> smsSendRecordList(SmsSendRecord smsSendRecord) {
+        List<SmsSendRecord> records = smsRecordMapper.getSmsSendRecord(smsSendRecord);
+        if(CollectionUtil.isEmpty(records)){
+            return null;
+        }
+        List<Long> templateIds = records.stream().map(SmsSendRecord::getMsSmsTemplateId).collect(Collectors.toList());
+        if(CollectionUtil.isEmpty(templateIds)){
+            return records;
+        }
+        List<Long> ids = records.stream().map(SmsSendRecord::getId).collect(Collectors.toList());
+        // 查询记录表参数值
+        Example recordParamExam = new Example(MsSmsSendRecordParam.class);
+        recordParamExam.createCriteria().andIn("smsRecordId", ids);
+        List<MsSmsSendRecordParam> recordParams = recordParamMapper.selectByExample(recordParamExam);
+        if(CollectionUtil.isEmpty(recordParams)){
+            return records;
+        }
+        // 根据模板id查询模板参数
+        Example templateParamExam = new Example(MsSmsTemplateParam.class);
+        templateParamExam.createCriteria().andIn("smsTemplateId", templateIds);
+        List<MsSmsTemplateParam> templateParams = templateParamMapper.selectByExample(templateParamExam);
+        if(CollectionUtil.isEmpty(templateParams)){
+            return records;
+        }
+        // 根据模板id对模板参数分组
+        Map<Long, List<MsSmsTemplateParam>> templateParamMap = templateParams.stream().collect(Collectors.groupingBy(MsSmsTemplateParam::getSmsTemplateId));
+
+        // 根据记录id分组
+        Map<Long, List<String>> recordParamContentMap = new HashMap<>();
+        for (MsSmsSendRecordParam recordParam : recordParams) {
+            List<String> list = recordParamContentMap.get(recordParam.getSmsRecordId());
+            if(CollectionUtil.isEmpty(list)){
+                list=new ArrayList<>();
+            }
+            list.add(recordParam.getParamValue());
+            recordParamContentMap.put(recordParam.getSmsRecordId(),list);
+        }
+        // 根据模板id查询模板
+        Example templateExam = new Example(MsSmsTemplate.class);
+        templateExam.createCriteria().andIn("id", templateIds);
+        List<MsSmsTemplate> templates = templateMapper.selectByExample(templateExam);
+        if(CollectionUtil.isEmpty(templates)){
+            return records;
+        }
+        // 根据主键id获取模板内容
+        Map<Long, String> templateMap = templates.stream().collect(Collectors.toMap(MsSmsTemplate::getId, MsSmsTemplate::getContent, (k1, k2) -> k2));
+        Map<Long, String> templateIdMap = templates.stream().collect(Collectors.toMap(MsSmsTemplate::getId, MsSmsTemplate::getTemplateId, (k1, k2) -> k2));
+        // 组装模板内容
+        for (SmsSendRecord record : records) {
+            if(record.getMsSmsTemplateId()==null){
+                continue;
+            }
+            if(!templateMap.containsKey(record.getMsSmsTemplateId())){
+                continue;
+            }
+
+            if(!recordParamContentMap.containsKey(record.getId())){
+                continue;
+            }
+            if(templateIdMap.containsKey(record.getMsSmsTemplateId())){
+              record.setTemplateId(templateIdMap.get(record.getMsSmsTemplateId()));
+            }
+            String templateContent = templateMap.get(record.getMsSmsTemplateId());
+            record.setTemplateContent(templateContent);
+            List<String> recordParamList = recordParamContentMap.get(record.getId());
+            if(recordParamContentMap.containsKey(record.getId()) && templateParamMap.containsKey(record.getMsSmsTemplateId())){
+                List<MsSmsTemplateParam> templateParamList = templateParamMap.get(record.getMsSmsTemplateId());
+                for (int i = 0; i < templateParamList.size(); i++) {
+                    MsSmsTemplateParam templateParam = templateParamList.get(i);
+                    templateParam.setParamValue(recordParamContentMap.get(record.getId()).get(i));
+                }
+                record.setTemplateParams(templateParamList);
+
+            }
+            // 按顺序替换占位符
+            if(CollectionUtil.isNotEmpty(recordParamList)){
+                recordParamList.add(0,"0");
+
+                // 将List<String>转换为String[]数组
+                String[] paramArray = recordParamList.toArray(new String[recordParamList.size()]);
+                String formattedMessage = MessageFormat.format(templateContent, paramArray);
+                record.setSendContent(formattedMessage);
+            }
 
+
+        }
+
+        return records;
+    }
     /**
      * 新增发送历史记录
      *
      * @param smsSendRecord
      */
+    @Transactional
     @Override
-    public void insertShortMessageHistoryRecord(SmsSendRecord smsSendRecord) {
-        if (smsSendRecord != null) {
-            MsSmsSendHistoryRecord historyRecord = new MsSmsSendHistoryRecord();
-            BeanUtils.copyProperties(smsSendRecord, historyRecord);
+    public void insertShortMessageHistoryRecord(SmsSendRecord smsSendRecord,List<MsSmsSendRecordParam> recordParams) {
+        if(smsSendRecord!=null){
+            MsSmsSendHistoryRecord historyRecord=new MsSmsSendHistoryRecord();
+            BeanUtils.copyProperties(smsSendRecord,historyRecord);
             historyRecord.setId(null);
             historyRecord.setParentId(smsSendRecord.getId());
-            msSmsSendHistoryRecordMapper.insert(historyRecord);
+            int i = msSmsSendHistoryRecordMapper.insert(historyRecord);
+            if(i>0 && CollectionUtil.isNotEmpty(recordParams)){
+                // 新增参数表
+                List<MsSmsSendHistoryRecordParam> historyRecordParams = new ArrayList<>();
+                for (MsSmsSendRecordParam templateParam : recordParams) {
+                    MsSmsSendHistoryRecordParam recordParam = new MsSmsSendHistoryRecordParam();
+                    BeanUtils.copyProperties(templateParam,recordParam);
+                    recordParam.setId(null);
+                    recordParam.setSmsRecordHistoryId(historyRecord.getId());
+                    historyRecordParams.add(recordParam);
+                }
+                historyRecordParamMapper.batchInsert(historyRecordParams);
+            }
         }
     }
 
      */
     @Override
     public AjaxResult reSendShortMessage(ReSendMessageVO reSendMessageVO) {
-        if (reSendMessageVO != null && reSendMessageVO.getTemplateId() != null && reSendMessageVO.getPhone() != null && reSendMessageVO.getParamValues() != null && reSendMessageVO.getParamValues().size() > 0) {
+        if (reSendMessageVO != null && reSendMessageVO.getTemplateId() != null && reSendMessageVO.getPhone() != null && reSendMessageVO.getTemplateParams() != null && reSendMessageVO.getTemplateParams().size() > 0 && reSendMessageVO.getId() != null) {
+            // 根据id查询短信记录
+            SmsSendRecord smsSendRecord = smsRecordMapper.selectById(reSendMessageVO.getId());
+            if(smsSendRecord == null){
+                return AjaxResult.warn("短信记录不存在");
+            }
+
             SmsUtils.SendSmsRequest request = new SmsUtils.SendSmsRequest();
             request.setTemplateId(reSendMessageVO.getTemplateId());
             request.setPhone(reSendMessageVO.getPhone());
-            String[] messageContent = reSendMessageVO.getParamValues().toArray(new String[0]);
-            System.out.println(reSendMessageVO.getTemplateId());
-            System.out.println(reSendMessageVO.getPhone());
-            System.out.println(messageContent);
+            List<String> paramsList = reSendMessageVO.getTemplateParams().stream().map(MsSmsTemplateParam::getParamValue).collect(Collectors.toList());
+            String[] messageContent = paramsList.toArray(new String[0]);
             request.setTemplateParamSet(messageContent);
             JSONObject resultObj = SmsUtils.sendSms(request);
+            smsSendRecord.setSendTime(new Date());
+            // 修改sid和状态
             if (resultObj.get("status") != null && !resultObj.get("status").equals(SMSStatusEnum.FAIL.getCode())) {
+                smsSendRecord.setSendStatus(SMSStatusEnum.SENDING.getCode());
+                smsSendRecord.setSid(resultObj.get("sid")==null?null:resultObj.get("sid").toString());
+                smsSendRecord.setReason(null);
+                // 修改
+                smsRecordMapper.update(smsSendRecord);
+
                 return AjaxResult.success("重新发送成功");
             } else {
+                smsSendRecord.setSid(resultObj.get("sid")==null?null:resultObj.get("sid").toString());
+                smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
+                smsSendRecord.setSid(resultObj.get("reason")==null?null:resultObj.get("reason").toString());
+                // 修改
+                smsRecordMapper.update(smsSendRecord);
                 return AjaxResult.warn("重新发送失败");
             }
         } else {

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/sms/SMSTemplateService.java

+package com.ruoyi.wisdomarbitrate.service.sms;
+
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplate;
+
+import java.util.List;
+
+/**
+ * @Classname SMSTemplateService
+ * @Description TODO
+ * @Version 1.0.0
+ * @Date 2024/4/16 11:39
+ * @Created wangqiong
+ */
+public interface SMSTemplateService {
+    List<MsSmsTemplate> page();
+
+    AjaxResult insert(MsSmsTemplate template);
+
+    AjaxResult delete(Long id);
+}

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/service/sms/impl/SMSTemplateServiceImpl.java

+package com.ruoyi.wisdomarbitrate.service.sms.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplate;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam;
+import com.ruoyi.system.mapper.sms.MsSmsTemplateMapper;
+import com.ruoyi.system.mapper.sms.MsSmsTemplateParamMapper;
+import com.ruoyi.wisdomarbitrate.service.sms.SMSTemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import tk.mybatis.mapper.entity.Example;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Classname SMSTemplateServiceImpl
+ * @Description TODO
+ * @Version 1.0.0
+ * @Date 2024/4/16 11:40
+ * @Created wangqiong
+ */
+@Service
+public class SMSTemplateServiceImpl implements SMSTemplateService {
+    @Autowired
+    private MsSmsTemplateMapper templateMapper;
+    @Autowired
+    private MsSmsTemplateParamMapper templateParamMapper;
+
+    @Override
+    public List<MsSmsTemplate> page() {
+        // 分页查询模板
+        Example templateExam = new Example(MsSmsTemplate.class);
+        List<MsSmsTemplate> templates = templateMapper.selectByExample(templateExam);
+        if(CollectionUtil.isEmpty(templates)){
+            return null;
+        }
+
+        List<Long> templateIds = templates.stream().map(MsSmsTemplate::getId).collect(Collectors.toList());
+        // 查询参数
+        Example templateParamExam = new Example(MsSmsTemplateParam.class);
+        templateParamExam.createCriteria().andIn("smsTemplateId", templateIds);
+        List<MsSmsTemplateParam> templateParams = templateParamMapper.selectByExample(templateParamExam);
+        // 根据模板id对模板参数分组
+        Map<Long, List<MsSmsTemplateParam>> templateParamMap = templateParams.stream().collect(Collectors.groupingBy(MsSmsTemplateParam::getSmsTemplateId));
+        for (MsSmsTemplate template : templates) {
+            if(templateParamMap.containsKey(template.getId())){
+                template.setTemplateParams(templateParamMap.get(template.getId()));
+            }
+        }
+        return templates;
+    }
+
+    /**
+     * 新增或者修改
+     * @param template
+     * @return
+     */
+    @Override
+    public AjaxResult insert(MsSmsTemplate template) {
+        if(template.getId() == null){
+            templateMapper.insert(template);
+
+        }else{
+            templateMapper.updateByPrimaryKey(template);
+            for (MsSmsTemplateParam templateParam : template.getTemplateParams()) {
+                templateParam.setSmsTemplateId(template.getId());
+            }
+            // todo 先删除
+            Example paramExam = new Example(MsSmsTemplateParam.class);
+            paramExam.createCriteria().andEqualTo("smsTemplateId", template.getId());
+            templateParamMapper.deleteByExample(paramExam);
+        }
+        // 新增参数表
+        if(CollectionUtil.isNotEmpty(template.getTemplateParams())){
+            for (MsSmsTemplateParam templateParam : template.getTemplateParams()) {
+                templateParam.setSmsTemplateId(template.getId());
+            }
+            templateParamMapper.batchInsert(template.getTemplateParams());
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult delete(Long id) {
+        // 删除
+        templateMapper.deleteByPrimaryKey(id);
+        // 删除参数表
+        Example paramExam = new Example(MsSmsTemplateParam.class);
+        paramExam.createCriteria().andEqualTo("smsTemplateId", id);
+        templateParamMapper.deleteByExample(paramExam);
+        return AjaxResult.success();
+    }
+}

ruoyi-system/src/main/java/com/ruoyi/wisdomarbitrate/utils/SmsUtils.java

+package com.ruoyi.wisdomarbitrate.utils;
+
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.spring.SpringUtil;
+import cn.hutool.json.JSONObject;
+import com.ruoyi.common.enums.SMSStatusEnum;
+import com.ruoyi.common.utils.SecurityUtils;
+import com.ruoyi.common.utils.ThreadUtil;
+import com.ruoyi.system.domain.entity.sms.MsSmsSendRecordParam;
+import com.ruoyi.system.domain.entity.sms.MsSmsTemplate;
+import com.ruoyi.system.mapper.SysRoleMapper;
+import com.ruoyi.system.mapper.SysUserMapper;
+import com.ruoyi.system.mapper.flow.MsCaseFlowRoleSmsRelatedMapper;
+import com.ruoyi.system.mapper.sms.MsSmsSendRecordParamMapper;
+import com.ruoyi.system.mapper.sms.MsSmsTemplateMapper;
+import com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord;
+import com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseApplication;
+import com.ruoyi.wisdomarbitrate.mapper.sendrecord.SmsRecordMapper;
+import com.ruoyi.wisdomarbitrate.service.shortmessage.ShortMessageService;
+import com.tencentcloudapi.common.Credential;
+import com.tencentcloudapi.common.exception.TencentCloudSDKException;
+import com.tencentcloudapi.sms.v20210111.SmsClient;
+import com.tencentcloudapi.sms.v20210111.models.SendSmsResponse;
+import com.tencentcloudapi.sms.v20210111.models.SendStatus;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import lombok.var;
+import tk.mybatis.mapper.entity.Example;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+
+@Slf4j
+public class SmsUtils {
+    //应用id
+    private static final String SDK_APP_ID = "1400854852";
+    //API的SecretId
+    private static final String SECRET_ID = "AKIDeEf2A8uX1HSainvvnXAc3X9ZlhtyvkMp";
+    //API的SecretKey
+    private static final String SECRET_KEY = "QjphKo8zkHZigT8j9PVtFPJyfIvO3d6V";
+    //签名内容
+    private static final String SIGN_NAME = "乙巢智慧仲裁网";
+    private static SmsRecordMapper recordMapper = SpringUtil.getBean(SmsRecordMapper.class);
+    private static MsSmsSendRecordParamMapper recordParamMapper = SpringUtil.getBean(MsSmsSendRecordParamMapper.class);
+    private static MsSmsTemplateMapper templateMapper = SpringUtil.getBean(MsSmsTemplateMapper.class);
+    private static SysUserMapper sysUserMapper = SpringUtil.getBean(SysUserMapper.class);
+    private static MsCaseFlowRoleSmsRelatedMapper flowRoleRelatedMapper = SpringUtil.getBean(MsCaseFlowRoleSmsRelatedMapper.class);
+    private static SysRoleMapper roleMapper = SpringUtil.getBean(SysRoleMapper.class);
+    private static ShortMessageService shortMessageService = SpringUtil.getBean(ShortMessageService.class);
+
+    public static JSONObject sendSms(SendSmsRequest request) {
+        JSONObject jsonObject = new JSONObject();
+        Credential cred = new Credential(SECRET_ID, SECRET_KEY);
+
+        SmsClient client = new SmsClient(cred, "ap-guangzhou");
+
+        final var req = new com.tencentcloudapi.sms.v20210111.models.SendSmsRequest();
+        req.setPhoneNumberSet(new String[]{"+86" + request.getPhone()});
+        req.setSmsSdkAppId(SDK_APP_ID);
+        req.setSignName(SIGN_NAME);
+        req.setTemplateId(request.getTemplateId());
+        req.setTemplateParamSet(request.getTemplateParamSet());
+        SendSmsResponse res = null;
+        try {
+            res = client.SendSms(req);
+        } catch (TencentCloudSDKException e) {
+            log.error("发送短信出错：", e);
+            jsonObject.set("status", SMSStatusEnum.FAIL.getCode());
+            jsonObject.set("reason",e.getMessage());
+            return jsonObject;
+        }
+        SendStatus sendStatus = res.getSendStatusSet()[0];
+        log.info("发送短信结果：Code={}, Message={}", sendStatus.getCode(), sendStatus.getMessage());
+
+        if (Objects.nonNull(res.getSendStatusSet()) && res.getSendStatusSet().length > 0 && "Ok".equals(res.getSendStatusSet()[0].getCode())) {
+            jsonObject.set("status", SMSStatusEnum.SENDING.getCode());
+        } else {
+            jsonObject.set("status", SMSStatusEnum.FAIL.getCode());
+        }
+        jsonObject.set("sid", sendStatus.getSerialNo());
+        return jsonObject;
+    }
+
+    public static void sendSms(MsCaseApplication application, String templateId, String phone, String[] templateParamSet) {
+        if(application==null||StrUtil.isEmpty(templateId)||StrUtil.isEmpty(phone)||templateParamSet==null||templateParamSet.length==0){
+            return;
+        }
+        Example templateExam = new Example(MsSmsTemplate.class);
+        templateExam.createCriteria().andEqualTo("templateId", templateId);
+        List<MsSmsTemplate> templates = templateMapper.selectByExample(templateExam);
+        if (CollectionUtil.isEmpty(templates)) {
+            return ;
+        }
+        MsSmsTemplate template = templates.get(0);
+        SendSmsRequest request = new SendSmsRequest(phone, templateId, templateParamSet, application.getId());
+        Credential cred = new Credential(SECRET_ID, SECRET_KEY);
+
+        SmsClient client = new SmsClient(cred, "ap-guangzhou");
+
+        final var req = new com.tencentcloudapi.sms.v20210111.models.SendSmsRequest();
+        req.setPhoneNumberSet(new String[]{"+86" + request.getPhone()});
+        req.setSmsSdkAppId(SDK_APP_ID);
+        req.setSignName(SIGN_NAME);
+        req.setTemplateId(request.getTemplateId());
+        req.setTemplateParamSet(request.getTemplateParamSet());
+        sendSms(client,template,application,phone, templateParamSet,req);
+    }
+
+
+    private static void sendSms(SmsClient client,MsSmsTemplate template, MsCaseApplication application, String phone, String[] templateParamSet, com.tencentcloudapi.sms.v20210111.models.SendSmsRequest req) {
+        SmsSendRecord smsSendRecord=new SmsSendRecord();
+        smsSendRecord.setMsSmsTemplateId(template.getId());
+        smsSendRecord.setCaseId(application.getId());
+        smsSendRecord.setCaseNum(application.getCaseNum());
+        smsSendRecord.setSendTime(new Date());
+        smsSendRecord.setPhone(phone);
+        smsSendRecord.setCreateTime(new Date());
+        smsSendRecord.setCreateBy(SecurityUtils.getUsername());
+        //    SendSmsRequest request = new SendSmsRequest(phone, template.getTemplateId(), templateParamSet, application.getId());
+        req.setPhoneNumberSet(new String[]{"+86" + phone});
+        req.setTemplateId(template.getTemplateId());
+        req.setTemplateParamSet(templateParamSet);
+        try {
+            SendSmsResponse res=client.SendSms(req);
+            SendStatus sendStatus = res.getSendStatusSet()[0];
+            if (Objects.nonNull(res.getSendStatusSet()) && res.getSendStatusSet().length > 0 && "Ok".equals(res.getSendStatusSet()[0].getCode())) {
+                smsSendRecord.setSendStatus( SMSStatusEnum.SENDING.getCode());
+            } else {
+                smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
+                smsSendRecord.setReason(sendStatus.getMessage());
+            }
+            smsSendRecord.setSid(sendStatus.getSerialNo());
+        } catch (TencentCloudSDKException e) {
+            smsSendRecord.setSendStatus(SMSStatusEnum.FAIL.getCode());
+            smsSendRecord.setReason(e.getMessage());
+        }
+        int i = recordMapper.saveSmsSendRecord(smsSendRecord);
+        if(i>0){
+            List<MsSmsSendRecordParam> recordParams=new ArrayList<>();
+            for (String paramValue : templateParamSet) {
+                // 新增参数
+                MsSmsSendRecordParam recordParam = new MsSmsSendRecordParam();
+                recordParam.setSmsRecordId(smsSendRecord.getId());
+                recordParam.setParamValue(paramValue);
+                recordParams.add(recordParam);
+            }
+            ExecutorService executor = ThreadUtil.createThreadPool();
+            CompletableFuture.runAsync(() -> {
+                recordParamMapper.batchInsert(recordParams);
+
+            }, executor);
+            // 新增历史记录表
+            CompletableFuture.runAsync(() -> {
+                shortMessageService.insertShortMessageHistoryRecord(smsSendRecord,recordParams);
+
+            }, executor);
+
+        }
+    }
+
+    /**
+     * 参数对象
+     */
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class SendSmsRequest {
+        /**
+         * 电话
+         */
+        private String phone;
+
+        /**
+         * 模板 ID: 必须填写已审核通过的模板 ID
+         */
+        private String templateId;
+
+        /**
+         * 模板参数: 模板参数的个数需要与 TemplateId 对应模板的变量个数保持一致，若无模板参数，则设置为空
+         */
+        private String[] templateParamSet;
+        private Long caseId;
+
+    }
+}

ruoyi-system/src/main/resources/com/ruoyi/system/mapper/log/MsRequestLogMapper.xml

       WARNING - @mbg.generated
     -->
     <id column="id" jdbcType="BIGINT" property="id" />
-    <result column="status" jdbcType="BIGINT" property="status" />
+    <result column="status" jdbcType="INTEGER" property="status" />
     <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
     <result column="request_url" jdbcType="LONGVARCHAR" property="requestUrl" />
     <result column="content" jdbcType="LONGVARCHAR" property="content" />
     <result column="reason" jdbcType="LONGVARCHAR" property="reason" />
+    <result column="return_content" jdbcType="LONGVARCHAR" property="returnContent" />
   </resultMap>
 </mapper>

ruoyi-system/src/main/resources/com/ruoyi/system/mapper/sms/MsSmsSendHistoryRecordParamMapper.xml

+<?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="com.ruoyi.system.mapper.sms.MsSmsSendHistoryRecordParamMapper">
+  <resultMap id="BaseResultMap" type="com.ruoyi.system.domain.entity.sms.MsSmsSendHistoryRecordParam">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <id column="id" jdbcType="BIGINT" property="id" />
+    <result column="sms_record_history_id" jdbcType="BIGINT" property="smsRecordHistoryId" />
+    <result column="param_value" jdbcType="LONGVARCHAR" property="paramValue" />
+  </resultMap>
+</mapper>

ruoyi-system/src/main/resources/com/ruoyi/system/mapper/sms/MsSmsSendRecordParamMapper.xml

+<?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="com.ruoyi.system.mapper.sms.MsSmsSendRecordParamMapper">
+  <resultMap id="BaseResultMap" type="com.ruoyi.system.domain.entity.sms.MsSmsSendRecordParam">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <id column="id" jdbcType="INTEGER" property="id" />
+    <result column="sms_record_id" jdbcType="VARCHAR" property="smsRecordId" />
+    <result column="param" jdbcType="VARCHAR" property="param" />
+    <result column="param_value" jdbcType="LONGVARCHAR" property="paramValue" />
+  </resultMap>
+</mapper>

ruoyi-system/src/main/resources/com/ruoyi/system/mapper/sms/MsSmsTemplateMapper.xml

+<?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="com.ruoyi.system.mapper.sms.MsSmsTemplateMapper">
+  <resultMap id="BaseResultMap" type="com.ruoyi.system.domain.entity.sms.MsSmsTemplate">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <id column="id" jdbcType="INTEGER" property="id" />
+    <result column="template_id" jdbcType="VARCHAR" property="templateId" />
+    <result column="name" jdbcType="VARCHAR" property="name" />
+  </resultMap>
+</mapper>

ruoyi-system/src/main/resources/com/ruoyi/system/mapper/sms/MsSmsTemplateParamMapper.xml

+<?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="com.ruoyi.system.mapper.sms.MsSmsTemplateParamMapper">
+  <resultMap id="BaseResultMap" type="com.ruoyi.system.domain.entity.sms.MsSmsTemplateParam">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <id column="id" jdbcType="INTEGER" property="id" />
+    <result column="sms_template_id" jdbcType="VARCHAR" property="smsTemplateId" />
+    <result column="param" jdbcType="VARCHAR" property="param" />
+  </resultMap>
+</mapper>

ruoyi-system/src/main/resources/mapper/system/SysMenuMapper.xml

 			 left join ms_sys_role_menu rm on m.menu_id = rm.menu_id
 			 left join ms_sys_user_role ur on rm.role_id = ur.role_id
 			 left join ms_sys_role r on r.role_id = ur.role_id
-		where m.status = '0' and r.status = '0' and ur.user_id = #{userId}
+		where m.status = '0' and r.status = '0' and ur.user_id = #{userId} and m.perms is not null and m.perms!=''
 	</select>
 	
 	<select id="selectMenuPermsByRoleId" parameterType="Long" resultType="String">

ruoyi-system/src/main/resources/mapper/system/SysUserMapper.xml

         <result property="updateTime"   column="update_time"  />
         <result property="remark"       column="remark"       />
         <result property="specialty"       column="specialty"       />
+        <result property="birth"       column="birth"       />
+        <result property="home"       column="home"       />
+        <result property="address"       column="address"       />
 <!--        <collection property="dept"    javaType="com.ruoyi.common.core.domain.entity.SysDept"         resultMap="deptResult" />-->
         <collection  property="roles"   javaType="java.util.List"  resultMap="RoleResult" />
     </resultMap>
 	
 	<sql id="selectUserVo">
         select u.user_id, u.user_name, u.nick_name,u.specialty, u.id_card,u.email, u.avatar, u.phonenumber, u.password, u.sex, u.status, u.del_flag, u.login_ip, u.login_date, u.create_by, u.create_time, u.remark,
-        r.role_id, r.role_name, r.role_key, r.role_sort, r.data_scope, r.status as role_status,u.id_card,u.id_type,u.nationality
+        r.role_id, r.role_name, r.role_key, r.role_sort, r.data_scope, r.status as role_status,u.birth,u.id_type,u.nationality,u.home,u.address
         from ms_sys_user u
 		    left join ms_sys_user_role ur on u.user_id = ur.user_id
 		    left join ms_sys_role r on r.role_id = ur.role_id

ruoyi-system/src/main/resources/mapper/wisdomarbitrate/mscase/MsCaseAffiliateMapper.xml

       u.nickName name,
       u.id_type idType,
       r.role_name roleName,
-      GROUP_CONCAT( DISTINCT CASE WHEN c.organize_flag = 0 THEN u.nick_name ELSE d.dept_name END ) AS name,
+      GROUP_CONCAT( DISTINCT CASE WHEN a1.organize_flag = 0 THEN u.nick_name ELSE d.dept_name END ) AS name,
     (select GROUP_CONCAT( DISTINCT u1.nick_name ) FROM
 
      ms_case_affiliate a1
     group by a.case_appli_id
   </select>
     <select id="selectByCaseId" resultType="com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseAffiliate">
-        select c.id caseAppliId,a.id,a.role_type roleType,a.group_order groupOrder,a.operator_flag operatorFlag,d.code,d.comp_legal_person compLegalPerson,u.id_card idCard,u.phonenumber phone,
-            u.email,
+        select c.id caseAppliId,r.role_id roleId,a.id,a.role_type roleType,a.group_order groupOrder,a.operator_flag operatorFlag,d.code,d.comp_legal_person compLegalPerson,u.id_card idCard,u.phonenumber phone,
+            u.email,u.user_name userName,
                (case when a.user_id is null then d.dept_name else u.nick_name end)  name,
                (case when a.user_id is null then d.home else u.home end) home,
                (case when a.user_id is null then d.address else u.address end) address,
                (case when a.user_id is null then d.nationality else u.nationality end) nationality,
-                u.sex,u.id_type idType,u.birth,a.user_id userId,c.organize_flag organizeFlag,c.case_source caseSource,d.dept_name applicantOrgName
+                u.sex,u.id_type idType,u.birth,a.user_id userId,a.organize_flag organizeFlag,c.case_source caseSource,d.dept_name applicantOrgName
         FROM
             ms_case_application c
                 JOIN ms_case_affiliate a ON a.case_appli_id=#{id} and c.id = a.case_appli_id
                 LEFT JOIN ms_sys_role r ON r.role_id = ur.role_id
                 LEFT JOIN ms_sys_dept d ON d.dept_id = a.applicant_dept_id
         where  c.id = #{id}
-        GROUP BY a.id order by a.id asc
+        GROUP BY a.id,r.role_id order by a.id asc
     </select>
     <select id="selectUserRoleByCaseIds" resultType="com.ruoyi.wisdomarbitrate.domain.entity.mscase.MsCaseAffiliate">
         select c.id caseAppliId,a.id,a.role_type roleType,a.group_order groupOrder,a.operator_flag operatorFlag,d.code,d.comp_legal_person compLegalPerson,u.id_card idCard,u.phonenumber phone,
         (case when a.user_id is null then d.home else u.home end) home,
         (case when a.user_id is null then d.address else u.address end) address,
         (case when a.user_id is null then d.nationality else u.nationality end) nationality,
-        u.sex,u.id_type idType,u.birth,r.role_name roleName,d.dept_name applicantOrgName,a.user_id userId,a.applicant_dept_id applicantDeptId,c.organize_flag organizeFlag,c.case_source caseSource
+        u.sex,u.id_type idType,u.birth,r.role_name roleName,d.dept_name applicantOrgName,a.user_id userId,a.applicant_dept_id applicantDeptId,a.organize_flag organizeFlag,c.case_source caseSource
         FROM
             ms_case_application c
                 JOIN ms_case_affiliate a ON  c.id = a.case_appli_id

ruoyi-system/src/main/resources/mapper/wisdomarbitrate/mscase/MsCaseApplicationMapper.xml

   <select id="list" resultType="com.ruoyi.wisdomarbitrate.domain.vo.mscase.MsCaseApplicationVO">
     select t.* from(
     SELECT
-    c.id,c.organize_flag organizeFlag,c.case_source caseSource,c.media_result mediaResult,c.room_id roomId,0 AS pendingStatus,
+    c.id,c.case_source caseSource,c.media_result mediaResult,c.room_id roomId,0 AS pendingStatus,
     c.case_flow_id caseFlowId,c.batch_number batchNumber,c.case_num caseNum,
     u1.nick_name mediatorName,c.hear_date hearDate,c.case_status_name caseStatusName,c.create_time createTime,
     c.mediation_method mediationMethod,
     c.id
     union
     SELECT
-    c.id,c.organize_flag organizeFlag,c.case_source caseSource,c.media_result mediaResult,c.room_id roomId,1 AS pendingStatus,
+    c.id,c.case_source caseSource,c.media_result mediaResult,c.room_id roomId,1 AS pendingStatus,
     c.case_flow_id caseFlowId,c.batch_number batchNumber,c.case_num caseNum,
     u1.nick_name mediatorName,c.hear_date hearDate,c.case_status_name caseStatusName,c.create_time createTime,
     c.mediation_method mediationMethod,
     ) t ORDER BY t.createTime desc,t.caseNum desc
 
   </select>
+  <select id="countCasePerson" resultType="java.lang.Long">
+    select c.id from ms_case_application c where c.mediator_id
+     in
+    <foreach collection="userIds" item="userId" open="(" separator="," close=")">
+      #{userId}
+    </foreach>
+    union ALL
+    select a.id from ms_case_affiliate a where a.user_id
+    in
+    <foreach collection="userIds" item="userId" open="(" separator="," close=")">
+      #{userId}
+    </foreach>
+    union all
+    SELECT id from ms_dept_identify where user_id
+    in
+    <foreach collection="userIds" item="userId" open="(" separator="," close=")">
+      #{userId}
+    </foreach>
+  </select>
+  <select id="selectCaseByDeptId" resultType="java.lang.Long">
+    select a.id from ms_case_affiliate a where a.applicant_dept_id=#{deptId}
+    union all
+    SELECT id from ms_dept_identify where dept_id=#{deptId}
+  </select>
 </mapper>

ruoyi-system/src/main/resources/mapper/wisdomarbitrate/sendrecord/SmsRecordMapper.xml

 
 <mapper namespace="com.ruoyi.wisdomarbitrate.mapper.sendrecord.SmsRecordMapper">
     <resultMap type="com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord" id="SmsSendRecordResult">
-        <id property="id" column="id"/>
-        <result property="caseId" column="case_appli_id"/>
-        <result property="caseNum" column="case_num"/>
-        <result property="phone" column="phone"/>
-        <result property="sendTime" column="send_time"/>
-        <result property="sendContent" column="send_content"/>
-        <result property="createTime" column="create_time"/>
-        <result property="updateTime" column="update_time"/>
-        <result property="createBy" column="create_by"/>
-        <result property="updateBy" column="update_by"/>
-        <result property="sendStatus" column="send_status"/>
-        <result property="sid" column="sid"/>
+        <id     property="id"       column="id"      />
+        <result property="caseId"       column="case_appli_id"      />
+        <result property="msSmsTemplateId"       column="ms_sms_template_id"      />
+        <result property="caseNum"       column="case_num"      />
+        <result property="phone"     column="phone"    />
+        <result property="sendTime"     column="send_time"    />
+        <result property="createTime"   column="create_time"  />
+        <result property="updateTime"   column="update_time"  />
+        <result property="createBy"   column="create_by"  />
+        <result property="updateBy"   column="update_by"  />
+        <result property="sendStatus"   column="send_status"  />
+        <result property="sid"   column="sid"  />
     </resultMap>
-    <insert id="saveSmsSendRecord" parameterType="com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord"
-            useGeneratedKeys="true" keyProperty="id">
+    <insert id="saveSmsSendRecord" parameterType="com.ruoyi.wisdomarbitrate.domain.dto.sendrecord.SmsSendRecord" useGeneratedKeys="true" keyProperty="id">
 
         insert into ms_sms_send_record(
         <if test="caseId != null ">case_appli_id,</if>
         <if test="caseNum != null ">case_num,</if>
         <if test="phone != null and phone != ''">phone,</if>
         <if test="sendTime != null ">send_time,</if>
-        <if test="sendContent != null ">send_content,</if>
+        <if test="msSmsTemplateId != null ">ms_sms_template_id,</if>
         <if test="createBy != null and createBy != ''">create_by,</if>
         <if test="sendStatus != null ">send_status,</if>
         sid,
         <if test="caseNum != null ">#{caseNum},</if>
         <if test="phone != null and phone != ''">#{phone},</if>
         <if test="sendTime != null ">#{sendTime},</if>
-        <if test="sendContent != null ">#{sendContent},</if>
+        <if test="msSmsTemplateId != null ">#{msSmsTemplateId},</if>
         <if test="createBy != null  and createBy != ''">#{createBy},</if>
         <if test="sendStatus != null ">#{sendStatus},</if>
         #{sid},
     <insert id="batchSaveSmsSendRecord">
 
         insert into ms_sms_send_record(
-        case_appli_id,
-        case_num,
-        phone,
-        send_time,
-        send_content,
-        create_by,
-        send_status,
+       case_appli_id,
+       case_num,
+       phone,
+       send_time,
+        ms_sms_template_id,
+       create_by,
+       send_status,
         create_time,
         sid,reason
         )values
         <foreach item="item" index="index" collection="list" separator=",">
-            (
-            #{item.caseId},
-            #{item.caseNum},
-            #{item.phone},
-            #{item.sendTime},
-            #{item.sendContent},
-            #{item.createBy},
-            #{item.sendStatus},
-            sysdate(),#{sid},#{reason}
-            )
+        (
+        #{item.caseId},
+        #{item.caseNum},
+        #{item.phone},
+        #{item.sendTime},
+        #{item.msSmsTemplateId},
+        #{item.createBy},
+        #{item.sendStatus},
+        sysdate(),#{sid},#{reason}
+        )
         </foreach>
     </insert>
 
             reason=#{reason}
         where sid = #{sid}
     </update>
-    <update id="updateSendContent">
+    <update id="update">
         update ms_sms_send_record
-        set send_content= #{sendContent},
-            update_time=#{updateTime}
+        <set>
+            <if test="caseId != null ">case_appli_id = #{caseId},</if>
+            <if test="caseNum != null and caseNum != '' ">case_num = #{caseNum},</if>
+            <if test="phone != null and phone != ''">phone = #{phone},</if>
+
+            <if test="sendTime != null ">send_time = #{sendTime},</if>
+            <if test="msSmsTemplateId != null ">ms_sms_template_id = #{msSmsTemplateId},
+            </if>
+            <if test="sendStatus != null ">send_status = #{sendStatus},</if>
+            <if test="sid != null and sid != '' ">sid = #{sid},</if>
+            reason = #{reason}
+        </set>
         where id = #{id}
     </update>