安防监控工单流程

business/base-service/src/main/java/com/yihu/jw/hospital/message/dao/SystemMessageDao.java

@@ -30,4 +30,8 @@ public interface SystemMessageDao extends PagingAndSortingRepository<SystemMessa
    //获取资质申请审核有效的未结束已发送的消息
    @Query("select a from SystemMessageDO a where a.type in ('401','408') and a.del='1' and a.over='1' and relationCode = ?1  ")
    List<SystemMessageDO> findMessageByRelationCode(String relationCode);
    @Modifying
    @Query("delete from SystemMessageDO a   where a.receiver = ?1 and a.relationCode = ?2 and a.type =?3")
    int orderMessageDelByType(String doctor, String orderId,String type);
}

common/common-entity/src/main/java/com/yihu/jw/entity/care/securitymonitoring/SecurityMonitoringConclusionDO.java

@@ -13,7 +13,7 @@ import javax.persistence.Table;
@Table(name = "base_security_monitoring_conclusion")
public class SecurityMonitoringConclusionDO extends UuidIdentityEntityWithOperator {
    private String orerId;//工单id
    private String orderId;//工单id
    private String patient;//工单服务的居民
    private String patientName;//居民姓名
    private String doctor;//医生
@@ -21,12 +21,12 @@ public class SecurityMonitoringConclusionDO extends UuidIdentityEntityWithOperat
    private Integer status;//处置状态 1已确认安全 2已转送医疗机构 3已处置完成
    private String conclusion;//处置小结
    public String getOrerId() {
        return orerId;
    public String getOrderId() {
        return orderId;
    }
    public void setOrerId(String orerId) {
        this.orerId = orerId;
    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }
    public String getPatient() {

common/common-entity/src/main/java/com/yihu/jw/entity/care/securitymonitoring/SecurityMonitoringDoctorStatusDo.java

@@ -0,0 +1,78 @@
package com.yihu.jw.entity.care.securitymonitoring;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
* 医生安防服务工单状态情况
*
* @author Administrator on  2019年03月19日
*
*/
@Entity
@Table(name = "base_semoni_doctor_status")
public class SecurityMonitoringDoctorStatusDo extends UuidIdentityEntityWithOperator {
    /**
     * 医生派单状态
     */
    public enum Status {
        waitForSend(1, "待派单"),
        waitForAccept(2, "待接单"),
        waitForServe(3, "待服务"),
        serving(4, "服务中"),
        stopped(5, "停止接单");
        private Integer type;
        private String desc;
        Status(Integer type, String desc) {
            this.type = type;
            this.desc = desc;
        }
        public Integer getType() {
            return type;
        }
        public void setType(Integer type) {
            this.type = type;
        }
    }
    /**
     * wlyy_doctor中医生code
     */
    private String doctor;
    /**
     * 医生状态：1-待派单，2-待接单，3-待服务，4-服务中，5-停止接单
     */
    private Integer status;
	@Column(name = "doctor")
    public String getDoctor() {
        return doctor;
    }
    public void setDoctor(String doctor) {
        this.doctor = doctor;
    }
	@Column(name = "status")
    public Integer getStatus() {
        return status;
    }
    public void setStatus(Integer status) {
        this.status = status;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/care/securitymonitoring/SecurityMonitoringOrderCancelLog.java

@@ -0,0 +1,86 @@
package com.yihu.jw.entity.care.securitymonitoring;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yihu.jw.entity.UuidIdentityEntity;
import org.springframework.expression.EvaluationContext;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.util.Date;
/**
 * Created by Bing on 2021/4/7.
 */
@Entity
@Table(name="base_security_monitoring_order_cancel_log")
public class SecurityMonitoringOrderCancelLog extends UuidIdentityEntity {
    /**
     * 工单id
     */
    private String orderId;
    /**
     * 居民code
     */
    private String patient;
    /**
     * 取消类型：1-调度员取消，2-居民取消
     */
    private Integer cancelType;
    /**
     * 取消理由
     */
    private String cancelReason;
    /**
     * 取消时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
    private Date time;
    @Column(name = "order_id")
    public String getOrderId() {
        return orderId;
    }
    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }
    @Column(name = "patient")
    public String getPatient() {
        return patient;
    }
    public void setPatient(String patient) {
        this.patient = patient;
    }
    @Column(name = "cancel_type")
    public Integer getCancelType() {
        return cancelType;
    }
    public void setCancelType(Integer cancelType) {
        this.cancelType = cancelType;
    }
    @Column(name = "cancel_reason")
    public String getCancelReason() {
        return cancelReason;
    }
    public void setCancelReason(String cancelReason) {
        this.cancelReason = cancelReason;
    }
    @Column(name = "time")
    public Date getTime() {
        return time;
    }
    public void setTime(Date time) {
        this.time = time;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/care/securitymonitoring/SecurityMonitoringOrderDO.java

@@ -23,7 +23,7 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
        cancel(-1, "已取消"),
        waitForSend(1, "待处置"),
        waitForAccept(2, "前往居民定位"),
        waitForArrive(2, "前往居民定位"),
        signed(3, "已签到"),
        registerSummary(4, "已登记小结,"),
        waitForAdded(5, "待补录"),
@@ -274,7 +274,7 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
    /**
     * 服务小结
     */
    private SecurityMonitoringOrderDO monitoringOrder;
    private SecurityMonitoringConclusionDO monitoringConclusion;
    /**
     * 服务医生响应时间（第一条咨询或者接单时间）
@@ -314,15 +314,16 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
    private String hospital;
    private Integer conclusionStatus;//服务小结登记状态：1待补录；2-已补录
    private Integer type;//发起工单类型（1本人发起 2家人待预约 3医生代预约）
    private String authorizeImage;//电子健康卡授权图片
    private String relationCode;//业务关联
    private String serviceStatus;//服务类型 1-预约项目 2-即时项目
    private String orderInfo;//工单详情 0-未推送 1-未确认 2-已确认
    private String doctorConfirmFinishImg;
    /**
     * 快捷类型，1是快捷类型，其他值不是
     * 医生确认医生结束服务时间
     */
    private String shortcutType;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
    private Date doctorConfirmFinishFinishTime;
@@ -562,12 +563,12 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
    }
    @Transient
    public SecurityMonitoringOrderDO getMonitoringOrder() {
        return monitoringOrder;
    public SecurityMonitoringConclusionDO getMonitoringConclusion() {
        return monitoringConclusion;
    }
    public void setMonitoringOrder(SecurityMonitoringOrderDO monitoringOrder) {
        this.monitoringOrder = monitoringOrder;
    public void setMonitoringConclusion(SecurityMonitoringConclusionDO monitoringConclusion) {
        this.monitoringConclusion = monitoringConclusion;
    }
    @Column(name = "service_response_time")
@@ -632,6 +633,14 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
        this.type = type;
    }
    public String getAuthorizeImage() {
        return authorizeImage;
    }
    public void setAuthorizeImage(String authorizeImage) {
        this.authorizeImage = authorizeImage;
    }
    @Column(name = "relation_code")
    public String getRelationCode() {
        return relationCode;
@@ -659,15 +668,6 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
        this.orderInfo = orderInfo;
    }
    @Column(name = "shortcut_type")
    public String getShortcutType() {
        return shortcutType;
    }
    public void setShortcutType(String shortcutType) {
        this.shortcutType = shortcutType;
    }
    public Integer getConclusionStatus() {
        return conclusionStatus;
    }
@@ -675,4 +675,20 @@ public class SecurityMonitoringOrderDO extends UuidIdentityEntityWithOperator {
    public void setConclusionStatus(Integer conclusionStatus) {
        this.conclusionStatus = conclusionStatus;
    }
    public String getDoctorConfirmFinishImg() {
        return doctorConfirmFinishImg;
    }
    public void setDoctorConfirmFinishImg(String doctorConfirmFinishImg) {
        this.doctorConfirmFinishImg = doctorConfirmFinishImg;
    }
    public Date getDoctorConfirmFinishFinishTime() {
        return doctorConfirmFinishFinishTime;
    }
    public void setDoctorConfirmFinishFinishTime(Date doctorConfirmFinishFinishTime) {
        this.doctorConfirmFinishFinishTime = doctorConfirmFinishFinishTime;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/care/securitymonitoring/SecurityMonitoringOrderPatientConfirmLog.java

@@ -0,0 +1,81 @@
package com.yihu.jw.entity.care.securitymonitoring;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
 * Created by Bing on 2021/4/7.
 */
@Entity
@Table(name="base_semoni_patient_confirm_log")
public class SecurityMonitoringOrderPatientConfirmLog extends UuidIdentityEntityWithOperator {
    /**
     * 工单id
     */
    private String orderId;
    /**
     * 居民
     */
    private String patient;
    /**
     * 居民姓名
     */
    private String patientName;
    /**
     * 确认操作类型：1-确认基础信息无误或变更，2-确认上门医生变更上门信息，3-同意工单转接,4-同意取消工单
     */
    private Integer type;
    /**
     * 操作描述
     */
    private String description;
    @Column(name = "order_id")
    public String getOrderId() {
        return orderId;
    }
    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }
    @Column(name = "patient")
    public String getPatient() {
        return patient;
    }
    public void setPatient(String patient) {
        this.patient = patient;
    }
    @Column(name = "patient_name")
    public String getPatientName() {
        return patientName;
    }
    public void setPatientName(String patientName) {
        this.patientName = patientName;
    }
    @Column(name = "type")
    public Integer getType() {
        return type;
    }
    public void setType(Integer type) {
        this.type = type;
    }
    @Column(name = "description")
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/care/sign/CapacityAssessmentBaseInfoDo.java

@@ -32,19 +32,20 @@ public class CapacityAssessmentBaseInfoDo extends UuidIdentityEntityWithCreateTi
    private String  pensionCount;  //养老金收入 元/月
    private String  familyType;    //是否为经济困难家庭 0否 1特困 2低保 3低保边缘
    private String  disabilityCertificate; //是否为持证残疾人 0否 1是
    private String  medicalInsuranceType; //医保类别 1职工基本医疗保险 2城乡居民基本医疗保险 3其他医疗保障 4无任何保障
    private String  medicalInsurance;  //是否购买了商业健康（医疗）保险 0否 1是
    private String  livingType;    //现住场所:1自有产权房、私房等;2各类租赁房等;3养老院或类似机构;4护理院或类似机构;5医院或类似机构
    private String  livingTogether;    //同居者类型 0独居;1与配偶/伴侣居住;2与子女居住;3与孙辈居住;4与父母居住;5与兄弟姐妹居住;6与其他亲友居住;7其他
    private String  livingTogetherRemark; //同居者备注
    private String  dementiaFlag;  //痴呆症 0无 1有
    private String  MentalIllness; //精神疾病（可多选）0无;1精神分裂症;2双相情感障碍;3偏执性精神障碍;4分裂情感性障碍;5癫痫所致精神障碍;6精神发育迟滞伴发精神障碍
    private String  mentalIllness; //精神疾病（可多选）0无;1精神分裂症;2双相情感障碍;3偏执性精神障碍;4分裂情感性障碍;5癫痫所致精神障碍;6精神发育迟滞伴发精神障碍
    private String  diseaseType;   //患病类型可多选;0无 1肿瘤(晚期)2严重心律失常3压疮4慢性心力衰竭(心功能III-IV级)5慢性肾功能衰竭(尿毒症期)6多器官功能衰竭7蛋白质能量营养不足(重度)8慢性阻塞性肺疾病(肺心病心功能III-IV级)9呼吸衰竭10脑血管意外合并吞咽障碍11其他
    private String  diseaseRemark; //其他疾病
    private String  fallLately;    //近30天跌倒 0无;1一次;2两次;3三次及以上
    private String  lostLately;    //近30天走失 0无;1一次;2两次;3三次及以上
    private String  chokingLately; //近30天噎食 0无;1一次;2两次;3三次及以上
    private String  suicideLately; //近30天自杀 0无;1一次;2两次;3三次及以上
    private String  remarkLately;  //近30天意外 其他 0无;1一次;2两次;3三次及以上
    private String  remarkLately;  //近30天意外 其他
    private String  medicalServices;   //近7天是否接受过医疗护理服务 0无1有
    private String  domicileCounty;    //户籍  区(县、市)
    private String  domicileStreet;   //户籍  街(镇）
@@ -231,6 +232,14 @@ public class CapacityAssessmentBaseInfoDo extends UuidIdentityEntityWithCreateTi
        this.disabilityCertificate = disabilityCertificate;
    }
    public String getMedicalInsuranceType() {
        return medicalInsuranceType;
    }
    public void setMedicalInsuranceType(String medicalInsuranceType) {
        this.medicalInsuranceType = medicalInsuranceType;
    }
    public String getMedicalInsurance() {
        return medicalInsurance;
    }
@@ -272,11 +281,11 @@ public class CapacityAssessmentBaseInfoDo extends UuidIdentityEntityWithCreateTi
    }
    public String getMentalIllness() {
        return MentalIllness;
        return mentalIllness;
    }
    public void setMentalIllness(String mentalIllness) {
        MentalIllness = mentalIllness;
        this.mentalIllness = mentalIllness;
    }
    public String getDiseaseType() {

common/common-entity/src/main/java/com/yihu/jw/entity/care/sign/CapacityAssessmentLivingAbilityDo.java

@@ -23,7 +23,7 @@ public class CapacityAssessmentLivingAbilityDo extends UuidIdentityEntityWithCre
    private String  excretionAbilityScore;  //排便控制能力得分 10可自主控制;5偶尔失控(每周小于一次，或需要他人提示);0完全失控
    private String  urinationAbilityScore;  //排尿控制能力得分 10可自主控制;5偶尔失控(每周小于一次，或需要他人提示);0完全失控或留置导尿管
    private String  toiletAbilityScore; //如厕能力得分 10可独立完成;5需部分帮助;0需要极大帮助或完全依赖他人
    private String  transferBedAbility_score;   //床椅转移能力得分 15可独立完成10需要部分帮忙5需要极大帮忙0完全依赖他人
    private String  transferBedAbilityScore;   //床椅转移能力得分 15可独立完成10需要部分帮忙5需要极大帮忙0完全依赖他人
    private String  walkingAbilityScore;    //平地行走能力得分 15可独立行走45m;10需要部分帮助;5需要极大帮助;0完全依赖他人
    private String  downStairsAbilityScore; //上下楼梯能力得分10可独立上下楼梯(连续10~15个台阶);5需要部分帮忙0需要极大帮助或完全依赖他人
    private String  totalScore; //日常生活能力总分 上述得分和 总分100
@@ -109,12 +109,12 @@ public class CapacityAssessmentLivingAbilityDo extends UuidIdentityEntityWithCre
        this.toiletAbilityScore = toiletAbilityScore;
    }
    public String getTransferBedAbility_score() {
        return transferBedAbility_score;
    public String getTransferBedAbilityScore() {
        return transferBedAbilityScore;
    }
    public void setTransferBedAbility_score(String transferBedAbility_score) {
        this.transferBedAbility_score = transferBedAbility_score;
    public void setTransferBedAbilityScore(String transferBedAbilityScore) {
        this.transferBedAbilityScore = transferBedAbilityScore;
    }
    public String getWalkingAbilityScore() {

common/common-entity/src/main/java/com/yihu/jw/entity/hospital/message/SystemMessageDO.java

@@ -18,7 +18,7 @@ import java.util.Date;
public class SystemMessageDO extends UuidIdentityEntity {
    /**
     *消息类型 上门服务400开头，生活照料500开头
     *消息类型 上门服务400开头，生活照料500开头 ,安防监控600开头
     */
    private String type;
    /**

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/device/PatientDeviceDao.java

@@ -47,5 +47,8 @@ public interface PatientDeviceDao extends PagingAndSortingRepository<PatientDevi
    @Query("select a from PatientDevice a")
    List<PatientDevice> findAll();
    @Query("select a from PatientDevice a where a.user=?1 and a.del=0")
    List<PatientDevice> findAllByUser(String user);
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/security/SecurityMonitoringConclusionDao.java

@@ -0,0 +1,17 @@
package com.yihu.jw.care.dao.security;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringConclusionDO;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by Bing on 2021/4/7.
 */
public interface SecurityMonitoringConclusionDao extends PagingAndSortingRepository<SecurityMonitoringConclusionDO,String>,
        JpaSpecificationExecutor<SecurityMonitoringConclusionDO> {
    @Query("select c from SecurityMonitoringConclusionDO c where c.orderId = ?1")
    SecurityMonitoringConclusionDO findByOrderId(String orderId);
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/security/SecurityMonitoringDoctorStatusDao.java

@@ -0,0 +1,16 @@
package com.yihu.jw.care.dao.security;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringDoctorStatusDo;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by Bing on 2021/4/7.
 */
public interface SecurityMonitoringDoctorStatusDao extends PagingAndSortingRepository<SecurityMonitoringDoctorStatusDo,String>,
        JpaSpecificationExecutor<SecurityMonitoringDoctorStatusDo> {
    SecurityMonitoringDoctorStatusDo findByDoctor(String doctor);
    SecurityMonitoringDoctorStatusDo queryByDoctorAndStatusIn(String doctor, Integer[] status);
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/security/SecurityMonitoringOrderCancelLogDao.java

@@ -0,0 +1,14 @@
package com.yihu.jw.care.dao.security;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringOrderCancelLog;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by Bing on 2021/4/7.
 */
public interface SecurityMonitoringOrderCancelLogDao extends PagingAndSortingRepository<SecurityMonitoringOrderCancelLog,String>,
        JpaSpecificationExecutor<SecurityMonitoringOrderCancelLog> {
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/security/SecurityMonitoringOrderDao.java

@@ -0,0 +1,24 @@
package com.yihu.jw.care.dao.security;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringOrderDO;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
 * Created by Bing on 2021/4/6.
 */
public interface SecurityMonitoringOrderDao extends PagingAndSortingRepository<SecurityMonitoringOrderDO,String>,
        JpaSpecificationExecutor<SecurityMonitoringOrderDO> {
    boolean existsByPatientAndStatusIn(String patient,Integer[] status);
    @Modifying
    @Transactional
    @Query("update SecurityMonitoringOrderDO o set o.conclusionStatus = 1,o.status='4' where o.id=?1")
    void updateConclusionStatus(String orderId);
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/dao/security/SecurityMonitoringOrderPatientConfirmLogDao.java

@@ -0,0 +1,12 @@
package com.yihu.jw.care.dao.security;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringOrderPatientConfirmLog;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by Bing on 2021/4/7.
 */
public interface SecurityMonitoringOrderPatientConfirmLogDao extends PagingAndSortingRepository<SecurityMonitoringOrderPatientConfirmLog,String>,
        JpaSpecificationExecutor<SecurityMonitoringOrderPatientConfirmLog> {
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/endpoint/security/SecurityMonitoringOrderEndpoint.java

@@ -0,0 +1,201 @@
package com.yihu.jw.care.endpoint.security;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.care.aop.ObserverRequired;
import com.yihu.jw.care.service.security.SecurityMonitoringOrderService;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringConclusionDO;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringOrderDO;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
 * 安防监护 服务工单
 * Created by Bing on 2021/4/6.
 */
@RestController
@RequestMapping(value = "security/order")
@Api(description = "安防监护 服务工单相关")
public class SecurityMonitoringOrderEndpoint extends EnvelopRestEndpoint {
    @Autowired
    private SecurityMonitoringOrderService securityMonitoringOrderService;
    @PostMapping(value = "createOrder")
    @ApiOperation(value = "创建安防服务工单")
    public ObjEnvelop createOrder(@ApiParam(name="jsonData",value = "json数据",required = true)
                               @RequestParam(value = "jsonData")String jsonData){
        try {
            JSONObject result = securityMonitoringOrderService.createOrder(jsonData);
            if (result.getIntValue("resultFlag") == 0) {
                return ObjEnvelop.getError(result.getString("resultMsg"));
            }
            return ObjEnvelop.getSuccess("创建成功",result);
        }catch (Exception e){
            e.printStackTrace();
            return ObjEnvelop.getError("创建失败"+e.getMessage());
        }
    }
    @GetMapping(value = "getSecurityOrderList")
    @ApiOperation(value = "获取安防工单列表")
    public ListEnvelop getSecurityOrderList(@ApiParam(name="doctor",value = "医生ID",required = true)
                                            @RequestParam(value = "doctor")String doctor,
                                            @ApiParam(name="patient",value = "patient")
                                            @RequestParam(value = "patient",required = false)String patient,
                                            @ApiParam(name="status",value = "工单状态-1已取消1待处置2前往居民定位3已签到4已登记小结5待补录6待评价7已完成")
                                            @RequestParam(value = "status",required = false)String status,
                                            @ApiParam(name="page",value = "page",required = true)
                                            @RequestParam(value = "page")Integer page,
                                            @ApiParam(name="pageSize",value = "pageSize",required = true)
                                            @RequestParam(value = "pageSize")Integer pageSize){
        try {
            page = page>1?page-1:0;
            return ListEnvelop.getSuccess("查询成功",securityMonitoringOrderService.getSecurityOrderList(doctor, patient, status, page, pageSize));
        }catch (Exception e){
            e.printStackTrace();
            return ListEnvelop.getError("查询失败");
        }
    }
    @PostMapping("acceptOrder")
    @ApiOperation(value = "接单")
    @ObserverRequired
    public ObjEnvelop acceptOrder(
            @ApiParam(value = "工单id", name = "orderId", required = true) @RequestParam(value = "orderId", required = true) String orderId,
            @ApiParam(value = "医生code", name = "doctor", required = true) @RequestParam(value = "doctor", required = true) String doctor) {
        try {
            securityMonitoringOrderService.acceptOrder(orderId,doctor);
            return ObjEnvelop.getSuccess("操作成功",200);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError( "操作失败!" + e.getMessage());
        }
    }
    @PostMapping(value = "cancelOrder")
    @ApiOperation(value = "取消工单")
    public Envelop cancelOrder(
            @ApiParam(name = "orderId", value = "工单id") @RequestParam(value = "orderId", required = true) String orderId,
            @ApiParam(name = "reason", value = "取消理由") @RequestParam(value = "reason", required = true) String reason) {
        JSONObject result = new JSONObject();
        try{
            result = securityMonitoringOrderService.cancelOrder(orderId, 2, reason,null,null);
            if (result.getIntValue("resultFlag") == 0) {
                return ObjEnvelop.getError(result.getString("resultMsg"));
            }
            return ObjEnvelop.getSuccess("创建成功");
        }catch (Exception e){
            e.printStackTrace();
            return ObjEnvelop.getError("工单取消失败"+e.getMessage());
        }
    }
    @PostMapping("signIn")
    @ApiOperation(value = "上门服务签到")
    public ObjEnvelop signIn(
            @ApiParam(value = "工单id", name = "orderId")
            @RequestParam(value = "orderId", required = true) String orderId,
            @ApiParam(value = "签到时间", name = "signTime")
            @RequestParam(value = "signTime", required = false) String signTime,
            @ApiParam(value = "签到方式：1-定位，2-扫码，3-拍照", name = "signWay")
            @RequestParam(value = "signWay", required = false) Integer signWay,
            @ApiParam(value = "签到地址", name = "signLocation")
            @RequestParam(value = "signLocation", required = false) String signLocation,
            @ApiParam(value = "签到照片", name = "signImg")
            @RequestParam(value = "signImg", required = false) String signImg,
            @ApiParam(value = "二维码内容", name = "twoDimensionalCode")
            @RequestParam(value = "twoDimensionalCode", required = false) String twoDimensionalCode) {
        try {
            SecurityMonitoringOrderDO securityMonitoringOrderDO = securityMonitoringOrderService.signIn(orderId, signTime, signWay, signLocation, signImg,twoDimensionalCode,getUID());
            if (securityMonitoringOrderDO != null){
                return ObjEnvelop.getSuccess("操作成功", securityMonitoringOrderDO);
            }else {
                return ObjEnvelop.getError("扫码签到失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError( "操作失败!" + e.getMessage());
        }
    }
    @PostMapping("updateDoorConclusion")
    @ApiOperation("编辑保存服务工单小结")
    public ObjEnvelop updateDoorConclusion(
            @ApiParam(value = "服务小结json",name = "model")
            @RequestParam String model,
            @ApiParam(value = "补录状态", name = "examPapeStatus")
            @RequestParam(value = "examPapeStatus", required = false) Integer examPapeStatus) {
        try {
            SecurityMonitoringConclusionDO doorConclusion = securityMonitoringOrderService.updateDoorConclusion(model, examPapeStatus);
            return ObjEnvelop.getSuccess( "保存成功", doorConclusion);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError( "保存失败!" + e.getMessage());
        }
    }
    @PostMapping(value = "cancelConclusion")
    @ResponseBody
    @ApiOperation("取消登记服务小结")
    public ObjEnvelop cancelConclusion(@ApiParam(name = "orderId", value = "工单id", required = true) @RequestParam String orderId) {
        try {
            securityMonitoringOrderService.cancelConclusion(orderId);
            return ObjEnvelop.getSuccess("取消成功",200);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("取消失败");
        }
    }
    @GetMapping("getDoorConclusion")
    @ApiOperation("获取服务工单小结")
    public ObjEnvelop getDoorConclusion(
            @ApiParam(value = "医生code", name = "doctor")
            @RequestParam(value = "doctor", required = false) String doctor,
            @ApiParam(value = "工单id", name = "orderId")
            @RequestParam(value = "orderId", required = false) String orderId) {
        try {
            // 没有提供工单id的情况下，默认代入上一次服务信息记录
            if (StringUtils.isEmpty(orderId)) {
                orderId = securityMonitoringOrderService.getOrderIdByDoctor(doctor);
                if (StringUtils.isEmpty(orderId)) {
                    return ObjEnvelop.getError("获取失败，该医生暂无工单" );
                }
            }
            // 根据orderId查询工单小结表
            SecurityMonitoringConclusionDO doorConclusion = securityMonitoringOrderService.getDoorConclusion(orderId);
            return ObjEnvelop.getSuccess("获取成功", doorConclusion);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("获取失败!" + e.getMessage());
        }
    }
    @PostMapping("saveOrderFinishBydoctor")
    @ApiOperation(value = "医生确认完成工单")
    @ObserverRequired
    public ObjEnvelop saveOrderFinishBydoctor(
            @ApiParam(value = "工单id", name = "orderId")
            @RequestParam(value = "orderId", required = true) String orderId,
            @ApiParam(value = "医生确认结束服务照片", name = "finishImg")
            @RequestParam(value = "finishImg", required = false) String finishImg) {
        try {
            return ObjEnvelop.getSuccess("操作成功", securityMonitoringOrderService.saveOrderFinishBydoctor(orderId, finishImg));
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError( "操作失败!" + e.getMessage());
        }
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/endpoint/sign/SignEndpoint.java

@@ -144,6 +144,21 @@ public class SignEndpoint extends EnvelopRestEndpoint {
        }
    }
    @GetMapping(value = "servicePackageByPatient")
    @ApiOperation(value = "获取患者服务包")
    public ObjEnvelop servicePackageByPatient (
            @ApiParam(name = "patient", value = "患者id", required = true)
            @RequestParam(value = "patient") String patient,
            @ApiParam(name = "packageType", value = "服务包类型1养老服务、2医疗服务、3安防监护、4慢病管理", required = false)
            @RequestParam(value = "packageType",required = false) String packageType) throws Exception {
        try{
            return ObjEnvelop.getSuccess("查询成功",servicePackageService.servicePackageByPatient(patient, packageType));
        }catch (Exception e){
            e.printStackTrace();
            return ObjEnvelop.getError("查询失败");
        }
    }
    @GetMapping(value = "isCapacityAssessment" )
    @ApiOperation(value = "查询今年是否进行过能力评估")
    public ObjEnvelop isCapacityAssessment(
@@ -216,6 +231,29 @@ public class SignEndpoint extends EnvelopRestEndpoint {
        }
    }
    @PostMapping(value = "capacityAssessmentByPatient" )
    @ApiOperation(value = "通过患者id生成当年能力评估报告")
    @ObserverRequired
    public Envelop capacityAssessmentByPatient(
            @ApiParam(name = "patient", value = "患者id", required = true)
            @RequestParam String patient,
            @ApiParam(name = "doctorId", value = "医生id", required = true)
            @RequestParam String doctorId) {
        try{
            JSONObject result =  capacityAssessmentRecordService.capacityAssessmentByPatient(patient,doctorId);
            if (result.getInteger("status")==1){
                return success("生成成功",result.get("data"));
            }
            else {
                return failed(result.getString("message"),-1);
            }
        }catch (Exception e){
            e.printStackTrace();
            return failed("生成失败",-1);
        }
    }
    @PostMapping(value = "confirmAssessment" )
    @ApiOperation(value = "确认评估结果")
    @ObserverRequired

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/security/SecurityMonitoringOrderService.java

@@ -0,0 +1,757 @@
package com.yihu.jw.care.service.security;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.care.dao.device.PatientDeviceDao;
import com.yihu.jw.care.dao.security.*;
import com.yihu.jw.care.service.sign.ServicePackageService;
import com.yihu.jw.care.util.MessageUtil;
import com.yihu.jw.doctor.dao.BaseDoctorDao;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.base.servicePackage.ServicePackageRecordDO;
import com.yihu.jw.entity.care.device.PatientDevice;
import com.yihu.jw.entity.care.securitymonitoring.*;
import com.yihu.jw.hospital.message.dao.SystemMessageDao;
import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.restmodel.ResponseContant;
import com.yihu.jw.util.common.IdCardUtil;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.util.entity.EntityUtils;
import com.yihu.mysql.query.BaseJpaService;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
 * Created by Bing on 2021/4/6.
 */
@Service
public class SecurityMonitoringOrderService extends BaseJpaService<SecurityMonitoringOrderDO, SecurityMonitoringOrderDao> {
    @Autowired
    private SecurityMonitoringOrderDao securityMonitoringOrderDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private PatientDeviceDao patientDeviceDao;
    @Autowired
    private ServicePackageService servicePackageService;
    @Autowired
    private SecurityMonitoringOrderCancelLogDao securityMonitoringOrderCancelLogDao;
    @Autowired
    private MessageUtil messageUtil;
    @Autowired
    private SecurityMonitoringOrderPatientConfirmLogDao securityMonitoringOrderPatientConfirmLogDao;
    @Autowired
    private SecurityMonitoringDoctorStatusDao doctorStatusDao;
    @Autowired
    private SystemMessageDao systemMessageDao;
    @Autowired
    private BasePatientDao basePatientDao;
    @Autowired
    private BaseDoctorDao baseDoctorDao;
    @Autowired
    private SecurityMonitoringConclusionDao securityMonitoringConclusionDao;
    private Logger logger = LoggerFactory.getLogger(SecurityMonitoringOrderService.class);
    public JSONObject createOrder(String jsonData){
        logger.info("创建上门服务jsonData参数：" + jsonData);
        JSONObject result = new JSONObject();
        JSONObject jsonObjectParam;
        try {
            jsonObjectParam = JSONObject.parseObject(jsonData);
        } catch (Exception e) {
            result.put("resultFlag", 0);
            String failMsg = "参数转换成JSON对象异常：" + e.getMessage();
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        SecurityMonitoringOrderDO orderDO = null;
        try {
            orderDO = EntityUtils.jsonToEntity(jsonObjectParam.get("order").toString(), SecurityMonitoringOrderDO.class);
        } catch (Exception e) {
            result.put("resultFlag", 0);
            String failMsg = "服务工单服务基本信息：" + e.getMessage();
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        orderDO.setStatus(1);
        orderDO.setNumber(getRandomIntStr());
        orderDO.setCreateTime(new Date());
        orderDO.setCreateUser(orderDO.getCreateUser());
        orderDO.setCreateUserName(orderDO.getCreateUserName());
        orderDO.setOrderInfo("0");
        if(StringUtils.isEmpty(orderDO.getPatient())){
            result.put("resultFlag", 0);
            String failMsg = "当前服务对象code为空，请联系管理员检查参数！patient = " + orderDO.getPatient();
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        //签约防走失服务包
        List<ServicePackageRecordDO> signRecords = servicePackageService.servicePackageByPatient(orderDO.getPatient(),"3");
        if (signRecords.size()<0) {
            result.put("resultFlag", 0);
            String failMsg = "当前服务对象未完成签约，请完成签约后再预约服务！";
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        //已取消的订单也可以申请
        boolean bool = securityMonitoringOrderDao.existsByPatientAndStatusIn(orderDO.getPatient(),
                new Integer[]{SecurityMonitoringOrderDO.Status.waitForSend.getType(),
                        SecurityMonitoringOrderDO.Status.waitForArrive.getType(),
                        SecurityMonitoringOrderDO.Status.signed.getType(),
                        SecurityMonitoringOrderDO.Status.registerSummary.getType(),
                        SecurityMonitoringOrderDO.Status.waitForAdded.getType(),
                });
        if(bool){
            String failMsg = "当前服务对象存在未完成的服务，请先完成该服务！";
            result.put("resultFlag", 0);
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        orderDO.setHospital(jsonObjectParam.getJSONObject("hospital").get("code").toString());
        orderDO.setCreateTime(new Date());
        //判断创建预警服务类型,发起类型(1本人发起 2家人待预约 3医生代预约)
        orderDO.setType(3);//发起类型
        orderDO.setServiceStatus("2");
        this.save(orderDO);
        //创建咨询
        org.json.JSONObject successOrNot = null;
        try {
//            successOrNot = consultTeamService.addDoorServiceConsult(orderDO.getId());
            successOrNot = null;//TODO 接单时创建两个人聊天
        } catch (Exception e) {
            String failMsg = "创建咨询时异常： " + e.getMessage();
            result.put("resultFlag", 0);
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        if (Integer.parseInt(successOrNot.get("resultFlag").toString()) == 0) {
            return JSONObject.parseObject(successOrNot.toString());
        }
        return result;
    }
    public JSONArray getSecurityOrderList(String doctor, String patient, String status, Integer page, Integer pageSize){
        String sql = " select p.id patientCode,p.name,p.sex,p.idcard,ord.id orderId,ord.number,ord.serve_desc,ord.create_time,ord.`status`,ord.doctor," +
                "ord.doctor_name,ord.patient_phone from base_security_monitoring_order ord INNER JOIN base_patient p on p.id = ord.patient " +
                "where 1=1 ";
        if (StringUtils.isNotBlank(doctor)){
            sql +=" and ord.doctor = '"+doctor+"' ";
        }
        if (StringUtils.isNotBlank(patient)){
            sql+=" and ord.patient='"+patient+"' ";
        }
        if (StringUtils.isNotBlank(status)){
            sql+=" and ord.status='"+Integer.parseInt(status)+"' ";
        }
        sql+=" order by ord.create_time desc limit " + (page*pageSize) + "," + pageSize;
        List<Map<String,Object>> sqlResult = jdbcTemplate.queryForList(sql);
        JSONArray result = new JSONArray();
        for (Map<String,Object>one:sqlResult){
            JSONObject tmp = new JSONObject();
            tmp.put("patientCode",one.get("patientCode"));
            tmp.put("patientName",one.get("name"));
            tmp.put("sex",one.get("sex"));
            tmp.put("idcard",one.get("idcard"));
            tmp.put("number",one.get("number"));
            tmp.put("id",one.get("orderId"));
            tmp.put("serveDesc",one.get("serve_desc"));
            Date date = (Date)one.get("create_time");
            tmp.put("createTime", DateUtil.dateToStr(date,"yyyy-MM-dd hh:mm:ss"));
            tmp.put("status",one.get("status"));
            tmp.put("doctor",one.get("doctor"));
            tmp.put("doctorName",one.get("doctor_ame"));
            tmp.put("patientPhone",one.get("patient_phone"));
            Integer statustemp = Integer.valueOf(one.get("status")+"");
            String statusName = "";
            switch (statustemp){
                case -1:statusName="已取消";break;
                case 1:statusName="待处置";break;
                case 2:statusName="前往居民定位";break;
                case 3:statusName="已签到";break;
                case 4:statusName="已登记小结";break;
                case 5:statusName="待补录";break;
                case 6:statusName="待评价";break;
                case 7:statusName="已完成";break;
            }
            tmp.put("statusName",statusName);
            result.add(tmp);
            Integer age  = IdCardUtil.getAgeForIdcard(tmp.getString("idcard"));
            tmp.put("age",age);
            //患者设备
            List<PatientDevice> devices = patientDeviceDao.findAllByUser(tmp.get("patientCode").toString());
            if (devices.size()>0){
                tmp.put("deviceFlag","1");
            }
            else {
                tmp.put("deviceFlag","0");
            }
        }
        return result;
    }
    /**
     * 系统更新医生上门服务工单状态
     * @param doctor
     * @param dispatchOrderStatus
     */
    public void updateDispatchStatusBySystem(String doctor, Integer dispatchOrderStatus) {
        SecurityMonitoringDoctorStatusDo doctorSwitch = doctorStatusDao.findByDoctor(doctor);
        if (null != doctorSwitch) {
            doctorSwitch.setStatus(dispatchOrderStatus);
            doctorSwitch.setUpdateTime(new Date());
            doctorSwitch.setCreateUser("System");
            doctorSwitch.setCreateUserName("System");
        } else {
            doctorSwitch = new SecurityMonitoringDoctorStatusDo();
            doctorSwitch.setDoctor(doctor);
            doctorSwitch.setStatus(dispatchOrderStatus);
            doctorSwitch.setCreateTime(new Date());
            doctorSwitch.setCreateUser("System");
            doctorSwitch.setCreateUserName("System");
        }
        doctorStatusDao.save(doctorSwitch);
    }
    public SecurityMonitoringOrderDO acceptOrder1(String orderId,String doctor) throws Exception{
        SecurityMonitoringOrderDO doorServiceOrder = securityMonitoringOrderDao.findOne(orderId);
        if (null == doorServiceOrder) {
            throw new Exception("该工单不存在");
        }
        doorServiceOrder.setStatus(SecurityMonitoringOrderDO.Status.waitForArrive.getType()); //
        this.updateDispatchStatusBySystem(doorServiceOrder.getDoctor(), 3);//待服务
        doorServiceOrder.setServiceResponseTime(new Date());
        //新增工单医生关联关系
//        JSONObject jsonObjectParam = new JSONObject();
//        JSONObject doc = new JSONObject();
//        doc.put("doctor",doorServiceOrder.getDoctor());
//        doc.put("doctorName",doorServiceOrder.getDoctorName());
//        doc.put("hospitalLevel",hospitalLevel);
//        doc.put("doctorJobCode",jobCode);
//        doc.put("doctorJobName",jobCodeName);
//        JSONArray docArr = new JSONArray();
//        docArr.add(doc);
//        jsonObjectParam.put("doctorArr",docArr);
        // 无费用
//        if (wlyyDoorServiceOrderService.orderWithDoctorAdd(new JSONObject(), jsonObjectParam, doorServiceOrder)) return null;
        securityMonitoringOrderDao.save(doorServiceOrder);
        systemMessageDao.orderMessageDelByType(doorServiceOrder.getDoctor(),orderId,"607");
        if(doorServiceOrder.getType() == null|| doorServiceOrder.getType() != 3) {
//            //获取咨询
//            ConsultTeam consultTeam = consultTeamDao.queryByRelationCode(orderId);
//            consultTeam.setDoctor(doorServiceOrder.getDoctor());
//            consultTeam.setDoctorName(doorServiceOrder.getDoctorName());
//            consultTeamDao.save(consultTeam);
//
//            String sessionId = doorServiceOrder.getPatient() + "_" + consultTeam.getConsult() + "_" + doorServiceOrder.getNumber() + "_" + consultTeam.getType();
//            //成功创建服务工单后，居民所在机构调度员向居民发起一条通知服务消息
//
//            // 发送IM消息通知患者医生已接单
//            String noticeContent = "我已接受您的服务工单预约，" + doorServiceOrder.getDoctorName() + "医生正在为您服务！";
////        imUtill.sendIntoTopicIM(doorServiceOrder.getDoctor(), sessionId, consultTeam.getConsult(), noticeContent, doorServiceOrder.getProxyPatient(), doorServiceOrder.getProxyPatientName());
//            wlyyDoorServiceOrderService.qucikSendIM(doorServiceOrder.getId(), doorServiceOrder.getDispatcher(), "智能助手", "1", noticeContent);
//            // 发送居民上门服务简要信息
//            JSONObject orderInfoContent = wlyyDoorServiceOrderService.queryOrderCardInfo(doorServiceOrder);
//            orderInfoContent.put("re_msg_type", 0);
//            wlyyDoorServiceOrderService.qucikSendIM(doorServiceOrder.getId(), doorServiceOrder.getDispatcher(), "智能助手", "2101", orderInfoContent.toJSONString());
        }
        return doorServiceOrder;
    }
    /**
     * 接单
     * @param orderId
     */
    @Transactional(rollbackFor = Exception.class)
    public JSONObject acceptOrder(String orderId,String doctor) throws Exception {
        JSONObject result = new JSONObject();
        SecurityMonitoringOrderDO doorServiceOrderDO = securityMonitoringOrderDao.findOne(orderId);
        if(null == doorServiceOrderDO){
            result.put(ResponseContant.resultFlag, ResponseContant.fail);
            String failMsg = "当前工单不存在，id：" + orderId;
            result.put(ResponseContant.resultMsg, failMsg);
            logger.error(failMsg);
            return result;
        }
        SecurityMonitoringDoctorStatusDo doorDoctorStatusDO = doctorStatusDao.queryByDoctorAndStatusIn(doctor,new Integer[]{SecurityMonitoringDoctorStatusDo.Status.waitForSend.getType(),
                SecurityMonitoringDoctorStatusDo.Status.waitForAccept.getType(),
                SecurityMonitoringDoctorStatusDo.Status.waitForServe.getType(),
                SecurityMonitoringDoctorStatusDo.Status.serving.getType(),
        });
        if(null == doorDoctorStatusDO){
            result.put(ResponseContant.resultFlag, ResponseContant.fail);
            String failMsg = "当前接单的医生不存在或禁止接单，doctor：" + doctor;
            result.put(ResponseContant.resultMsg, failMsg);
            logger.error(failMsg);
            return result;
        }
        BaseDoctorDO doctorDO= baseDoctorDao.findById(doctor);
        doorServiceOrderDO.setDoctor(doctor);
        doorServiceOrderDO.setDoctorName(doctorDO.getName());
        doorServiceOrderDO.setDoctorType("医生");
        doorServiceOrderDO.setStatus(SecurityMonitoringOrderDO.Status.waitForArrive.getType());//前往居民定位
        doorServiceOrderDO.setUpdateUser(doctor);
        doorServiceOrderDO.setUpdateUserName(doctorDO.getName());
        securityMonitoringOrderDao.save(doorServiceOrderDO);
        // 派单时，把医生拉入会话，作为其中一个成员，医生拒单时，退出会话
        //TODO 接单时创建两个人聊天
//        ConsultDo consult = consultDao.queryByRelationCode(orderId);
//        String sessionId = doorServiceOrderDO.getPatient() + "_" + consult.getId() + "_" + doorServiceOrderDO.getNumber() + "_" + consult.getType();
//        imUtill.updateParticipantNew(sessionId,doctor,null);
        // 工单状态变更记录
//        WlyyDoorProcessLogDO processLogDO = new WlyyDoorProcessLogDO();
//        processLogDO.setOrderId(orderId);
//        processLogDO.setStatus(WlyyDoorServiceOrderDO.Status.waitForAccept.getType());
//        processLogDO.setDispatcher(dispatcher);
//        processLogDO.setDispatcherName(dispathcherName);
//        processLogDO.setCreateTime(new Date());
//        wlyyDoorProcessLogDao.save(processLogDO);
        // 发送IM消息通知患者医生已派单
//        String noticeContent = "已转派"+doorServiceOrderDO.getDoctorName()+"医生为您服务，请耐心等待医生接单";
//        this.qucikSendIM(doorServiceOrderDO.getId(), dispatcher, "智能助手","1", noticeContent);
        SecurityMonitoringOrderDO doorServiceOrder = acceptOrder1(orderId, doctor);
        if(doorServiceOrder==null){
            result.put(ResponseContant.resultFlag, ResponseContant.fail);
            String failMsg = "当前接单的医生不存在或禁止接单，doctor：" + doctor;
            result.put(ResponseContant.resultMsg, failMsg);
            logger.error(failMsg);
            return result;
        }
        result.put(ResponseContant.resultFlag, ResponseContant.success);
        result.put(ResponseContant.resultMsg, doorServiceOrder);
        // 发送微信模板消息通知患者医生已接单
//        BasePatientDO patient = basePatientDao.findById(doorServiceOrder.getPatient());//
        // 获取微信模板
//        ConsultDo consult = consultDao.queryByRelationCode(orderId);
//        try {
//            JSONObject json = new JSONObject();
//            if(consult != null) {
//                json.put("consult", consult.getId());
//            }
//            String first = "key1，您好！您的上门预约服务已由【key2】医生接单了";
//            first = first.replace("key1",(patient.getName()==null?"":patient.getName()));
//            first = first.replace("key2", null != doorServiceOrder.getDoctorName() ? doorServiceOrder.getDoctorName() : "");
//            List<BasePatientWechatDo> basePatientWechatDos = basePatientWechatDao.findByWechatIdAndPatientId(wxId,patient.getId());
//            String openId = basePatientWechatDos.get(0).getOpenid();
//            messageUtil.putTemplateWxMessage(wxId,"template_process_feedback","smyyyjjd",openId,first,null,null,30,json,DateUtil.dateToChineseDate(new Date()),"上门服务已接单");
//        }catch (Exception e){
//            e.printStackTrace();
//            logger.error(e.getMessage());
//        }
        //  待接单消息设为已操作， 434 医生接单-- 王五接受了服务工单12345678
        messageUtil.createMessage("医生接单","634",doorServiceOrder.getPatient(),doorServiceOrder.getPatientName(),
                doorServiceOrder.getId(), doorServiceOrder.getDoctor(),doorServiceOrder.getDoctorName() ,null, doorServiceOrder.getDoctor() + "接受了服务工单"+ doorServiceOrder.getNumber());
        return result;
    }
    /**
     * 取消工单
     * @param orderId
     * @param type
     * @param reason
     * @param dispatcher
     * @param dispatcherName
     * @return
     */
    public JSONObject cancelOrder(String orderId,int type,String reason,String dispatcher,String dispatcherName){
        JSONObject result = new JSONObject();
        SecurityMonitoringOrderDO orderDO = securityMonitoringOrderDao.findOne(orderId);
        if(null == orderDO){
            String failMsg = "【取消工单】该工单不存在：," + orderId;
            result.put("resultFlag", 0);
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        //接单前可取消工单
        if(orderDO.getStatus() > SecurityMonitoringOrderDO.Status.waitForSend.getType()){
            String failMsg = "只有医生接单前的工单才可取消：," + orderId;
            result.put("resultFlag", 0);
            result.put("resultMsg", failMsg);
            logger.error(failMsg);
            return result;
        }
        orderDO.setCancelType(type);
        orderDO.setCancelTime(new Date());
        orderDO.setCancelReason(reason);
        orderDO.setStatus(SecurityMonitoringOrderDO.Status.cancel.getType());
        this.save(orderDO);
       if(type == SecurityMonitoringOrderDO.CancelType.patient.getType()){                   //居民取消，消息列表也应该不显示
           messageUtil.updateSecurityMonitoringOrderMessage(orderDO,new String[]{"602","603"},"patientCancel");
        }
        //保存取消记录
        SecurityMonitoringOrderCancelLog cancelLogDO = new SecurityMonitoringOrderCancelLog();
        cancelLogDO.setOrderId(orderId);
        cancelLogDO.setPatient(orderDO.getPatient());
        cancelLogDO.setCancelType(type);
        cancelLogDO.setCancelReason(reason);
        cancelLogDO.setTime(orderDO.getCancelTime());
        securityMonitoringOrderCancelLogDao.save(cancelLogDO);
        //保存居民确认取消记录
        JSONObject confirmInfo = new JSONObject();
        confirmInfo.put("orderId",orderId);
        confirmInfo.put("patient",orderDO.getPatient());
        confirmInfo.put("patientName",orderDO.getPatientName());
        confirmInfo.put("type",4);
        confirmInfo.put("description",reason);
        JSONObject confirmInfoJson = new JSONObject();
        confirmInfoJson.put("confirmInfo",confirmInfo);
        this.orderWithConfirmLogAdd(result,confirmInfo,orderId);
//        Consult consult = consultDao.queryByRelationCode(orderId);
//        // 发送微信模板消息，通知居民工单已取消（smyyyqx-上门预约已取消）
//
//        Patient patient = patientInfoService.findByCode(orderDO.getPatient());
//        WechatTemplateConfig templateConfig = templateConfigDao.findByScene("template_process_feedback","smyyyqx");
//        String first = templateConfig.getFirst().replace("key1", null != patient.getName() ? patient.getName() : "");
//        org.json.JSONObject json = new org.json.JSONObject();
//        json.put("first", first);
//        json.put("keyword1", DateUtil.dateToStrShort(new Date()));
//        json.put("keyword2", "上门预约已取消");
//        json.put("url", templateConfig.getUrl());
//        json.put("remark", templateConfig.getRemark());
//        if(consult != null) {
//            json.put("consult", consult.getCode());
//        }else {
//            json.put("id", orderDO.getId());
//        }
//        pushMsgTask.putWxMsg(tokenUtils.getAccessToken(), 30, patient.getOpenid(), patient.getName(), json);
        result.put("resultFlag", 1);
        result.put("resultMsg", "工单服务已取消！");
        return result;
    }
    @Transactional(rollbackFor = Exception.class)
    public boolean orderWithConfirmLogAdd(JSONObject result, JSONObject jsonObjectParam, String orderId) {
        // 确认信息
        JSONObject confirmInfo = jsonObjectParam.getJSONObject("confirmInfo");
        if (null != confirmInfo) {
            SecurityMonitoringOrderPatientConfirmLog confirmLogDO = null;
            try {
                confirmLogDO = EntityUtils.jsonToEntity(confirmInfo.toString(), SecurityMonitoringOrderPatientConfirmLog.class);
            } catch (Exception e) {
                String failMsg = "工单关联【居民确认操作日志记录】时," + e.getMessage();
                result.put("resultFlag", 0);
                result.put("resultMsg", failMsg);
                logger.error(failMsg);
                return true;
            }
            confirmLogDO.setOrderId(orderId);
            confirmLogDO.setCreateTime(new Date());
            try {
                securityMonitoringOrderPatientConfirmLogDao.save(confirmLogDO);
            } catch (Exception e) {
                String failMsg = "保存工单关联的【居民确认操作日志记录】时：," + e.getMessage();
                result.put("resultFlag", 0);
                result.put("resultMsg", failMsg);
                logger.error(failMsg);
                return true;
            }
        }
        return false;
    }
    /**
     * 签到保存
     * @param orderId
     * @param signTime
     * @param signWay
     * @param signLocation
     * @param signImg
     * @return
     */
    public SecurityMonitoringOrderDO signIn(String orderId, String signTime, Integer signWay, String signLocation,
                                         String signImg, String twoDimensionalCode,String doctorId) throws Exception {
        SecurityMonitoringOrderDO doorServiceOrder = securityMonitoringOrderDao.findOne(orderId);
        doorServiceOrder.setDoctorSignTime(DateUtil.strToDate(signTime));
        doorServiceOrder.setDoctorSignWay(signWay);
        // 签到方式-2扫码时，需要去解析地址
        doorServiceOrder.setDoctorSignLocation(signLocation);
        doorServiceOrder.setDoctorSignImg(org.apache.commons.lang.StringUtils.isEmpty(signImg) ? null : signImg);
        doorServiceOrder.setStatus(SecurityMonitoringOrderDO.Status.signed.getType());
        if(signWay == 4 ){//扫码签到
            if (twoDimensionalCode.equals(doorServiceOrder.getNumber())){
                this.setUpdateColumnInfo(doorServiceOrder);
                doorServiceOrder = securityMonitoringOrderDao.save(doorServiceOrder);
                // 修改医生上门服务工单状态 4服务中
                this.updateDispatchStatusBySystem(doorServiceOrder.getDoctor(), 4);//服务中
                return doorServiceOrder;
            }else {
                logger.info("扫码签到失败");
                return null;
            }
        }else {
            this.setUpdateColumnInfo(doorServiceOrder);
            doorServiceOrder = securityMonitoringOrderDao.save(doorServiceOrder);
            // 修改医生上门服务工单状态 4服务中
            this.updateDispatchStatusBySystem(doorServiceOrder.getDoctor(), 4);
            return doorServiceOrder;
        }
    }
    /**
     * 根据接单医生code获取最近一次服务orderId
     * @param doctor
     * @return
     */
    public String getOrderIdByDoctor(String doctor) {
        String sql = "SELECT id as orderId from base_security_monitoring_order where doctor=? and status in(2,3,4,5,6,7) ORDER BY update_time desc,create_time desc, status ASC limit 1";
        String orderId = jdbcTemplate.queryForObject(sql, String.class, new Object[]{doctor});
        return orderId;
    }
    /**
     * 编辑保存服务工单小结
     * @param model
     * @return
     * @throws Exception
     */
    public SecurityMonitoringConclusionDO updateDoorConclusion(String model, Integer examPapeStatus) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));
        SecurityMonitoringConclusionDO doorConclusion = objectMapper.readValue(model, SecurityMonitoringConclusionDO.class);
        SecurityMonitoringOrderDO one = securityMonitoringOrderDao.findOne(doorConclusion.getOrderId());
        BaseDoctorDO doctorVO = baseDoctorDao.findById(one.getDoctor());
        if (doorConclusion != null && org.apache.commons.lang.StringUtils.isNotEmpty(doorConclusion.getId())) {
            doorConclusion.setUpdateTime(new Date());
            doorConclusion.setUpdateUser(one.getDoctor());
            doorConclusion.setUpdateUserName(null != doctorVO ? doctorVO.getName() : null);
        } else {
            doorConclusion.setCreateTime(new Date());
            doorConclusion.setUpdateTime(new Date());
            doorConclusion.setCreateUser(one.getDoctor());
            doorConclusion.setCreateUserName(null != doctorVO ? doctorVO.getName() : null);
        }
        securityMonitoringConclusionDao.save(doorConclusion);
        // 设置是否需要上传补录报告
        one.setStatus(SecurityMonitoringOrderDO.Status.registerSummary.getType());//已登记服务小结
        one.setExamPaperStatus(examPapeStatus);
        one.setConclusionStatus(2);
        securityMonitoringOrderDao.save(one);
        return doorConclusion;
    }
    /**
     * 跳过登记服务小结
     * @param orderId
     */
    public void cancelConclusion(String orderId) {
        securityMonitoringOrderDao.updateConclusionStatus(orderId);
    }
    /**
     * 统计居民已经服务的次数
     * @param patient
     * @return
     */
    public Integer countPatientDoorTimes(String patient){
        Integer count = 0;
        String sql = "SELECT count(d.id) as count FROM base_security_monitoring_order o  where  o.patient = '" + patient + "' and status>3 ";
        count = jdbcTemplate.queryForObject(sql,Integer.class);
        return count;
    }
    /**
     * 根据orderId获取工单服务小结
     * @param orderId
     * @return
     */
    public SecurityMonitoringConclusionDO getDoorConclusion(String orderId){
        SecurityMonitoringConclusionDO doorConclusion = securityMonitoringConclusionDao.findByOrderId(orderId);
        SecurityMonitoringOrderDO one = securityMonitoringOrderDao.findOne(orderId);
        if (doorConclusion==null&&one!=null) {
            doorConclusion = new SecurityMonitoringConclusionDO();
            doorConclusion.setOrderId(one.getId());
            doorConclusion.setPatient(one.getPatient());
            doorConclusion.setPatientName(one.getPatientName());
            doorConclusion.setDoctor(one.getDoctor());
            doorConclusion.setDoctorName(one.getDoctorName());
        }
        return doorConclusion;
    }
    public SecurityMonitoringOrderDO saveOrderFinishBydoctor(String orderId ,String finishImg) throws Exception {
        SecurityMonitoringOrderDO one = securityMonitoringOrderDao.findOne(orderId);
        one.setDoctorConfirmFinishImg(finishImg);
        one.setStatus(SecurityMonitoringOrderDO.Status.complete.getType());
        one.setDoctorConfirmFinishFinishTime(new Date());
        // 更新记录
        this.setUpdateColumnInfo(one);
        // 计算保存服务总的支付费用
        securityMonitoringOrderDao.save(one);
        SecurityMonitoringOrderDO doorServiceOrderDO = this.getDoorServiceOrderById(orderId);
        // 发送微信通知  待付款
        BasePatientDO patient = basePatientDao.findById(one.getPatient());
        // 获取微信模板 smfwdwk-上门服务待付款
//        Consult consult = consultDao.queryByRelationCode(orderId);
        try {
//            WechatTemplateConfig templateConfig = templateConfigDao.findByScene("template_process_feedback","fwyspf");
//            String first = templateConfig.getFirst();
//            first = first.replace("key1", DateUtil.dateToStr(new Date(), "yyyy-MM-dd HH:mm"));
//            first = first .replace("key2", null != one.getDoctorName() ? one.getDoctorName() : "");
//            org.json.JSONObject json = new org.json.JSONObject();
//            json.put("first", first);
//            json.put("keyword1", DateUtil.dateToStrShort(new Date()));
//            json.put("keyword2", "服务医生评分");
//            json.put("url", templateConfig.getUrl());
//            json.put("remark", templateConfig.getRemark());
//            json.put("id",orderId);
//            //json.put("consult",consult.getCode());
//            WlyyDoorCommentDO wlyyDoorCommentDO = this.DoorCommentDao.selectCommentDoctor(patient.getCode(),orderId);
//            String finish="";
//            if(wlyyDoorCommentDO!=null){
//                finish = "0";
//                json.put("finish",finish);
//            }else {
//                finish = "1";
//                json.put("finish",finish);
//            }
//            pushMsgTask.putWxMsg(tokenUtils.getAccessToken(), 31, patient.getOpenid(), patient.getName(), json);
        }catch (Exception e){
            logger.error(e.getMessage());
        }
        return doorServiceOrderDO;
    }
    /**
     * 根据id获取服务工单信息
     * @param id
     * @return
     */
    public SecurityMonitoringOrderDO getDoorServiceOrderById(String id) throws Exception {
        SecurityMonitoringOrderDO doorServiceOrder = securityMonitoringOrderDao.findOne(id);
        if (null == doorServiceOrder) {
            return null;
        }
        BasePatientDO patient = basePatientDao.findById(doorServiceOrder.getPatient());
        if (patient != null) {
            String sex = IdCardUtil.getSexForIdcard_new(patient.getIdcard());
            int age = IdCardUtil.getAgeByIdcardOrBirthday(patient.getIdcard(),patient.getBirthday());
            doorServiceOrder.setSex("1".equals(sex) ? "男" : "2".equals(sex) ? "女" : "未知");
            doorServiceOrder.setAge(age);
            doorServiceOrder.setPhoto(patient.getPhoto());
//            String typeValues = this.getTypeValueByPatientCode(patient.getCode());
//            doorServiceOrder.setTypeValue(typeValues);
        }
        // 获取服务次数
        Integer count = 1;//本年服务次数 一年只能1次
        Integer times = countPatientDoorTimes(doorServiceOrder.getPatient());//服务次数
//        List<WlyyDoorDoctorDO> djDetailList = this.djDetailList(id,level,times);
//        doorServiceOrder.setDjDetailList(djDetailList);
//        List<Map<String, Object>> feeDetailDOS = this.getDoorFeeDetailGroupByStatus(id);
//        String jsonData = this.serverPackagePriceByOrderId(id);
//        if (null != feeDetailDOS && feeDetailDOS.size() > 0) {
//            // 设置服务项及费用信息
//            doorServiceOrder.setDoorFeeDetailList(feeDetailDOS);
//            //计算扣服务包后应付的服务项费用
//            /*Map<String, Object> map = this.countServerPackagePrice(jsonData, doorServiceOrder.getPatient());
//            BigDecimal cashPrice = this.calculateCash(String.valueOf(map.get("cashPrice")), id, level, times);
//            WlyyDoorServiceOrderDO wlyyDoorServiceOrderDO = this.doorServiceOrderDao.findOne(id);
//            if(wlyyDoorServiceOrderDO.getTotalFee()!=cashPrice){
//                wlyyDoorServiceOrderDO.setTotalFee(cashPrice);
//                wlyyDoorServiceOrderService.save(wlyyDoorServiceOrderDO);
//            }
//            map.put("cashPrice", cashPrice);
//            doorServiceOrder.setServiceCost(map);*/
//        }
        // 服务工单关联的医护人员
//        List<Map<String, Object>> doorServiceDoctors = this.getDoorServiceDoctor(id);
//        if (null != doorServiceDoctors && doorServiceDoctors.size() > 0) {
//            doorServiceOrder.setDoctors(doorServiceDoctors);
//        }
        // 设置医生出诊费信息，先获取工单出诊医生
        /*List<WlyyDoorDoctorDO> doorDoctorDOList = doorDoctorDao.findByOrderId(id);
        if (doorDoctorDOList != null && doorDoctorDOList.size() > 0) {
            Map<String,String> jobName = new HashMap<>();
            Map<String,String> jobCode = new HashMap<>();
            List<Integer> levels = new ArrayList<>();
            for(WlyyDoorDoctorDO doorDoctorDO : doorDoctorDOList){
                jobName.put(doorDoctorDO.getDoctor(),doorDoctorDO.getDoctorJobName());
                jobName.put(doorDoctorDO.getDoctor(),doorDoctorDO.getDoctorJobCode());
                levels.add(doorDoctorDO.getHospitalLevel());
            }
            List<Map<String, Object>> jobFeeList = dmJobService.getJobFeeList(jobCode, jobName, levels, times);
            doorServiceOrder.setVisitCost(jobFeeList);
        }*/
        //获取咨询 //TODO 获取咨询
//        Consult consult = consultDao.queryByRelationCode(id);
//        if (null != consult) {
//            doorServiceOrder.setSessionId(doorServiceOrder.getPatient() + "_" + consult.getCode() + "_"  + doorServiceOrder.getNumber() +  "_" +  consult.getType());
//        }
        // 设置服务小结
        SecurityMonitoringConclusionDO doorConclusion = this.getDoorConclusion(id);
        doorServiceOrder.setMonitoringConclusion(doorConclusion);
        return doorServiceOrder;
    }
    private String getRandomIntStr(){
        Random rand = new Random();
        int i = rand.nextInt(); //int范围类的随机数
        i = rand.nextInt(100); //生成0-100以内的随机数
        i = (int)(Math.random() * 100000000); //0-100以内的随机数，用Matn.random()方式
        return String.valueOf(i);
    }
    private void setUpdateColumnInfo(SecurityMonitoringOrderDO one) {
        one.setUpdateTime(new Date());
        one.setUpdateUser(one.getDoctor());
        one.setUpdateUserName(one.getDoctorName());
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/sign/CapacityAssessmentRecordService.java

@@ -9,8 +9,10 @@ import com.yihu.jw.doctor.dao.BaseDoctorDao;
import com.yihu.jw.doctor.dao.BaseDoctorHospitalDao;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.base.doctor.BaseDoctorHospitalDO;
import com.yihu.jw.entity.base.org.BaseOrgDO;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.care.sign.*;
import com.yihu.jw.org.dao.BaseOrgDao;
import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.rm.base.BaseRequestMapping;
@@ -26,6 +28,7 @@ import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -55,6 +58,8 @@ public class CapacityAssessmentRecordService extends BaseJpaService<CapacityAsse
    private CapacityAssessmentLivingAbilityDao CALivingAbilityDao;
    @Autowired
    private CapacityAssessmentSocialAbilityDao CASocialAbilityDao;
    @Autowired
    private BaseOrgDao baseOrgDao;
    public PageEnvelop<List<Map<String,Object>>> assessmentPage(String doctorId,String name, int page, int size,
                    Integer status,Integer levelConclusion,Integer servicePackageStatus){
@@ -111,6 +116,8 @@ public class CapacityAssessmentRecordService extends BaseJpaService<CapacityAsse
     * @throws Exception
     */
    public void capacityAssessment(String jsonData,String doctorId) throws Exception{
        JSONObject jsonObject = JSONObject.parseObject(jsonData);
        CapacityAssessmentRecordDO recordDO = objectMapper.readValue(jsonObject.getJSONObject("assessment").toJSONString(), CapacityAssessmentRecordDO.class);
@@ -127,6 +134,107 @@ public class CapacityAssessmentRecordService extends BaseJpaService<CapacityAsse
        }
    }
    /**
     * 通过患者id 生成当年评估报告
     * @param patient
     * @param doctorId
     * @throws Exception
     */
    public JSONObject capacityAssessmentByPatient(String patient,String doctorId) throws Exception {
        JSONObject result = new JSONObject();
        String year = DateUtil.getNowYear()+"";
        BasePatientDO patientDO = patientDao.findById(patient);
        if (patientDO!=null){
            CapacityAssessmentRecordDO recordDO = new CapacityAssessmentRecordDO();
            //判断患者是否评估表已填
            JSONObject obj = getAssessmentItemDetail(patient,0,year);
            net.sf.json.JSONObject objTmp = net.sf.json.JSONObject.fromObject(JSON.parseObject(obj.toJSONString()));
            Iterator<String> keys = objTmp.keys();
            boolean finishFlag=true;
            while (keys.hasNext()){
                String key = keys.next();
                net.sf.json.JSONObject tmp = objTmp.getJSONObject(key+"");
                String id = tmp.containsKey("id")?tmp.getString("id"):"";
                if (StringUtils.isBlank(id)){
                    result.put("status",-1);
                    result.put("message","患者存在未完成的评估表"+key);
                    finishFlag=false;
                    break;
                }
            }
            if (!finishFlag){
                return result;
            }
            if(isCapacityAssessment(recordDO.getPatient())==0&&finishFlag){
                List<CapacityAssessmentBaseInfoDo> baseInfoDoList = CAbaseInfoDao.findByPatientAndYear(patient,year);
                if (baseInfoDoList.size()>0){
                    CapacityAssessmentBaseInfoDo baseInfoDo = baseInfoDoList.get(0);
                    if (StringUtils.isNotBlank(baseInfoDo.getName())){
                        recordDO.setName(baseInfoDo.getName());
                    }
                    else {
                        recordDO.setName(patientDO.getName());
                    }
                    recordDO.setPatient(patientDO.getId());
                    if (StringUtils.isNotBlank(baseInfoDo.getIdcard())){
                        recordDO.setIdcard(baseInfoDo.getIdcard());
                        recordDO.setBirthday(IdCardUtil.getBirthdayForIdcard(recordDO.getIdcard()));
                    }
                    else {
                        recordDO.setIdcard(patientDO.getIdcard());
                        recordDO.setBirthday(patientDO.getBirthday());
                    }
                    if (StringUtils.isNotBlank(baseInfoDo.getPatientPhone())){
                        recordDO.setMobile(baseInfoDo.getPatientPhone());
                    }
                    else {
                        recordDO.setMobile(patientDO.getMobile());
                    }
                    //户籍所在地，居住地
                    if (StringUtils.isNotBlank(baseInfoDo.getDomicileStreetName())){
                        String registeredResidence =baseInfoDo.getDomicileCountyName()+baseInfoDo.getDomicileStreetName()
                                +baseInfoDo.getDomicileOrgName()+baseInfoDo.getDomicileBuilding()+baseInfoDo.getDomicileRoom();
                        recordDO.setRegisteredResidence(registeredResidence);
                    }
                    if (StringUtils.isNotBlank(baseInfoDo.getLiveStreetName())){
                        String liveAddress =baseInfoDo.getLiveCountyName()+baseInfoDo.getLiveStreetName()
                                +baseInfoDo.getLiveOrgName()+baseInfoDo.getLiveBuilding()+baseInfoDo.getLiveRoom();
                        recordDO.setLiveAddress(liveAddress);
                    }
                    //评估时间
                    recordDO.setAssessmentTime(baseInfoDo.getCreateTime());
                    BaseDoctorDO doctorDO = doctorDao.findById(doctorId);
                    List<BaseDoctorHospitalDO> doctorHospitalDOs = doctorHospitalDao.findByDoctorCode(doctorId);
                    recordDO.setOrgCode(doctorHospitalDOs.get(0).getOrgCode());
                    BaseOrgDO orgDO = baseOrgDao.findByCode(recordDO.getOrgCode());
                    recordDO.setAssessmentAddress(orgDO.getAddress());// 评估地点
                    recordDO.setOrgName(doctorHospitalDOs.get(0).getOrgName());
                    recordDO.setDoctorName(doctorDO.getName());
                    recordDO.setDoctor(doctorId);
                    recordDO.setServicePackageStatus(0);
                    recordDO.setStatus(0);
                    capacityAssessmentRecordDao.save(recordDO);
                    result.put("status",1);
                    result.put("message","保存成功");
                    result.put("data",recordDO);
                }
                else {
                    result.put("status",-1);
                    result.put("message","未查询到患者基本信息");
                }
            }
            else {
                result.put("status",-1);
                result.put("message","患者已做过能力评估");
            }
        }
        else {
            result.put("status",-1);
            result.put("message","未找到该患者");
        }
        return result;
    }
    /**
     * 确认评估结果
     * @param signUrl

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/sign/ServicePackageService.java

@@ -19,6 +19,7 @@ import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.util.common.IdCardUtil;
import com.yihu.jw.utils.StringUtil;
import com.yihu.mysql.query.BaseJpaService;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@@ -28,10 +29,7 @@ import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
/**
 *
@@ -329,4 +327,21 @@ public class ServicePackageService extends BaseJpaService<ServicePackageDO, Serv
        return PageEnvelop.getSuccessListWithPage("success",list,page,size,count);
    }
    public List<ServicePackageRecordDO> servicePackageByPatient(String patient,String packageType){
        //签约记录
        List<ServicePackageSignRecordDO> signs = servicePackageSignRecordDao.findByStatusAndPatient(1,patient);
        if (signs.size()>0){
            ServicePackageSignRecordDO tmp = signs.get(0);
            String sql = " select r.* from base_service_package_record r inner join base_service_package p on r.service_package_id = p.id " +
                    " and p.del=1  where r.sign_id='"+tmp.getId()+"' ";
            if (StringUtils.isNotBlank(packageType)){
                sql += " and p.type='"+packageType+"' ";
            }
            List<ServicePackageRecordDO> result = jdbcTemplate.query(sql,new BeanPropertyRowMapper(ServicePackageRecordDO.class));
            return result;
        }
        else return new ArrayList<>();
    }
}

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/util/MessageUtil.java

@@ -7,6 +7,7 @@ import com.yihu.jw.entity.base.wx.BasePatientWechatDo;
import com.yihu.jw.entity.base.wx.WxAccessTokenDO;
import com.yihu.jw.entity.base.wx.WxTemplateConfigDO;
import com.yihu.jw.entity.care.lifeCare.LifeCareOrderDO;
import com.yihu.jw.entity.care.securitymonitoring.SecurityMonitoringOrderDO;
import com.yihu.jw.entity.hospital.message.SystemMessageDO;
import com.yihu.jw.hospital.message.dao.SystemMessageDao;
import com.yihu.jw.patient.dao.BasePatientDao;
@@ -305,6 +306,21 @@ public class MessageUtil {
        return messageDO;
    }
    public void createMessage(String title,String type,String sender,String senderName,String relationCode,String Receiver,String ReceiverName,String idCard,String msg){
        SystemMessageDO messageDO = new SystemMessageDO();
        messageDO.setTitle(title);
        messageDO.setType(type);//401为资质申请审核
        messageDO.setSender(sender);
        messageDO.setSenderName(senderName);
        messageDO.setRelationCode(relationCode);
        messageDO.setReceiver(Receiver);
        messageDO.setReceiverName(ReceiverName);
        messageDO.setOver("1");
        messageDO.setData(msg);
        messageDO.setDel("1");
        messageDO.setCreateTime(new Date());
        systemMessageDao.save(messageDO);
    }
    public void updateLifeCareMessage(LifeCareOrderDO orderDO, String[] type, String toType){
        String orderId=orderDO.getId();
@@ -323,4 +339,21 @@ public class MessageUtil {
        }
    }
    public void updateSecurityMonitoringOrderMessage(SecurityMonitoringOrderDO orderDO, String[] type, String toType){
        String orderId=orderDO.getId();
        List<SystemMessageDO> messages = systemMessageDao.queryByRelationCodeAndTypeIn(orderId,type);
        if (toType.equals("patientCancel")){//居民取消 消息列表也应该不显示
            if(CollectionUtils.isEmpty(messages)){
                logger.error("当前安防工单没有系统消息！！orderId:" + orderId);
            } else {
                messages.forEach(
                        message -> {
                            message.setOver("0");
                            systemMessageDao.save(message);
                        }
                );
            }
        }
    }
}