~liusheng/smartor.git

			@@ -1,7 +1,6 @@
			package com.ruoyi.web.component;

			import com.alibaba.fastjson2.JSON;
			import com.fasterxml.jackson.core.JsonProcessingException;
			import com.fasterxml.jackson.databind.ObjectMapper;
			import com.ruoyi.common.core.redis.RedisCache;
			import com.ruoyi.common.enums.ServiceFromEnum;
			@@ -13,7 +12,10 @@
			import com.smartor.domain.*;
			import com.smartor.mapper.IvrTaskMapper;
			import com.smartor.mapper.IvrTaskSingleMapper;
			import com.smartor.mapper.SvyTaskMapper;
			import com.smartor.mapper.SvyTaskSingleMapper;
			import com.smartor.service.IIvrTaskTemplateService;
			import com.smartor.service.ISvyTaskTemplateService;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			@@ -54,6 +56,14 @@

			private static RobotPhoneUtils robotPhoneUtils;

			@Autowired
			private SvyTaskMapper svyTaskMapper;

			@Autowired
			private SvyTaskSingleMapper svyTaskSingleMapper;

			@Autowired
			private ISvyTaskTemplateService iSvyTaskTemplateService;

			// 创建固定大小的线程池
			private static final ExecutorService executorService = Executors.newFixedThreadPool(10);
			@@ -102,28 +112,58 @@
			log.info("不是任务信息");
			return;
			}
			CommonTaskcallMQ ivrTaskcallMQ = null;
			CommonTaskcallMQ commonTaskcallMQ = null;
			try {
			ObjectMapper mapper = new ObjectMapper();
			try {
			if (!content.startsWith("{")) {
			ivrTaskcallMQ = mapper.readValue("{" + content + "}", CommonTaskcallMQ.class);
			commonTaskcallMQ = mapper.readValue("{" + content + "}", CommonTaskcallMQ.class);
			} else {
			ivrTaskcallMQ = mapper.readValue(content, CommonTaskcallMQ.class);
			commonTaskcallMQ = mapper.readValue(content, CommonTaskcallMQ.class);
			}
			} catch (JsonProcessingException e) {
			e.printStackTrace();

			if (commonTaskcallMQ.getTaskType() == 1) {
			//随访
			sfHandle((commonTaskcallMQ));
			} else if (commonTaskcallMQ.getTaskType() == 2) {
			//问卷
			wjHandle(commonTaskcallMQ);
			} else if (commonTaskcallMQ.getTaskType() == 3) {
			//宣教
			}
			//判断一下ivrTaskcallMQ中的stopstate是否与ivr_task中的一致，不一致，则说明是暂停了
			IvrTask ivrTask1 = ivrTaskMapper.selectIvrTaskByTaskid(ivrTaskcallMQ.getTaskid());
			if (ivrTask1.getStopState() != ivrTaskcallMQ.getStopState()) {


			} catch (Exception e) {
			Integer integer = redisCache.getCacheObject(commonTaskcallMQ.getTaskid().toString());
			if (integer != null && integer == 2) {
			//将消息从队列中删除
			} else if (integer == null) {
			redisCache.setCacheObject(commonTaskcallMQ.getTaskid().toString(), 1, 120, TimeUnit.MINUTES);
			} else {
			redisCache.setCacheObject(commonTaskcallMQ.getTaskid().toString(), integer + 1, 120, TimeUnit.MINUTES);
			}

			log.error("============消费失败,尝试消息补发再次消费!============== {}", e.getMessage());
			redisCache.setCacheObject(message.toString(), message.toString(), 60, TimeUnit.SECONDS);
			}

			}

			/**
			* 随访任务处理
			*
			* @param commonTaskcallMQ
			*/
			private void sfHandle(CommonTaskcallMQ commonTaskcallMQ) {
			//判断一下commonTaskcallMQ中的stopstate是否与ivr_task中的一致，不一致，则说明是暂停了
			IvrTask ivrTask1 = ivrTaskMapper.selectIvrTaskByTaskid(commonTaskcallMQ.getTaskid());
			if (ivrTask1.getStopState() != commonTaskcallMQ.getStopState()) {
			//将消息从队列中剔除
			return;
			}

			if (StringUtils.isNotEmpty(ivrTaskcallMQ.getPreachform())) {
			if (StringUtils.isNotEmpty(commonTaskcallMQ.getPreachform())) {
			//如何任务发送方式不为空
			String[] split = ivrTaskcallMQ.getPreachform().split(",");
			String[] split = commonTaskcallMQ.getPreachform().split(",");
			System.out.println("split的值为：" + split);
			for (String serviceFrom : split) {
			String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(serviceFrom));
			@@ -131,12 +171,12 @@

			//通过模板ID获取模板问题
			IvrTaskTemplateVO ivrTaskTemplateVO = new IvrTaskTemplateVO();
			ivrTaskTemplateVO.setID(Long.valueOf(ivrTaskcallMQ.getTemplateid()));
			ivrTaskTemplateVO.setID(Long.valueOf(commonTaskcallMQ.getTemplateid()));
			IvrTaskTemplateVO ivrTaskTemplateVO1 = ivrTaskTemplateService.selectInfoByCondition(ivrTaskTemplateVO);

			//通过任务ID拿到患者信息
			IvrTaskSingle ivrTaskcall = new IvrTaskSingle();
			ivrTaskcall.setTaskid(ivrTaskcallMQ.getTaskid());
			ivrTaskcall.setTaskid(commonTaskcallMQ.getTaskid());
			List<IvrTaskSingle> ivrTaskcalls = ivrTaskcallMapper.selectIvrTaskcallList(ivrTaskcall);
			if (descByCode.equals("电话")) {
			for (IvrTaskSingle ivrTaskcall1 : ivrTaskcalls) {
			@@ -188,22 +228,77 @@
			//通知 MQ 消息已被接收,可以ACK(从队列中删除)了（这个需要根据业务再去处理ACK）
			}
			}
			} catch (Exception e) {
			Integer integer = redisCache.getCacheObject(ivrTaskcallMQ.getTaskid().toString());
			if (integer != null && integer == 2) {
			//将消息从队列中删除
			} else if (integer == null) {
			redisCache.setCacheObject(ivrTaskcallMQ.getTaskid().toString(), 1, 120, TimeUnit.MINUTES);
			} else {
			redisCache.setCacheObject(ivrTaskcallMQ.getTaskid().toString(), integer + 1, 120, TimeUnit.MINUTES);
			}

			log.error("============消费失败,尝试消息补发再次消费!==============");
			log.error(e.getMessage());
			redisCache.setCacheObject(message.toString(), message.toString(), 60, TimeUnit.SECONDS);
			/**
			* 问卷任务处理
			*
			* @param commonTaskcallMQ
			*/
			private void wjHandle(CommonTaskcallMQ commonTaskcallMQ) {
			//判断一下commonTaskcallMQ中的stopstate是否与ivr_task中的一致，不一致，则说明是暂停了
			SvyTask svyTask = svyTaskMapper.selectSvyTaskByTaskid(commonTaskcallMQ.getTaskid());
			if (svyTask.getStopState() != commonTaskcallMQ.getStopState()) {
			//将消息从队列中剔除
			return;
			}

			if (StringUtils.isNotEmpty(commonTaskcallMQ.getPreachform())) {
			//如何任务发送方式不为空
			String[] split = commonTaskcallMQ.getPreachform().split(",");
			System.out.println("split的值为：" + split);
			for (String serviceFrom : split) {
			String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(serviceFrom));
			//这里可以考虑用策略模式优化一下，不然太难看了

			//通过模板ID获取模板问题
			SvyTaskTemplateVO svyTaskTemplateVO = new SvyTaskTemplateVO();
			svyTaskTemplateVO.setId(Long.valueOf(commonTaskcallMQ.getTemplateid()));
			SvyTaskTemplateVO svyTaskTemplateVO1 = iSvyTaskTemplateService.selectInfoByCondition(svyTaskTemplateVO);

			//通过任务ID拿到患者信息
			SvyTaskSingle svyTaskSingle = new SvyTaskSingle();
			svyTaskSingle.setTaskid(commonTaskcallMQ.getTaskid());
			List<SvyTaskSingle> svyTaskSingles = svyTaskSingleMapper.selectSvyTaskSingleList(svyTaskSingle);
			if (descByCode.equals("电话")) {
			for (SvyTaskSingle svyTaskSingle1 : svyTaskSingles) {
			SvyTask svyTask1 = svyTaskMapper.selectSvyTaskByTaskid(svyTaskSingle1.getTaskid());
			if (svyTask1.getSendState() != null && svyTask1.getSendState().equals("3") \|\| svyTask1.getSendState() != null && svyTask1.getSendState().equals("4")) {
			//如何任务被“暂停”或“终止”
			break;
			}
			//通过多线程的方式去打电话
			// executorService.submit(new PhoneTask(ivrTaskcall1, ivrTaskTemplateVO1, redisCache, sendService, phonePath, robotPhoneUtils));
			}
			} else if (descByCode.equals("多媒体")) {
			//多媒体
			} else if (descByCode.equals("纸质")) {
			//纸质
			} else if (descByCode.equals("短信")) {
			//短信
			} else if (descByCode.equals("公众号")) {
			//公众号
			RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
			String taskId = rsaPublicKeyExample.encryptedData(svyTask.getTaskid().toString(), pub_key);
			for (SvyTaskSingle svyTaskSingle1 : svyTaskSingles) {
			String patid = rsaPublicKeyExample.encryptedData(svyTaskSingle1.getPatid().toString(), pub_key);
			SendMagParam sendMagParam = new SendMagParam();
			sendMagParam.setType("5");
			sendMagParam.setUrl(req_path + "/outsideChain?param1=" + taskId + "&param2=" + patid + "&param3=" + svyTask.getTaskname());
			log.info("链接完整路径：{}", req_path + "/outsideChain?param1=" + taskId + "&param2=" + patid + "&param3=" + svyTask.getTaskname());
			//这个模板ID先写死，后面做成可选
			sendMagParam.setTmpCode("oG3pJHPVWpE81DmZsua_2tKwgJ97r0qz37z56ns7NB4");
			Map map = new HashMap();
			map.put("first", svyTask.getTaskname());
			sendMagParam.setContent(JSON.toJSONString(map));
			sendService.sendMsg(sendMagParam);
			}
			}
			//通知 MQ 消息已被接收,可以ACK(从队列中删除)了（这个需要根据业务再去处理ACK）
			}
			}
			}


			// /**
			// * 机器人第一句话语音
			@@ -212,15 +307,15 @@
			// @RabbitListener(queues = "ob_queue", concurrency = "50")
			// public void obVisit(String content, Message message, Channel channel) throws IOException {
			// try {
			// IvrTaskcallPhoneMQ ivrTaskcallMQ = null;
			// IvrTaskcallPhoneMQ commonTaskcallMQ = null;
			// ObjectMapper mapper = new ObjectMapper();
			// ivrTaskcallMQ = mapper.readValue(content, IvrTaskcallPhoneMQ.class);
			// commonTaskcallMQ = mapper.readValue(content, IvrTaskcallPhoneMQ.class);
			// //判断患者是否已经接电话
			// String str = redisCache.getCacheObject(ivrTaskcallMQ.getUuid() + "state_id");
			// String str = redisCache.getCacheObject(commonTaskcallMQ.getUuid() + "state_id");
			// System.out.println("-----------------" + str);
			// if (StringUtils.isNotEmpty(str) && str.equals("0")) {
			// //患者已经接听了电话
			// new PhoneUtils().ttsPlayback(ivrTaskcallMQ.getScript(), ivrTaskcallMQ.getUuid());
			// new PhoneUtils().ttsPlayback(commonTaskcallMQ.getScript(), commonTaskcallMQ.getUuid());
			// } else if (StringUtils.isNotEmpty(str) && str.equals("-10")) {
			// //这个说明,已经打了指定遍数还是没有人接，可以将消息从队列中移除了
			// channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);

	ruoyi-admin/src/main/java/com/ruoyi/web/component/RedisMqReceiver.java	153 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	smartor/src/main/java/com/smartor/domain/CommonTaskcallMQ.java	4 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	smartor/src/main/resources/mapper/smartor/SvyLibTemplateMapper.xml	2 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史

			@@ -53,9 +53,9 @@
			private Long stopState;

			/**
			* 暂停状态：状态如果发生修改，值就加1
			* 任务类型
			*/
			@ApiModelProperty(value = "暂停状态：状态如果发生修改，值就加1")
			@ApiModelProperty(value = "任务类型 1 随访 2 问卷 3 宣教")
			private Integer taskType;

			@@ -129,8 +129,6 @@
			<if test="reply != null">reply,</if>
			<if test="scriptScore != null">script_score,</if>
			<if test="scoreType != null">score_type,</if>
			value_type,
			reply,
			</trim>
			<trim prefix="values (" suffix=")" suffixOverrides=",">
			<if test="categoryid != null">#{categoryid},</if>