需求分析

存医院的基本信息，保持医院的编号，唯一id和接口调用的相关签名key的信息，开通医院设置信息后，可以上传医院的相关信息

功能点

• 基于单表的CRUD
• 锁定
• 解锁
• 发送签名信息

表结构

CREATE TABLE `hospital_set` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `hosname` varchar(100) DEFAULT NULL COMMENT '医院名称',
  `hoscode` varchar(30) DEFAULT NULL COMMENT '医院编号',
  `api_url` varchar(100) DEFAULT NULL COMMENT 'api基础路径',
  `sign_key` varchar(50) DEFAULT NULL COMMENT '签名秘钥',
  `contacts_name` varchar(20) DEFAULT NULL COMMENT '联系人',
  `contacts_phone` varchar(11) DEFAULT NULL COMMENT '联系人手机',
  `status` tinyint(3) NOT NULL DEFAULT '0' COMMENT '状态',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `is_deleted` tinyint(3) NOT NULL DEFAULT '0' COMMENT '逻辑删除(1:已删除，0:未删除)',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_hoscode` (`hoscode`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='医院设置表';

• hosname ：医院名称
• hoscode ：医院编号，平台分配，全局唯一，api接口必填信息
• api_url ：医院回调的基础url，如预约下单，则调用该接口地址去医院下单
• sign_key ：双方api接口调用的签名key，由平台生成
• contacts_name ：联系人姓名
• contacts_phone ：联系人电话
• status ：状态
  • 锁定 0 ：表示不可以使用
  • 解锁 1：表示可以使用

搭建模块 service-hosp

在父模块service下创建子模块，操作步骤同 common下的common-util

创建完成后，在src/main/java下

• 新建 com.stt.yygh.hosp 包
• 新建 com.stt.yygh.hosp.controller 包
• 新建 com.stt.yygh.hosp.service 包
• 新建 com.stt.yygh.hosp.mapper 包

修改pom文件

找到 serivce-hosp 项目下的pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>service</artifactId>
        <groupId>com.stt.yygh</groupId>
        <version>0.0.1</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <version>1.0</version>
    <artifactId>service-hosp</artifactId>
    <packaging>jar</packaging>
    <name>service-hosp</name>
    <description>service-hosp</description>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
    </dependencies>

    <build>
        <finalName>service-hosp</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

添加application.properties文件

application.properties 配置内容如下

# 服务端口
server.port=8201
# 服务名
spring.application.name=service-hosp

# 环境设置：dev、test、prod
spring.profiles.active=dev

# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/yygh_hosp?characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

#返回json的全局时间格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

#配置mapper xml文件的路径
mybatis-plus.mapper-locations=classpath:com/stt/yygh/mapper/xml/*.xml

添加启动类

创建包 com.stt.yygh.hosp

在该包下添加 ServiceHospApplication.java文件，内容如下

package com.stt.yygh.hosp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ServiceHospApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceHospApplication.class, args);
    }
}

注意：添加完成后，验证该服务是否可以启动成功

基础实现

添加实体类 BaseEntity

在 model 模块中创建包 com.stt.yygh.model.base

添加实体类 BaseEntity，所有实体类的父类，包含公共信息如下

• id
  • 每个对象的主键id
• createTime
  • 使用了jackson 的注解进行格式化，并绑定到create_time列
• updateTime
  • 与createTime类似的操作
• isDeleted
  • 逻辑删除列，使用了mybatisPlus的TableLogic注解指明
• param
  • 通过 mybatisPlus中 TableField 注解设置为非数据库字段
  • 用于bean传递额外的参数使用

package com.stt.yygh.model.base;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Data
public class BaseEntity implements Serializable {

    @ApiModelProperty(value = "id")
    @TableId(type = IdType.AUTO)
    private Long id;

    @ApiModelProperty(value = "创建时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @TableField("create_time")
    private Date createTime;

    @ApiModelProperty(value = "更新时间")
    @TableField("update_time")
    private Date updateTime;

    @ApiModelProperty(value = "逻辑删除(1:已删除，0:未删除)")
    @TableLogic
    @TableField("is_deleted")
    private Integer isDeleted;

    @ApiModelProperty(value = "其他参数")
    @TableField(exist = false)
    private Map<String,Object> param = new HashMap<>();
}

添加实体类HospitalSet

在model模块中创建 com.stt.yygh.model.hosp 包

在该包下添加 HospitalSet实体类，该实体类与数据库表hospital_set中的列一一对应

package com.stt.yygh.model.hosp;

import com.stt.yygh.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
@ApiModel(description = "医院设置")
@TableName("hospital_set")
public class HospitalSet extends BaseEntity {
	private static final long serialVersionUID = 1L;

	@ApiModelProperty(value = "医院名称")
	@TableField("hosname")
	private String hosname;

	@ApiModelProperty(value = "医院编号")
	@TableField("hoscode")
	private String hoscode;

	@ApiModelProperty(value = "api基础路径")
	@TableField("api_url")
	private String apiUrl;

	@ApiModelProperty(value = "签名秘钥")
	@TableField("sign_key")
	private String signKey;

	@ApiModelProperty(value = "联系人姓名")
	@TableField("contacts_name")
	private String contactsName;

	@ApiModelProperty(value = "联系人手机")
	@TableField("contacts_phone")
	private String contactsPhone;

	@ApiModelProperty(value = "状态")
	@TableField("status")
	private Integer status;

}

service-hosp中添加mapper

• 创建 com.stt.yygh.hosp.mapper 包，并添加 HospitalSetMapper类

package com.stt.yygh.hosp.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.stt.yygh.model.hosp.HospitalSet;
import org.apache.ibatis.annotations.Mapper;

// 可以使用Mapper单独注册，也可以配置MapperScan进行注册
@Mapper
public interface HospitalSetMapper extends BaseMapper<HospitalSet> {
}

• 创建 com.stt.yygh.hosp.mapper.xml 包，并添加 HospitalSetMapper.xml 文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.stt.yygh.hosp.mapper.HospitalSetMapper">
</mapper>

添加全局mybatisPlus配置

由于Mapper接口的实现类是框架自动生成的，如果没有@Mapper注解，那么就不会在spring容器中注册

可以使用全局注册的方式注册

在service-hosp服务中添加配置类 com.stt.yygh.hosp.config.HospitalSetConfig

在配置中添加分页插件拦截器配置

package com.stt.yygh.hosp.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.stt.yygh.hosp.mapper")
public class HospitalSetConfig {

    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

service-hosp中添加service

创建 com.stt.yygh.hosp.service.HospitalSetService接口

package com.stt.yygh.hosp.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.stt.yygh.model.hosp.HospitalSet;

public interface HospitalSetService extends IService<HospitalSet> {
}

创建 com.stt.yygh.hosp.service.HospitalSetServiceImpl 实现类

• 通过MybatisPlus中对service进行封装，提供了CRUD的能力

package com.stt.yygh.hosp.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.stt.yygh.hosp.mapper.HospitalSetMapper;
import com.stt.yygh.hosp.service.HospitalSetService;
import com.stt.yygh.model.hosp.HospitalSet;
import org.springframework.stereotype.Service;

@Service
public class HospitalSetServiceImpl extends ServiceImpl<HospitalSetMapper, HospitalSet> implements HospitalSetService {
    // 由于传递了 HospitalSetMapper ，在 ServiceImpl 中进行了 Autowired操作
    // 因此可以直接通过 baseMapper 变量调用  HospitalSetMapper 中的方法
}

service-hosp中添加controller

添加controller，实现CRUD功能

• 由于com.baomidou.mybatisplus.extension.service.impl.ServiceImpl类已经默认实现 了单表的CRUD，分页查询也有默认实现，能够更加灵活和代码简洁把分页查询功能实现

package com.stt.yygh.hosp.controller;

import com.stt.yygh.hosp.service.HospitalSetService;
import com.stt.yygh.model.hosp.HospitalSet;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Api(tags = "医院设置管理")
@RestController
@RequestMapping("/admin/hosp/hospitalSet")
public class HospitalSetController {

    @Autowired
    private HospitalSetService hospitalSetService;

    //1 查询医院设置表所有信息
    @ApiOperation(value = "获取所有医院设置")
    @GetMapping("findAll")
    public List<HospitalSet> findAll(){
        List<HospitalSet> re = hospitalSetService.list();
        return re;
    }

    //2 逻辑删除医院设置
    @ApiOperation(value = "逻辑删除医院设置")
    @DeleteMapping("{id}")
    public boolean remove(@PathVariable Long id){
        boolean re = hospitalSetService.removeById(id);
        return re;
    }
}

返回信息不统一，需要一个类统一包装一下

配置统一返回

在common的common-util模块中添加 com.stt.yygh.common.result.Result

package com.stt.yygh.common.result;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 全局统一返回结果类
 */
@Data
@ApiModel(value = "全局统一返回结果")
public class Result<T> {

    @ApiModelProperty(value = "返回码")
    private Integer code;

    @ApiModelProperty(value = "返回消息")
    private String message;

    @ApiModelProperty(value = "返回数据")
    private T data;

    public Result(){}

    protected static <T> Result<T> build(T data) {
        Result<T> result = new Result<T>();
        if (data != null)
            result.setData(data);
        return result;
    }

    public static <T> Result<T> build(T body, ResultCodeEnum resultCodeEnum) {
        Result<T> result = build(body);
        result.setCode(resultCodeEnum.getCode());
        result.setMessage(resultCodeEnum.getMessage());
        return result;
    }

    public static <T> Result<T> build(Integer code, String message) {
        Result<T> result = build(null);
        result.setCode(code);
        result.setMessage(message);
        return result;
    }

    public static<T> Result<T> ok(){
        return Result.ok(null);
    }

    /**
     * 操作成功
     * @param data
     * @param <T>
     * @return
     */
    public static<T> Result<T> ok(T data){
        Result<T> result = build(data);
        return build(data, ResultCodeEnum.SUCCESS);
    }

    public static<T> Result<T> fail(){
        return Result.fail(null);
    }

    /**
     * 操作失败
     * @param data
     * @param <T>
     * @return
     */
    public static<T> Result<T> fail(T data){
        Result<T> result = build(data);
        return build(data, ResultCodeEnum.FAIL);
    }

    public Result<T> message(String msg){
        this.setMessage(msg);
        return this;
    }

    public Result<T> code(Integer code){
        this.setCode(code);
        return this;
    }

    public boolean isOk() {
        if(this.getCode().intValue() == ResultCodeEnum.SUCCESS.getCode().intValue()) {
            return true;
        }
        return false;
    }
}

同样对应的返回的枚举值，在common-util中添加com.stt.yygh.common.result.ResultCodeEnum

package com.stt.yygh.common.result;

import lombok.Getter;

//  统一返回结果状态信息类
@Getter
public enum ResultCodeEnum {

    SUCCESS(200,"成功"),
    FAIL(201, "失败"),
    PARAM_ERROR( 202, "参数不正确"),
    SERVICE_ERROR(203, "服务异常"),
    DATA_ERROR(204, "数据异常"),
    DATA_UPDATE_ERROR(205, "数据版本异常"),

    LOGIN_AUTH(208, "未登陆"),
    PERMISSION(209, "没有权限"),

    CODE_ERROR(210, "验证码错误"),
//    LOGIN_MOBLE_ERROR(211, "账号不正确"),
    LOGIN_DISABLED_ERROR(212, "改用户已被禁用"),
    REGISTER_MOBLE_ERROR(213, "手机号已被使用"),
    LOGIN_AURH(214, "需要登录"),
    LOGIN_ACL(215, "没有权限"),

    URL_ENCODE_ERROR( 216, "URL编码失败"),
    ILLEGAL_CALLBACK_REQUEST_ERROR( 217, "非法回调请求"),
    FETCH_ACCESSTOKEN_FAILD( 218, "获取accessToken失败"),
    FETCH_USERINFO_ERROR( 219, "获取用户信息失败"),
    //LOGIN_ERROR( 23005, "登录失败"),

    PAY_RUN(220, "支付中"),
    CANCEL_ORDER_FAIL(225, "取消订单失败"),
    CANCEL_ORDER_NO(225, "不能取消预约"),

    HOSCODE_EXIST(230, "医院编号已经存在"),
    NUMBER_NO(240, "可预约号不足"),
    TIME_NO(250, "当前时间不可以预约"),

    SIGN_ERROR(300, "签名错误"),
    HOSPITAL_OPEN(310, "医院未开通，暂时不能访问"),
    HOSPITAL_LOCK(320, "医院被锁定，暂时不能访问"),
    ;

    private Integer code;
    private String message;

    private ResultCodeEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
}

此时再修改controller中的返回类型

package com.stt.yygh.hosp.controller;

import com.stt.yygh.hosp.service.HospitalSetService;
import com.stt.yygh.model.hosp.HospitalSet;
import com.stt.yygh..result.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Api(tags = "医院设置管理")
@RestController
@RequestMapping("/admin/hosp/hospitalSet")
public class HospitalSetController {

    @Autowired
    private HospitalSetService hospitalSetService;

    //1 查询医院设置表所有信息
    @ApiOperation(value = "获取所有医院设置")
    @GetMapping("findAll")
    public Result findAll() {
        List<HospitalSet> re = hospitalSetService.list();
        return Result.ok(re);
    }

    //2 逻辑删除医院设置
    @ApiOperation(value = "逻辑删除医院设置")
    @DeleteMapping("{id}")
    public Result remove(@PathVariable Long id) {
        boolean re = hospitalSetService.removeById(id);
        return re ? Result.ok() : Result.fail();
    }
}

配置完成后，进行测试，访问响应的接口，查看结果

集成Swagger2

需要了解swagger2的基本使用，如果已经了解可以略过

快速访问 🚀 Swagger2

swagger通过注解表明该接口会生成文档，包括接口名、请求方法、参数、返回信息等

- name: 快速访问 🚀 Swagger2
  desc: swagger通过注解表明该接口会生成文档，包括接口名、请求方法、参数、返回信息等
  link: /note/swagger2/
  bgColor: '#DFEEE7'
  textColor: '#2A3344'

在父模块common中添加如下依赖，让common-util和service-util含有swagger2依赖

<!--swagger-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
</dependency>

在server-util模块中添加com.stt.yygh.common.config.Swagger2Config，让所有服务都含有swagger2

package com.stt.yygh.common.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Swagger2Config {
    @Bean
    public Docket webApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                //只显示api路径下的页面
                .paths(Predicates.and(PathSelectors.regex("/api/.*")))
                .build();
    }

    @Bean
    public Docket adminApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("adminApi")
                .apiInfo(adminApiInfo())
                .select()
                //只显示admin路径下的页面
                .paths(Predicates.and(PathSelectors.regex("/admin/.*")))
                .build();
    }

    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("网站-API文档")
                .description("本文档描述了网站微服务接口定义")
                .version("1.0")
                .contact(new Contact("stt", "http://www.my-notes.cn", "382143256@qq.com"))
                .build();
    }

    private ApiInfo adminApiInfo(){
        return new ApiInfoBuilder()
                .title("后台管理系统-API文档")
                .description("本文档描述了后台管理系统微服务接口定义")
                .version("1.0")
                .contact(new Contact("stt", "http://www.my-notes.cn", "382143256@qq.com"))
                .build();
    }
}

注意：在service-hosp模块中ServiceHospApplication 上需要添加 @ComponentScan 注解，用于扫描service-util工具包中的配置类，放入spring容器的管理

package com.stt.yygh.hosp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = "com.stt")
public class ServiceHospApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceHospApplication.class, args);
    }
}

带条件的分页查询实现

针对查询的传参需要进行封装，在model模块中创建 com.stt.yygh.vo.hosp.HospitalSetQueryVo

package com.stt.yygh.vo.hosp;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
public class HospitalSetQueryVo {

    @ApiModelProperty(value = "医院名称")
    private String hosname;

    @ApiModelProperty(value = "医院编号")
    private String hoscode;
}

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

• 使用@PostMapping注解，接受@RequestBody内的json数据作为查询参数

//3 条件查询带分页
@PostMapping("findPageHospSet/{current}/{limit}")
public Result findPage(@PathVariable long current,
                       @PathVariable long limit,
                       @RequestBody(required = false) HospitalSetQueryVo hospitalSetQueryVo) {
    // 构建查询条件
    QueryWrapper<HospitalSet> queryWrapper = new QueryWrapper<>();
    if (!StringUtils.isEmpty(hospitalSetQueryVo.getHosname())) {
        queryWrapper.like("hosname", hospitalSetQueryVo.getHosname());
    }
    if (!StringUtils.isEmpty(hospitalSetQueryVo.getHoscode())) {
        queryWrapper.like("hoscode", hospitalSetQueryVo.getHoscode());
    }
    // 查询分页
    Page<HospitalSet> re = hospitalSetService.page(new Page<>(current, limit), queryWrapper);
    return Result.ok(re);
}

添加医院设置实现

由于添加操作，需要使用MD5加密操作，在service-util下创建

• 当然实际工作中，应该使用第三方安全jar包中的方法

package com.stt.yygh.common.utils;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public final class MD5 {

    public static String encrypt(String strSrc) {
        try {
            char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'a', 'b', 'c', 'd', 'e', 'f' };
            byte[] bytes = strSrc.getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
            bytes = md.digest();
            int j = bytes.length;
            char[] chars = new char[j * 2];
            int k = 0;
            for (int i = 0; i < bytes.length; i++) {
                byte b = bytes[i];
                chars[k++] = hexChars[b >>> 4 & 0xf];
                chars[k++] = hexChars[b & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new RuntimeException("MD5加密出错！！+" + e);
        }
    }
}

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

//4 添加医院设置
@PostMapping("saveHospitalSet")
public Result save(@RequestBody HospitalSet hospitalSet) {
    hospitalSet.setStatus(1); // 1 启用， 0 禁用
    // 随机数签名
    Random random = new Random();
    hospitalSet.setSignKey(MD5.encrypt(System.currentTimeMillis() + "" + random.nextInt(1000)));
    boolean re = hospitalSetService.save(hospitalSet);
    if (re) {
        return Result.ok();
    }
    return Result.fail();
}

在swagger2页面进行创建测试，可以填写如下参数

{
  "apiUrl": "http://localhost:8888",
  "contactsName": "lisi",
  "contactsPhone": "13866666666",
  "hoscode": "10001",
  "hosname": "协和医院"
}

通过id查询医院设置

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

//5 根据id获取医院设置
@GetMapping("getHospSet/{id}")
public Result getById(@PathVariable Long id) {
    HospitalSet re = hospitalSetService.getById(id);
    return Result.ok(re);
}

修改医院设置

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

//6 修改医院设置
@PostMapping("updateHospitalSet")
public Result update(@RequestBody HospitalSet hospitalSet) {
    boolean re = hospitalSetService.updateById(hospitalSet);
    if (re) {
        return Result.ok();
    }
    return Result.fail();
}

批量删除医院设置

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

//7 批量删除医院设置
@DeleteMapping("batchRemove")
public Result batchRemove(@RequestBody List<Long> idList){
    hospitalSetService.removeByIds(idList);
    return Result.ok();
}

医院的锁定和解锁操作

医院在创建后，如果锁定了，则不能进行上传信息等其他业务操作

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

//8 医院设置锁定和解锁
@PutMapping("lockHospitalSet/{id}/{status}")
public Result updateStatus(@PathVariable Long id,
                           @PathVariable Integer status) {
    HospitalSet hospitalSet = hospitalSetService.getById(id);
    hospitalSet.setStatus(status);
    boolean re = hospitalSetService.updateById(hospitalSet);
    if (re) {
        return Result.ok();
    }
    return Result.fail();
}

发送签名的key

医院信息配置后，可以通过短信的形式发送医院编号与签名key给联系人

联系人拿到该信息就可以参考【附录：在线预约挂号API接口文档】对接接口了

在serivce-hosp 模块中的com.stt.yygh.hosp.controller.HospitalSetController添加如下方法

• 关于发送接口，后期添加

//9 发送签名秘钥
@PutMapping("sendKey/{id}")
public Result lockHospitalSet(@PathVariable Long id) {
    HospitalSet hospitalSet = hospitalSetService.getById(id);
    String signKey = hospitalSet.getSignKey();
    String hosCode = hospitalSet.getHoscode();
    // todo 发送短信
    return Result.ok();
}