From 9c48fe63387ddba6404964ca2637ac0650dd0936 Mon Sep 17 00:00:00 2001 From: zy_Java <654600784@qq.com> Date: Thu, 3 Jun 2021 17:09:33 +0800 Subject: [PATCH 1/4] =?UTF-8?q?20210603=E6=8A=BD=E5=87=BA=E5=88=87?= =?UTF-8?q?=E6=8D=A2=E9=A1=B9=E7=9B=AE=E7=9A=84=E6=B6=88=E6=81=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../recovery/service/PatientService.java | 38 ++--------- .../ccsens/util/message/BaseMessageDto.java | 66 +++++++++++++++++++ .../util/message/RecoveryWithStartRecipe.java | 35 ++++++++++ .../util/message/SwitchoverProjectUtil.java | 40 +++++++++++ 4 files changed, 148 insertions(+), 31 deletions(-) create mode 100644 util/src/main/java/com/ccsens/util/message/BaseMessageDto.java create mode 100644 util/src/main/java/com/ccsens/util/message/RecoveryWithStartRecipe.java create mode 100644 util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java diff --git a/recovery/src/main/java/com/ccsens/recovery/service/PatientService.java b/recovery/src/main/java/com/ccsens/recovery/service/PatientService.java index 5ef9d019..3b926ffc 100644 --- a/recovery/src/main/java/com/ccsens/recovery/service/PatientService.java +++ b/recovery/src/main/java/com/ccsens/recovery/service/PatientService.java @@ -19,6 +19,7 @@ import com.ccsens.util.bean.message.common.InMessage; import com.ccsens.util.bean.message.common.MessageConstant; import com.ccsens.util.bean.message.common.MessageRule; import com.ccsens.util.config.RabbitMQConfig; +import com.ccsens.util.message.SwitchoverProjectUtil; import com.fasterxml.jackson.core.JsonProcessingException; import lombok.extern.slf4j.Slf4j; import org.springframework.amqp.core.AmqpTemplate; @@ -111,23 +112,10 @@ public class PatientService implements IPatientService{ //获取接收者id Set userIdSet = new HashSet<>(); userIdSet.add(robot.getUserid().toString()); - //生成消息 - RecoveryWithStartRecipe recoveryWithStartRecipe = new RecoveryWithStartRecipe(patient.getProjectId()); - //封装成inMessage - MessageRule messageRule = MessageRule.defaultRule(MessageConstant.DomainType.User); - messageRule.setAckRule(MessageRule.AckRule.NONE); - messageRule.setOfflineDiscard((byte) 1); - - InMessage inMessage = new InMessage(); - inMessage.setToDomain(MessageConstant.DomainType.User); - inMessage.setTos(userIdSet); - inMessage.setData(JacksonUtil.beanToJson(recoveryWithStartRecipe)); - inMessage.setRule(messageRule); - log.info("开启康复流程消息：{}",inMessage); - rabbitTemplate.convertAndSend(RabbitMQConfig.MESSAGE_QUEUE_NAME, - JacksonUtil.beanToJson(inMessage)); + SwitchoverProjectUtil.switchoverProject(userIdSet,patient.getProjectId()); } + @Override public PatientVo.RecipeRecordId startDrill(PatientDto.StartDrill param, Long userId) throws Exception { //存储一条训练记录 @@ -241,8 +229,7 @@ public class PatientService implements IPatientService{ //TODO 将处方项目关联的任务设为完成 //发送消息，让机器人切回康复中心的项目 Set userIdSet = new HashSet<>(); - RecoveryWithStartRecipe recoveryWithStartRecipe = null; - + Long projectId = null; Patient patient = patientDao.selectByPrimaryKey(param.getPatientId()); if(ObjectUtil.isNotNull(patient)){ //查询患者当前关联的机器人 @@ -251,22 +238,11 @@ public class PatientService implements IPatientService{ //查询患者所属的康复中心关联的项目 RecoveryCentre recoveryCentre = recoveryCentreMapper.selectByPrimaryKey(patient.getCentreId()); if(ObjectUtil.isNotNull(recoveryCentre)){ - recoveryWithStartRecipe = new RecoveryWithStartRecipe(patient.getProjectId()); + projectId = patient.getProjectId(); } } - //消息规则 - MessageRule messageRule = MessageRule.defaultRule(MessageConstant.DomainType.User); - messageRule.setAckRule(MessageRule.AckRule.NONE); - messageRule.setOfflineDiscard((byte) 1); - //封装成inMessage - InMessage inMessage = new InMessage(); - inMessage.setToDomain(MessageConstant.DomainType.User); - inMessage.setTos(userIdSet); - inMessage.setData(JacksonUtil.beanToJson(recoveryWithStartRecipe)); - inMessage.setRule(messageRule); - log.info("开启康复流程消息：{}",inMessage); - rabbitTemplate.convertAndSend(RabbitMQConfig.MESSAGE_QUEUE_NAME, - JacksonUtil.beanToJson(inMessage)); + + SwitchoverProjectUtil.switchoverProject(userIdSet,projectId); } @Override diff --git a/util/src/main/java/com/ccsens/util/message/BaseMessageDto.java b/util/src/main/java/com/ccsens/util/message/BaseMessageDto.java new file mode 100644 index 00000000..293ee6fb --- /dev/null +++ b/util/src/main/java/com/ccsens/util/message/BaseMessageDto.java @@ -0,0 +1,66 @@ +package com.ccsens.util.message; + +import cn.hutool.core.collection.CollectionUtil; +import com.alibaba.fastjson.JSONObject; +import com.ccsens.util.bean.message.common.InMessage; +import lombok.Data; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@Data +public class BaseMessageDto { + @Data + public static class MessageUser { + private Long id; + private Long userId; //本质上是authId //20190507 本质上是userId + private String nickname; + private String avatarUrl; + private boolean hasRead; + public MessageUser(){ + hasRead = false; + } + public MessageUser(Long userId){ + hasRead = false; + this.userId = userId; + } + public MessageUser(Long id,Long userId,String nickname,String avatarUrl){ + this(); + this.id = id; + this.userId = userId; + this.nickname = nickname; + this.avatarUrl = avatarUrl; + } + + public static List userIdToUsers(List userIds) { + List users = new ArrayList<>(); + userIds.forEach(userId ->{ + users.add(new MessageUser(userId)); + }); + return users; + } + } + + private Long time; + private String type; + private String event; + private Long projectId; + private MessageUser sender; + private List receivers; +// private Object data; + + public Set receiversTransTos() { + Set tos = new HashSet<>(); + if (CollectionUtil.isEmpty(receivers)) { + return tos; + } + receivers.forEach(receiver -> { + InMessage.To to = new InMessage.To(receiver.getUserId()); + tos.add(JSONObject.toJSONString(to)); + }); + + return tos; + } +} diff --git a/util/src/main/java/com/ccsens/util/message/RecoveryWithStartRecipe.java b/util/src/main/java/com/ccsens/util/message/RecoveryWithStartRecipe.java new file mode 100644 index 00000000..d2a5c5e4 --- /dev/null +++ b/util/src/main/java/com/ccsens/util/message/RecoveryWithStartRecipe.java @@ -0,0 +1,35 @@ +package com.ccsens.util.message; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +/** + * @author 逗 + */ + +@EqualsAndHashCode(callSuper = true) +@Data +public class RecoveryWithStartRecipe extends BaseMessageDto{ + /**切换项目*/ + public static final String SWITCHOVER_PROJECT = "switchoverProject"; + + @lombok.Data + public static class Data{ + private Long projectId; + } + + private Data data; + + public RecoveryWithStartRecipe(){ + setType(SWITCHOVER_PROJECT); + setEvent(SWITCHOVER_PROJECT); + setTime(System.currentTimeMillis()); + } + + public RecoveryWithStartRecipe(Long projectId){ + this(); + Data d = new Data(); + d.setProjectId(projectId); + setData(d); + } +} diff --git a/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java b/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java new file mode 100644 index 00000000..2c5d02fa --- /dev/null +++ b/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java @@ -0,0 +1,40 @@ +package com.ccsens.util.message; + +import com.ccsens.util.JacksonUtil; +import com.ccsens.util.bean.message.common.InMessage; +import com.ccsens.util.bean.message.common.MessageConstant; +import com.ccsens.util.bean.message.common.MessageRule; +import com.ccsens.util.config.RabbitMQConfig; +import com.fasterxml.jackson.core.JsonProcessingException; +import lombok.extern.slf4j.Slf4j; +import org.springframework.amqp.core.AmqpTemplate; +import org.springframework.amqp.rabbit.core.RabbitTemplate; + +import java.util.Set; + +/** + * @author 逗 + */ +@Slf4j +public class SwitchoverProjectUtil { + + public static void switchoverProject(Set userIdSet,Long projectId) throws JsonProcessingException { + AmqpTemplate amqpTemplate = new RabbitTemplate(); + log.info("切换项目：{}--{}",projectId,userIdSet); + //设定发送规则 + MessageRule messageRule = MessageRule.defaultRule(MessageConstant.DomainType.User); + messageRule.setAckRule(MessageRule.AckRule.NONE); + messageRule.setOfflineDiscard((byte) 1); + //生成消息 + RecoveryWithStartRecipe recoveryWithStartRecipe = new RecoveryWithStartRecipe(projectId); + //封装成inMessage + InMessage inMessage = new InMessage(); + inMessage.setToDomain(MessageConstant.DomainType.User); + inMessage.setTos(userIdSet); + inMessage.setData(JacksonUtil.beanToJson(recoveryWithStartRecipe)); + inMessage.setRule(messageRule); + log.info("发送切换项目信息：{}",inMessage); + amqpTemplate.convertAndSend(RabbitMQConfig.MESSAGE_QUEUE_NAME, + JacksonUtil.beanToJson(inMessage)); + } +} From fd17591538579911e4b017ec3f043713edaaf288 Mon Sep 17 00:00:00 2001 From: ma <1062634917@qq.com> Date: Thu, 3 Jun 2021 17:37:27 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=A0=B9=E6=8D=AE?= =?UTF-8?q?=E6=9F=A5=E8=AF=A2=E5=8E=86=E5=8F=B2=E6=82=A3=E8=80=85=E4=BF=A1?= =?UTF-8?q?=E6=81=AF,=E6=9F=A5=E7=9C=8B=E7=8E=AF=E8=8A=82=E7=8A=B6?= =?UTF-8?q?=E6=80=81=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 2 +- .../api/PatientAndFamilyController.java | 13 ++ .../ccsens/wisdomcar/api/StepController.java | 46 ++++ .../ccsens/wisdomcar/bean/dto/StepDto.java | 19 ++ .../wisdomcar/bean/po/HospitalMember.java | 33 +++ .../bean/po/HospitalMemberExample.java | 200 ++++++++++++++++++ .../ccsens/wisdomcar/bean/vo/PatientVo.java | 30 +++ .../com/ccsens/wisdomcar/bean/vo/StepVo.java | 19 ++ .../persist/dao/PatientDoctorDao.java | 10 +- .../persist/dao/PatientProjectDao.java | 7 + .../ccsens/wisdomcar/persist/dao/StepDao.java | 9 + .../service/IPatientAndFamilyService.java | 10 + .../wisdomcar/service/IStepService.java | 19 ++ .../service/PatientAndFamilyService.java | 88 +++++++- .../ccsens/wisdomcar/service/StepService.java | 32 +++ .../resources/mapper_dao/PatientDoctorDao.xml | 15 ++ .../mapper_dao/PatientProjectDao.xml | 20 ++ .../src/main/resources/mapper_dao/StepDao.xml | 19 ++ .../mapper_raw/HospitalMemberMapper.xml | 58 ++++- 19 files changed, 638 insertions(+), 11 deletions(-) create mode 100644 wisdomcar/src/main/java/com/ccsens/wisdomcar/api/StepController.java create mode 100644 wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/dto/StepDto.java create mode 100644 wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/PatientVo.java create mode 100644 wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IStepService.java create mode 100644 wisdomcar/src/main/java/com/ccsens/wisdomcar/service/StepService.java create mode 100644 wisdomcar/src/main/resources/mapper_dao/PatientDoctorDao.xml diff --git a/pom.xml b/pom.xml index d208788b..3063a72f 100644 --- a/pom.xml +++ b/pom.xml @@ -13,7 +13,7 @@ - + wisdomcar diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/PatientAndFamilyController.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/PatientAndFamilyController.java index 62ad0764..df8a844a 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/PatientAndFamilyController.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/PatientAndFamilyController.java @@ -7,6 +7,7 @@ import com.ccsens.wisdomcar.bean.dto.CreateCaseDto; import com.ccsens.wisdomcar.bean.dto.PatientAndFamilyDto; import com.ccsens.wisdomcar.bean.vo.OtherRecordsVo; import com.ccsens.wisdomcar.bean.vo.PatientAndFamilyVo; +import com.ccsens.wisdomcar.bean.vo.PatientVo; import com.ccsens.wisdomcar.service.IPatientAndFamilyService; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; @@ -54,6 +55,18 @@ public class PatientAndFamilyController { } + + @MustLogin + @ApiOperation(value = "医生查看以前患者", notes = "mz") + @RequestMapping(value = "/findOldPatient", method = RequestMethod.POST, produces = {"application/json;charset=UTF-8"}) + public JsonResponse findOldPatient(@ApiParam @Validated @RequestBody QueryDto params) { + log.info("医生查看以前患者：{}", params); + List patientRecordList = patientAndFamilyService.findOldPatient(params.getUserId()); + log.info("医生查看以前患者接口结束{}",patientRecordList); + return JsonResponse.newInstance().ok(patientRecordList); + + } + @ApiOperation(value = "查询患者", notes = "") @RequestMapping(value = "/queryPatientInfo", method = RequestMethod.POST, produces = {"application/json;charset=UTF-8"}) public JsonResponse queryPatientInfo(@ApiParam @Validated @RequestBody QueryDto params) { diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/StepController.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/StepController.java new file mode 100644 index 00000000..67f9fbb0 --- /dev/null +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/api/StepController.java @@ -0,0 +1,46 @@ +package com.ccsens.wisdomcar.api; + +import com.ccsens.cloudutil.annotation.MustLogin; +import com.ccsens.util.JsonResponse; +import com.ccsens.util.bean.dto.QueryDto; +import com.ccsens.wisdomcar.bean.dto.StepDto; +import com.ccsens.wisdomcar.bean.vo.PatientVo; +import com.ccsens.wisdomcar.bean.vo.StepVo; +import com.ccsens.wisdomcar.service.IStepService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import lombok.extern.slf4j.Slf4j; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; + +import javax.annotation.Resource; +import java.util.List; + +/** + * @author 马 + */ +@Slf4j +@Api(tags = "环节(节点)相关接口" , description = "") +@RestController +@RequestMapping("/step") +public class StepController { + + @Resource + private IStepService stepService; + + @MustLogin + @ApiOperation(value = "查看节点是否完成", notes = "mz") + @RequestMapping(value = "/findStepIsOver", method = RequestMethod.POST, produces = {"application/json;charset=UTF-8"}) + public JsonResponse findStepIsOver(@ApiParam @Validated @RequestBody QueryDto params) { + log.info("查看节点是否完成：{}", params); + List stepStatuses = stepService.findStepIsOver(params.getParam()); + log.info("查看节点是否完成接口结束{}",stepStatuses); + return JsonResponse.newInstance().ok(stepStatuses); + + } + +} diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/dto/StepDto.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/dto/StepDto.java new file mode 100644 index 00000000..de82cd27 --- /dev/null +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/dto/StepDto.java @@ -0,0 +1,19 @@ +package com.ccsens.wisdomcar.bean.dto; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @author AUSU + */ +@Data +public class StepDto { + + @Data + @ApiModel("查看环节完成状态") + public static class FindStepStatus{ + @ApiModelProperty("患者平车id") + private Long patientCarId; + } +} diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMember.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMember.java index 55b6b82b..e8cfa714 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMember.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMember.java @@ -20,6 +20,12 @@ public class HospitalMember implements Serializable { private Byte recStatus; + private String memberName; + + private Byte memberSex; + + private String memberPhone; + private static final long serialVersionUID = 1L; public Long getId() { @@ -86,6 +92,30 @@ public class HospitalMember implements Serializable { this.recStatus = recStatus; } + public String getMemberName() { + return memberName; + } + + public void setMemberName(String memberName) { + this.memberName = memberName == null ? null : memberName.trim(); + } + + public Byte getMemberSex() { + return memberSex; + } + + public void setMemberSex(Byte memberSex) { + this.memberSex = memberSex; + } + + public String getMemberPhone() { + return memberPhone; + } + + public void setMemberPhone(String memberPhone) { + this.memberPhone = memberPhone == null ? null : memberPhone.trim(); + } + @Override public String toString() { StringBuilder sb = new StringBuilder(); @@ -100,6 +130,9 @@ public class HospitalMember implements Serializable { sb.append(", createdAt=").append(createdAt); sb.append(", updatedAt=").append(updatedAt); sb.append(", recStatus=").append(recStatus); + sb.append(", memberName=").append(memberName); + sb.append(", memberSex=").append(memberSex); + sb.append(", memberPhone=").append(memberPhone); sb.append("]"); return sb.toString(); } diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMemberExample.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMemberExample.java index 212cc9a2..f1503017 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMemberExample.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/po/HospitalMemberExample.java @@ -584,6 +584,206 @@ public class HospitalMemberExample { addCriterion("rec_status not between", value1, value2, "recStatus"); return (Criteria) this; } + + public Criteria andMemberNameIsNull() { + addCriterion("member_name is null"); + return (Criteria) this; + } + + public Criteria andMemberNameIsNotNull() { + addCriterion("member_name is not null"); + return (Criteria) this; + } + + public Criteria andMemberNameEqualTo(String value) { + addCriterion("member_name =", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameNotEqualTo(String value) { + addCriterion("member_name <>", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameGreaterThan(String value) { + addCriterion("member_name >", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameGreaterThanOrEqualTo(String value) { + addCriterion("member_name >=", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameLessThan(String value) { + addCriterion("member_name <", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameLessThanOrEqualTo(String value) { + addCriterion("member_name <=", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameLike(String value) { + addCriterion("member_name like", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameNotLike(String value) { + addCriterion("member_name not like", value, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameIn(List values) { + addCriterion("member_name in", values, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameNotIn(List values) { + addCriterion("member_name not in", values, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameBetween(String value1, String value2) { + addCriterion("member_name between", value1, value2, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberNameNotBetween(String value1, String value2) { + addCriterion("member_name not between", value1, value2, "memberName"); + return (Criteria) this; + } + + public Criteria andMemberSexIsNull() { + addCriterion("member_sex is null"); + return (Criteria) this; + } + + public Criteria andMemberSexIsNotNull() { + addCriterion("member_sex is not null"); + return (Criteria) this; + } + + public Criteria andMemberSexEqualTo(Byte value) { + addCriterion("member_sex =", value, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexNotEqualTo(Byte value) { + addCriterion("member_sex <>", value, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexGreaterThan(Byte value) { + addCriterion("member_sex >", value, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexGreaterThanOrEqualTo(Byte value) { + addCriterion("member_sex >=", value, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexLessThan(Byte value) { + addCriterion("member_sex <", value, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexLessThanOrEqualTo(Byte value) { + addCriterion("member_sex <=", value, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexIn(List values) { + addCriterion("member_sex in", values, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexNotIn(List values) { + addCriterion("member_sex not in", values, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexBetween(Byte value1, Byte value2) { + addCriterion("member_sex between", value1, value2, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberSexNotBetween(Byte value1, Byte value2) { + addCriterion("member_sex not between", value1, value2, "memberSex"); + return (Criteria) this; + } + + public Criteria andMemberPhoneIsNull() { + addCriterion("member_phone is null"); + return (Criteria) this; + } + + public Criteria andMemberPhoneIsNotNull() { + addCriterion("member_phone is not null"); + return (Criteria) this; + } + + public Criteria andMemberPhoneEqualTo(String value) { + addCriterion("member_phone =", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneNotEqualTo(String value) { + addCriterion("member_phone <>", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneGreaterThan(String value) { + addCriterion("member_phone >", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneGreaterThanOrEqualTo(String value) { + addCriterion("member_phone >=", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneLessThan(String value) { + addCriterion("member_phone <", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneLessThanOrEqualTo(String value) { + addCriterion("member_phone <=", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneLike(String value) { + addCriterion("member_phone like", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneNotLike(String value) { + addCriterion("member_phone not like", value, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneIn(List values) { + addCriterion("member_phone in", values, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneNotIn(List values) { + addCriterion("member_phone not in", values, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneBetween(String value1, String value2) { + addCriterion("member_phone between", value1, value2, "memberPhone"); + return (Criteria) this; + } + + public Criteria andMemberPhoneNotBetween(String value1, String value2) { + addCriterion("member_phone not between", value1, value2, "memberPhone"); + return (Criteria) this; + } } public static class Criteria extends GeneratedCriteria { diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/PatientVo.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/PatientVo.java new file mode 100644 index 00000000..61ab4c60 --- /dev/null +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/PatientVo.java @@ -0,0 +1,30 @@ +package com.ccsens.wisdomcar.bean.vo; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @author AUSU + */ +@Data +public class PatientVo { + + @Data + @ApiModel("医生查看以前患者") + public static class PatientRecord { + @ApiModelProperty("患者姓名") + private String name; + @ApiModelProperty("患者性别(0-女,1-男)") + private Byte sex; + @ApiModelProperty("患者年龄") + private Integer age; + @ApiModelProperty("患者电话号") + private String phone; + @ApiModelProperty("患者身份证号") + private String idCard; + @ApiModelProperty("项目id") + private Long projectId; + } + +} diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/StepVo.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/StepVo.java index 9d40f576..c928ff38 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/StepVo.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/bean/vo/StepVo.java @@ -1,5 +1,7 @@ package com.ccsens.wisdomcar.bean.vo; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; import lombok.Data; /** @@ -12,6 +14,23 @@ public class StepVo { private Long id; private String stepCode; private byte stepType; + } + + @ApiModel("查看环节是否完成") + @Data + public static class StepStatus{ + @ApiModelProperty("环节id") + private Long stepId; + @ApiModelProperty("环节code") + private String stepCode; + @ApiModelProperty("环节名称") + private String stepName; + @ApiModelProperty("开始时间") + private Long startTime; + @ApiModelProperty("类型(0-平车,1-用户)") + private Byte type; + @ApiModelProperty("医生名字") + private String memberName; } } diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientDoctorDao.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientDoctorDao.java index 350037af..26e19233 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientDoctorDao.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientDoctorDao.java @@ -2,11 +2,19 @@ package com.ccsens.wisdomcar.persist.dao; import com.ccsens.wisdomcar.persist.mapper.PatientDoctorMapper; +import org.apache.ibatis.annotations.Param; + +import java.util.List; /** * @author AUSU */ public interface PatientDoctorDao extends PatientDoctorMapper { - + /** + * 查看医生负责的所有患者id + * @param id 医生id + * @return List(患者id) + */ + List findPatientIdByDoctor(@Param("id") Long id); } \ No newline at end of file diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientProjectDao.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientProjectDao.java index 9e3a8446..f054e89f 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientProjectDao.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/PatientProjectDao.java @@ -2,6 +2,7 @@ package com.ccsens.wisdomcar.persist.dao; import com.ccsens.wisdomcar.bean.po.PatientProject; import com.ccsens.wisdomcar.bean.po.PatientProjectExample; +import com.ccsens.wisdomcar.bean.vo.PatientVo; import com.ccsens.wisdomcar.bean.vo.PatientAndFamilyVo; import com.ccsens.wisdomcar.persist.mapper.PatientProjectMapper; import org.apache.ibatis.annotations.Param; @@ -12,6 +13,12 @@ import java.util.List; * @author 马 */ public interface PatientProjectDao extends PatientProjectMapper { + /** + *查找医生负责的患者信息 + * @param newPatientIds 患者id集合 + * @return 患者信息 + */ + List findPatientInfoByIdList(@Param("list") List newPatientIds); PatientAndFamilyVo.PatientInfo queryPatientInfo(@Param("projectId")Long projectId); } \ No newline at end of file diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/StepDao.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/StepDao.java index 4514328f..02016870 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/StepDao.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/persist/dao/StepDao.java @@ -5,6 +5,8 @@ import com.ccsens.wisdomcar.persist.mapper.StepMapper; import org.apache.ibatis.annotations.Param; import org.springframework.stereotype.Repository; +import java.util.List; + /** * @author 逗 */ @@ -28,4 +30,11 @@ public interface StepDao extends StepMapper { * @return 最大序号 */ Integer getMaxSequence(@Param("stepType") byte stepType); + + /** + * 查看环节是否完成 + * @param patientCarId 患者平车id + * @return 环节信息 + */ + List findStepIsOver(Long patientCarId); } diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IPatientAndFamilyService.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IPatientAndFamilyService.java index 642836a8..c9d2949c 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IPatientAndFamilyService.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IPatientAndFamilyService.java @@ -3,6 +3,9 @@ package com.ccsens.wisdomcar.service; import com.ccsens.wisdomcar.bean.dto.PatientAndFamilyDto; import com.ccsens.wisdomcar.bean.vo.PatientAndFamilyVo; +import com.ccsens.wisdomcar.bean.vo.PatientVo; + +import java.util.List; /** * @author 马 @@ -27,4 +30,11 @@ public interface IPatientAndFamilyService { * @param param 家属信息 */ PatientAndFamilyVo.PatientInfo queryPatientInfo(PatientAndFamilyDto.queryPatientInfo param); + + /** + * 查看往期患者记录 + * @param userId 当前用户userID + * @return 往期患者记录 + */ + List findOldPatient(Long userId); } diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IStepService.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IStepService.java new file mode 100644 index 00000000..4ebc2460 --- /dev/null +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/IStepService.java @@ -0,0 +1,19 @@ +package com.ccsens.wisdomcar.service; + + +import com.ccsens.wisdomcar.bean.dto.StepDto; +import com.ccsens.wisdomcar.bean.vo.StepVo; + +import java.util.List; + +/** + * @author AUSU + */ +public interface IStepService { + /** + * 查看环节是否完成 + * @param param 患者平车id + * @return 环节状态 + */ + List findStepIsOver(StepDto.FindStepStatus param); +} diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/PatientAndFamilyService.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/PatientAndFamilyService.java index 827b2d2d..57c19f8b 100644 --- a/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/PatientAndFamilyService.java +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/PatientAndFamilyService.java @@ -1,12 +1,24 @@ package com.ccsens.wisdomcar.service; +import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.util.ObjectUtil; +import com.ccsens.cloudutil.bean.tall.dto.MemberRoleDto; +import com.ccsens.cloudutil.feign.TallFeignClient; +import com.ccsens.util.JsonResponse; +import com.ccsens.util.bean.dto.QueryDto; import com.ccsens.util.CodeEnum; import com.ccsens.util.exception.BaseException; import com.ccsens.wisdomcar.bean.dto.PatientAndFamilyDto; +import com.ccsens.wisdomcar.bean.po.HospitalMember; +import com.ccsens.wisdomcar.bean.po.HospitalMemberExample; +import com.ccsens.wisdomcar.bean.po.PatientFamily; import com.ccsens.wisdomcar.bean.po.PatientProject; import com.ccsens.wisdomcar.bean.vo.PatientAndFamilyVo; +import com.ccsens.wisdomcar.bean.vo.PatientVo; +import com.ccsens.wisdomcar.persist.dao.HospitalMemberDao; +import com.ccsens.wisdomcar.persist.dao.PatientDoctorDao; +import com.ccsens.wisdomcar.persist.dao.PatientFamilyDao; import com.ccsens.wisdomcar.persist.dao.PatientProjectDao; import com.ccsens.wisdomcar.util.Constant; import lombok.extern.slf4j.Slf4j; @@ -15,6 +27,8 @@ import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; +import java.util.*; +import java.util.stream.Collectors; /** * @author 马 @@ -26,7 +40,14 @@ public class PatientAndFamilyService implements IPatientAndFamilyService{ @Resource private PatientProjectDao patientProjectDao; - + @Resource + private PatientFamilyDao patientFamilyDao; + @Resource + private TallFeignClient tallFeignClient; + @Resource + private HospitalMemberDao hospitalMemberDao; + @Resource + private PatientDoctorDao patientDoctorDao; @Override public void updatePatientInfo(PatientAndFamilyDto.PatientInfo param) { @@ -35,9 +56,6 @@ public class PatientAndFamilyService implements IPatientAndFamilyService{ if (ObjectUtil.isNotNull(param.getName())){ patient.setName(param.getName()); } - if (ObjectUtil.isNotNull(param.getPhone())){ - patient.setPhone(param.getPhone()); - } if (ObjectUtil.isNotNull(param.getAge())){ patient.setAge(param.getAge()); } @@ -47,6 +65,9 @@ public class PatientAndFamilyService implements IPatientAndFamilyService{ if (ObjectUtil.isNotNull(param.getSex())){ patient.setSex(param.getSex()); } + if (ObjectUtil.isNotNull(param.getPhone())){ + patient.setPhone(param.getPhone()); + } patientProjectDao.updateByPrimaryKeySelective(patient); }else{ throw new BaseException(Constant.PATIENT_NOT_FOUND); @@ -55,7 +76,66 @@ public class PatientAndFamilyService implements IPatientAndFamilyService{ @Override public void updatePatientFamilyInfo(PatientAndFamilyDto.PatientFamilyInfo param) { + PatientFamily family = patientFamilyDao.selectByPrimaryKey(param.getId()); + //如果手机号为空需要推送tall添加患者家属 + if (ObjectUtil.isNull(family.getPhone()) && ObjectUtil.isNotNull(param.getPhone())){ + //查找项目id + PatientProject patient = patientProjectDao.selectByPrimaryKey(family.getPatientId()); + List roleNameList = new ArrayList<>(); + roleNameList.add(Constant.PATIENT_FAMILY); + + QueryDto queryDto = new QueryDto<>(); + MemberRoleDto.SaveMemberForTemplate saveMemberForTemplate = new MemberRoleDto.SaveMemberForTemplate(); + saveMemberForTemplate.setProjectId(patient.getProjectId()); + //添加家属手机号和Tall对应角色名称 + List memberList = new ArrayList<>(); + MemberRoleDto.MemberForTemplate member = new MemberRoleDto.MemberForTemplate(); + member.setPhone(param.getPhone()); + member.setMemberName(param.getName()); + member.setRoleName(roleNameList); + memberList.add(member); + saveMemberForTemplate.setMemberForTemplate(memberList); + queryDto.setParam(saveMemberForTemplate); + log.info("调用tall添加成员接口:{}",queryDto); + JsonResponse jsonResponse = tallFeignClient.addMemberForTemplate(queryDto); + log.info("调用tall添加成员接口结束返回:{}",jsonResponse); + if(!jsonResponse.getCode().equals(Constant.RESPONSE_OK)){ + log.info("调用tall异常后返回：{}", jsonResponse.getMsg()); + throw new BaseException(Constant.RETURN_ERROR); + } + } + + if (ObjectUtil.isNotNull(param.getName())){ + family.setName(param.getName()); + } + if (ObjectUtil.isNotNull(param.getPhone())){ + family.setPhone(param.getPhone()); + } + patientFamilyDao.updateByPrimaryKeySelective(family); + + } + + @Override + public List findOldPatient(Long userId) { + List patientInfoByIdList = null; + List patientIds = new ArrayList<>(); + + HospitalMemberExample memberExample = new HospitalMemberExample(); + memberExample.createCriteria().andUserIdEqualTo(userId); + List hospitalMembers = hospitalMemberDao.selectByExample(memberExample); + if (CollectionUtil.isNotEmpty(hospitalMembers)){ + for (HospitalMember hospitalMember : hospitalMembers) { + List patientList = patientDoctorDao.findPatientIdByDoctor(hospitalMember.getId()); + patientIds.addAll(patientList); + } + } + //去重患者id + List newPatientIds= patientIds.stream().distinct().collect(Collectors.toList()); + if (CollectionUtil.isNotEmpty(newPatientIds)){ + patientInfoByIdList = patientProjectDao.findPatientInfoByIdList(newPatientIds); + } + return patientInfoByIdList; } @Override diff --git a/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/StepService.java b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/StepService.java new file mode 100644 index 00000000..2eff2918 --- /dev/null +++ b/wisdomcar/src/main/java/com/ccsens/wisdomcar/service/StepService.java @@ -0,0 +1,32 @@ +package com.ccsens.wisdomcar.service; + +import com.ccsens.wisdomcar.bean.dto.StepDto; +import com.ccsens.wisdomcar.bean.vo.StepVo; + +import com.ccsens.wisdomcar.persist.dao.StepDao; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.annotation.Transactional; + + +import javax.annotation.Resource; +import java.util.List; + +/** + * @author 马 + */ +@Slf4j +@Service +@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) +public class StepService implements IStepService { + + @Resource + private StepDao stepDao; + + @Override + public List findStepIsOver(StepDto.FindStepStatus param) { + return stepDao.findStepIsOver(param.getPatientCarId()); + } + +} diff --git a/wisdomcar/src/main/resources/mapper_dao/PatientDoctorDao.xml b/wisdomcar/src/main/resources/mapper_dao/PatientDoctorDao.xml new file mode 100644 index 00000000..150cc185 --- /dev/null +++ b/wisdomcar/src/main/resources/mapper_dao/PatientDoctorDao.xml @@ -0,0 +1,15 @@ + + + + + + + \ No newline at end of file diff --git a/wisdomcar/src/main/resources/mapper_dao/PatientProjectDao.xml b/wisdomcar/src/main/resources/mapper_dao/PatientProjectDao.xml index 7a810087..6432c061 100644 --- a/wisdomcar/src/main/resources/mapper_dao/PatientProjectDao.xml +++ b/wisdomcar/src/main/resources/mapper_dao/PatientProjectDao.xml @@ -2,6 +2,26 @@ + + select max(sequence) from t_step where step_type = #{stepType} and rec_status = 0 + + + + \ No newline at end of file diff --git a/wisdomcar/src/main/resources/mapper_raw/HospitalMemberMapper.xml b/wisdomcar/src/main/resources/mapper_raw/HospitalMemberMapper.xml index 763aaf20..988e38d7 100644 --- a/wisdomcar/src/main/resources/mapper_raw/HospitalMemberMapper.xml +++ b/wisdomcar/src/main/resources/mapper_raw/HospitalMemberMapper.xml @@ -10,6 +10,9 @@ + + + @@ -70,7 +73,8 @@ - id, position, department, hospital_id, user_id, created_at, updated_at, rec_status + id, position, department, hospital_id, user_id, created_at, updated_at, rec_status, + member_name, member_sex, member_phone @@ -198,6 +222,15 @@ rec_status = #{record.recStatus,jdbcType=TINYINT}, + + member_name = #{record.memberName,jdbcType=VARCHAR}, + + + member_sex = #{record.memberSex,jdbcType=TINYINT}, + + + member_phone = #{record.memberPhone,jdbcType=VARCHAR}, + @@ -212,7 +245,10 @@ user_id = #{record.userId,jdbcType=BIGINT}, created_at = #{record.createdAt,jdbcType=TIMESTAMP}, updated_at = #{record.updatedAt,jdbcType=TIMESTAMP}, - rec_status = #{record.recStatus,jdbcType=TINYINT} + rec_status = #{record.recStatus,jdbcType=TINYINT}, + member_name = #{record.memberName,jdbcType=VARCHAR}, + member_sex = #{record.memberSex,jdbcType=TINYINT}, + member_phone = #{record.memberPhone,jdbcType=VARCHAR} @@ -241,6 +277,15 @@ rec_status = #{recStatus,jdbcType=TINYINT}, + + member_name = #{memberName,jdbcType=VARCHAR}, + + + member_sex = #{memberSex,jdbcType=TINYINT}, + + + member_phone = #{memberPhone,jdbcType=VARCHAR}, + where id = #{id,jdbcType=BIGINT} @@ -252,7 +297,10 @@ user_id = #{userId,jdbcType=BIGINT}, created_at = #{createdAt,jdbcType=TIMESTAMP}, updated_at = #{updatedAt,jdbcType=TIMESTAMP}, - rec_status = #{recStatus,jdbcType=TINYINT} + rec_status = #{recStatus,jdbcType=TINYINT}, + member_name = #{memberName,jdbcType=VARCHAR}, + member_sex = #{memberSex,jdbcType=TINYINT}, + member_phone = #{memberPhone,jdbcType=VARCHAR} where id = #{id,jdbcType=BIGINT} \ No newline at end of file From 9a159b6fae09d11898530d3409485003036741d3 Mon Sep 17 00:00:00 2001 From: zy_Java <654600784@qq.com> Date: Thu, 3 Jun 2021 17:46:01 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=88=87=E6=8D=A2?= =?UTF-8?q?=E9=A1=B9=E7=9B=AE=E7=9A=84=E6=B6=88=E6=81=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../util/message/SwitchoverProjectUtil.java | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java b/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java index 2c5d02fa..306a77e6 100644 --- a/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java +++ b/util/src/main/java/com/ccsens/util/message/SwitchoverProjectUtil.java @@ -9,17 +9,29 @@ import com.fasterxml.jackson.core.JsonProcessingException; import lombok.extern.slf4j.Slf4j; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.amqp.rabbit.core.RabbitTemplate; +import org.springframework.stereotype.Component; +import javax.annotation.PostConstruct; +import javax.annotation.Resource; import java.util.Set; /** * @author 逗 */ +@Component @Slf4j public class SwitchoverProjectUtil { + @Resource + private AmqpTemplate amqpTemplate; + private static SwitchoverProjectUtil util; + + @PostConstruct + public void init(){ + util = this; + util.amqpTemplate = this.amqpTemplate; + } public static void switchoverProject(Set userIdSet,Long projectId) throws JsonProcessingException { - AmqpTemplate amqpTemplate = new RabbitTemplate(); log.info("切换项目：{}--{}",projectId,userIdSet); //设定发送规则 MessageRule messageRule = MessageRule.defaultRule(MessageConstant.DomainType.User); @@ -34,7 +46,7 @@ public class SwitchoverProjectUtil { inMessage.setData(JacksonUtil.beanToJson(recoveryWithStartRecipe)); inMessage.setRule(messageRule); log.info("发送切换项目信息：{}",inMessage); - amqpTemplate.convertAndSend(RabbitMQConfig.MESSAGE_QUEUE_NAME, + util.amqpTemplate.convertAndSend(RabbitMQConfig.MESSAGE_QUEUE_NAME, JacksonUtil.beanToJson(inMessage)); } } From e4ae7e2952adc8b3a3edeafba87afa738687a237 Mon Sep 17 00:00:00 2001 From: zhizhi wu <2377881365@qq.com> Date: Thu, 3 Jun 2021 17:52:37 +0800 Subject: [PATCH 4/4] base64 --- .../test/java/com/ccsens/util/Base64Test.java | 85 ++++++++++--------- 1 file changed, 45 insertions(+), 40 deletions(-) diff --git a/util/src/test/java/com/ccsens/util/Base64Test.java b/util/src/test/java/com/ccsens/util/Base64Test.java index f3605f88..5d583f2f 100644 --- a/util/src/test/java/com/ccsens/util/Base64Test.java +++ b/util/src/test/java/com/ccsens/util/Base64Test.java @@ -5,9 +5,12 @@ import cn.hutool.core.util.ZipUtil; import com.ccsens.util.exception.BaseException; import lombok.extern.slf4j.Slf4j; import org.junit.Test; +import sun.misc.BASE64Decoder; +import sun.misc.BASE64Encoder; import java.io.File; +import java.io.FileInputStream; import java.io.FileOutputStream; /** @@ -61,45 +64,47 @@ public class Base64Test { } } -// -// /** -// * 文件转base64 -// * -// * @param path -// * @return -// * @throws Exception -// */ -// public static String encodeBase64File(String path) throws Exception { -// File file = new File(path); -// ; -// FileInputStream inputFile = new FileInputStream(file); -// byte[] buffer = new byte[(int) file.length()]; -// inputFile.read(buffer); -// inputFile.close(); -// return new BASE64Encoder().encode(buffer); -// -// } -// -// -// /** -// * 将base64字符解码保存文件 -// * -// * @param base64Code -// * @param targetPath -// * @throws Exception -// */ -// -// public static void decoderBase64File(String base64Code, String targetPath) -// throws Exception { -// File file = new File(targetPath); -// if (!file.getParentFile().exists()) { -// file.getParentFile().mkdirs(); -// } -// byte[] buffer = new BASE64Decoder().decodeBuffer(base64Code); -// FileOutputStream out = new FileOutputStream(targetPath); -// out.write(buffer); -// out.close(); -// -// } + + /** + * 文件转base64 + * + * @param path + * @return + * @throws Exception + */ + @Test + public void encodeBase64File() throws Exception { + String path = ""; + File file = new File(path); + FileInputStream inputFile = new FileInputStream(file); + byte[] buffer = new byte[(int) file.length()]; + inputFile.read(buffer); + inputFile.close(); + String encode = new BASE64Encoder().encode(buffer); + System.out.println(encode); + + } + + + /** + * 将base64字符解码保存文件 + * + * @throws Exception + */ + @Test + public void decoderBase64File() + throws Exception { + String base64Code = "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"; + String targetPath = "D:\\1.mp3"; + File file = new File(targetPath); + if (!file.getParentFile().exists()) { + file.getParentFile().mkdirs(); + } + byte[] buffer = new BASE64Decoder().decodeBuffer(base64Code); + FileOutputStream out = new FileOutputStream(targetPath); + out.write(buffer); + out.close(); + + } }