Commit dc231664 by 邹磊浩

后台接口更新

parent bd0f68cf
package com.pz.web.controller.system;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.pz.common.annotation.RepeatSubmit;
import com.pz.common.annotation.Log;
import com.pz.common.core.controller.BaseController;
import com.pz.common.core.domain.PageQuery;
import com.pz.common.core.domain.R;
import com.pz.common.core.validate.AddGroup;
import com.pz.common.core.validate.EditGroup;
import com.pz.common.enums.BusinessType;
import com.pz.common.utils.poi.ExcelUtil;
import com.pz.system.domain.vo.DepartmentVo;
import com.pz.system.domain.bo.DepartmentBo;
import com.pz.system.service.IDepartmentService;
import com.pz.common.core.page.TableDataInfo;
/**
* 科室
*
* @author ruoyi
* @date 2023-09-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/system/department")
public class DepartmentController extends BaseController {
private final IDepartmentService iDepartmentService;
/**
* 查询科室列表
*/
@SaCheckPermission("system:department:list")
@GetMapping("/list")
public List<DepartmentVo> list(DepartmentBo bo) {
return iDepartmentService.queryPageList(bo);
}
/**
* 导出科室列表
*/
@SaCheckPermission("system:department:export")
@Log(title = "科室", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DepartmentBo bo, HttpServletResponse response) {
List<DepartmentVo> list = iDepartmentService.queryList(bo);
ExcelUtil.exportExcel(list, "科室", DepartmentVo.class, response);
}
/**
* 获取科室详细信息
*
* @param id 主键
*/
@SaCheckPermission("system:department:query")
@GetMapping("/{id}")
public R<DepartmentVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Integer id) {
return R.ok(iDepartmentService.queryById(id));
}
/**
* 新增科室
*/
@SaCheckPermission("system:department:add")
@Log(title = "科室", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DepartmentBo bo) {
return toAjax(iDepartmentService.insertByBo(bo));
}
/**
* 修改科室
*/
@SaCheckPermission("system:department:edit")
@Log(title = "科室", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DepartmentBo bo) {
return toAjax(iDepartmentService.updateByBo(bo));
}
/**
* 删除科室
*
* @param ids 主键串
*/
@SaCheckPermission("system:department:remove")
@Log(title = "科室", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Integer[] ids) {
return toAjax(iDepartmentService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
package com.pz.web.controller.system;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.pz.common.annotation.RepeatSubmit;
import com.pz.common.annotation.Log;
import com.pz.common.core.controller.BaseController;
import com.pz.common.core.domain.PageQuery;
import com.pz.common.core.domain.R;
import com.pz.common.core.validate.AddGroup;
import com.pz.common.core.validate.EditGroup;
import com.pz.common.enums.BusinessType;
import com.pz.common.utils.poi.ExcelUtil;
import com.pz.system.domain.vo.DoctorVo;
import com.pz.system.domain.bo.DoctorBo;
import com.pz.system.service.IDoctorService;
import com.pz.common.core.page.TableDataInfo;
/**
* 医生
*
* @author ruoyi
* @date 2023-09-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/system/doctor")
public class DoctorController extends BaseController {
private final IDoctorService iDoctorService;
/**
* 查询医生列表
*/
@SaCheckPermission("system:doctor:list")
@GetMapping("/list")
public TableDataInfo<DoctorVo> list(DoctorBo bo, PageQuery pageQuery) {
return iDoctorService.queryPageList(bo, pageQuery);
}
/**
* 导出医生列表
*/
@SaCheckPermission("system:doctor:export")
@Log(title = "医生", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DoctorBo bo, HttpServletResponse response) {
List<DoctorVo> list = iDoctorService.queryList(bo);
ExcelUtil.exportExcel(list, "医生", DoctorVo.class, response);
}
/**
* 获取医生详细信息
*
* @param id 主键
*/
@SaCheckPermission("system:doctor:query")
@GetMapping("/{id}")
public R<DoctorVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Integer id) {
return R.ok(iDoctorService.queryById(id));
}
/**
* 新增医生
*/
@SaCheckPermission("system:doctor:add")
@Log(title = "医生", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DoctorBo bo) {
return toAjax(iDoctorService.insertByBo(bo));
}
/**
* 修改医生
*/
@SaCheckPermission("system:doctor:edit")
@Log(title = "医生", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DoctorBo bo) {
return toAjax(iDoctorService.updateByBo(bo));
}
/**
* 删除医生
*
* @param ids 主键串
*/
@SaCheckPermission("system:doctor:remove")
@Log(title = "医生", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Integer[] ids) {
return toAjax(iDoctorService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
package com.pz.web.controller.system;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.pz.common.annotation.RepeatSubmit;
import com.pz.common.annotation.Log;
import com.pz.common.core.controller.BaseController;
import com.pz.common.core.domain.PageQuery;
import com.pz.common.core.domain.R;
import com.pz.common.core.validate.AddGroup;
import com.pz.common.core.validate.EditGroup;
import com.pz.common.enums.BusinessType;
import com.pz.common.utils.poi.ExcelUtil;
import com.pz.system.domain.vo.HospitalVo;
import com.pz.system.domain.bo.HospitalBo;
import com.pz.system.service.IHospitalService;
import com.pz.common.core.page.TableDataInfo;
/**
* 医院
*
* @author ruoyi
* @date 2023-09-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/system/hospital")
public class HospitalController extends BaseController {
private final IHospitalService iHospitalService;
/**
* 查询医院列表
*/
@SaCheckPermission("system:hospital:list")
@GetMapping("/list")
public TableDataInfo<HospitalVo> list(HospitalBo bo, PageQuery pageQuery) {
return iHospitalService.queryPageList(bo, pageQuery);
}
/**
* 导出医院列表
*/
@SaCheckPermission("system:hospital:export")
@Log(title = "医院", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HospitalBo bo, HttpServletResponse response) {
List<HospitalVo> list = iHospitalService.queryList(bo);
ExcelUtil.exportExcel(list, "医院", HospitalVo.class, response);
}
/**
* 获取医院详细信息
*
* @param id 主键
*/
@SaCheckPermission("system:hospital:query")
@GetMapping("/{id}")
public R<HospitalVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Integer id) {
return R.ok(iHospitalService.queryById(id));
}
/**
* 新增医院
*/
@SaCheckPermission("system:hospital:add")
@Log(title = "医院", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody HospitalBo bo) {
return toAjax(iHospitalService.insertByBo(bo));
}
/**
* 修改医院
*/
@SaCheckPermission("system:hospital:edit")
@Log(title = "医院", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody HospitalBo bo) {
return toAjax(iHospitalService.updateByBo(bo));
}
/**
* 删除医院
*
* @param ids 主键串
*/
@SaCheckPermission("system:hospital:remove")
@Log(title = "医院", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Integer[] ids) {
return toAjax(iHospitalService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
package com.pz.web.controller.system;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.pz.common.annotation.RepeatSubmit;
import com.pz.common.annotation.Log;
import com.pz.common.core.controller.BaseController;
import com.pz.common.core.domain.PageQuery;
import com.pz.common.core.domain.R;
import com.pz.common.core.validate.AddGroup;
import com.pz.common.core.validate.EditGroup;
import com.pz.common.enums.BusinessType;
import com.pz.common.utils.poi.ExcelUtil;
import com.pz.system.domain.vo.InformationVo;
import com.pz.system.domain.bo.InformationBo;
import com.pz.system.service.IInformationService;
import com.pz.common.core.page.TableDataInfo;
/**
* 新闻资讯
*
* @author ruoyi
* @date 2023-09-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/system/information")
public class InformationController extends BaseController {
private final IInformationService iInformationService;
/**
* 查询新闻资讯列表
*/
@SaCheckPermission("system:information:list")
@GetMapping("/list")
public TableDataInfo<InformationVo> list(InformationBo bo, PageQuery pageQuery) {
return iInformationService.queryPageList(bo, pageQuery);
}
/**
* 导出新闻资讯列表
*/
@SaCheckPermission("system:information:export")
@Log(title = "新闻资讯", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(InformationBo bo, HttpServletResponse response) {
List<InformationVo> list = iInformationService.queryList(bo);
ExcelUtil.exportExcel(list, "新闻资讯", InformationVo.class, response);
}
/**
* 获取新闻资讯详细信息
*
* @param id 主键
*/
@SaCheckPermission("system:information:query")
@GetMapping("/{id}")
public R<InformationVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Integer id) {
return R.ok(iInformationService.queryById(id));
}
/**
* 新增新闻资讯
*/
@SaCheckPermission("system:information:add")
@Log(title = "新闻资讯", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody InformationBo bo) {
return toAjax(iInformationService.insertByBo(bo));
}
/**
* 修改新闻资讯
*/
@SaCheckPermission("system:information:edit")
@Log(title = "新闻资讯", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody InformationBo bo) {
return toAjax(iInformationService.updateByBo(bo));
}
/**
* 删除新闻资讯
*
* @param ids 主键串
*/
@SaCheckPermission("system:information:remove")
@Log(title = "新闻资讯", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Integer[] ids) {
return toAjax(iInformationService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}
package com.pz.common.enums;
/**
* 医院等级枚举
*/
public enum HospitalLevel {
NOT_SET(0, "未设置"),
LEVEL_1_A(1, "一级甲等"),
LEVEL_1_B(2, "一级乙等"),
LEVEL_1_C(3, "一级丙等"),
LEVEL_2_A(4, "二级甲等"),
LEVEL_2_B(5, "二级乙等"),
LEVEL_2_C(6, "二级丙等"),
LEVEL_3_SPECIAL(7, "三级特等"),
LEVEL_3_A(8, "三级甲等"),
LEVEL_3_C(9, "三级丙等"),
LEVEL_3_B(10, "三级乙等");
private final Integer code;
private final String name;
HospitalLevel(Integer code, String name) {
this.code = code;
this.name = name;
}
public Integer getCode() {
return code;
}
public String getName() {
return name;
}
public static String getLevelName(Integer code) {
if (null == code) {
return null;
}
for (HospitalLevel level : values()) {
if (level.getCode() == code) {
return level.getName();
}
}
return null;
}
}
package com.pz.common.enums;
import com.pz.common.utils.StringUtils;
/**
* 医院类型枚举
*/
public enum HospitalType {
NOT_SET(0, "未设置"),
GENERAL_HOSPITAL(1, "综合医院"),
TRADITIONAL_CHINESE_MEDICINE_HOSPITAL(2, "中医医院"),
INTEGRATIVE_MEDICINE_HOSPITAL(3, "中西医结合医院"),
NATIONAL_MEDICINE_HOSPITAL(4, "民族医医院"),
SPECIALIZED_HOSPITAL(5, "专科医院"),
REHABILITATION_HOSPITAL(6, "康复医院"),
MATERNAL_CHILD_HEALTH_HOSPITAL(7, "妇幼保健院"),
COMMUNITY_HEALTH_SERVICE_CENTER(8, "社区卫生服务中心"),
COMMUNITY_HEALTH_SERVICE_STATION(9, "社区卫生服务站"),
CENTRAL_HEALTH_CLINIC(10, "中心卫生院"),
TOWN_HEALTH_CLINIC(11, "乡(镇)卫生院"),
STREET_HEALTH_CLINIC(12, "街道卫生院"),
SANATORIUM(13, "疗养院"),
GENERAL_OUTPATIENT_DEPARTMENT(14, "综合门诊部"),
SPECIALIZED_OUTPATIENT_DEPARTMENT(15, "专科门诊部"),
TRADITIONAL_CHINESE_MEDICINE_OUTPATIENT_DEPARTMENT(16, "中医门诊部"),
INTEGRATIVE_MEDICINE_OUTPATIENT_DEPARTMENT(17, "中西医结合门诊部"),
NATIONAL_MEDICINE_OUTPATIENT_DEPARTMENT(18, "民族医门诊部"),
CLINIC(19, "诊所"),
TRADITIONAL_CHINESE_MEDICINE_CLINIC(20, "中医诊所"),
NATIONAL_MEDICINE_CLINIC(21, "民族医诊所"),
HEALTH_CENTER(22, "卫生所"),
MEDICAL_OFFICE(23, "医务室"),
HEALTH_CARE_CENTER(24, "卫生保健所"),
HEALTH_STATION(25, "卫生站"),
VILLAGE_HEALTH_CENTER(26, "村卫生室(所)"),
EMERGENCY_CENTER(27, "急救中心"),
EMERGENCY_STATION(28, "急救站"),
CLINICAL_LABORATORY_CENTER(29, "临床检验中心"),
SPECIALIZED_DISEASE_PREVENTION_HOSPITAL(30, "专科疾病防治院"),
SPECIALIZED_DISEASE_PREVENTION_CENTER(31, "专科疾病防治所"),
SPECIALIZED_DISEASE_PREVENTION_STATION(32, "专科疾病防治站"),
NURSING_HOME(33, "护理院"),
NURSING_STATION(34, "护理站"),
OTHER_HEALTHCARE_INSTITUTION(35, "其他诊疗机构");
private final Integer code;
private final String name;
HospitalType(Integer code, String name) {
this.code = code;
this.name = name;
}
public Integer getCode() {
return code;
}
public String getName() {
return name;
}
public static String getTypeName(Integer code) {
if (null == code) {
return null;
}
for (HospitalType type : values()) {
if (type.getCode() == code) {
return type.getName();
}
}
return null;
}
}
package com.pz.system.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.pz.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 科室对象 department
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("department")
public class Department extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Integer id;
/**
* 上级科室
*/
private Integer parentId;
/**
* 排序
*/
private Integer sortord;
/**
* 名称
*/
private String title;
/**
* 删除标志(0代表存在 2代表删除)
*/
@TableLogic
private String delFlag;
}
package com.pz.system.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.pz.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 医生对象 doctor
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("doctor")
public class Doctor extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Integer id;
/**
* 姓名
*/
private String name;
/**
* 所属医院
*/
private Integer hid;
/**
* 所属科室
*/
private Integer did;
/**
*
*/
private String rank;
/**
*
*/
private String degree;
/**
* 删除标志(0代表存在 2代表删除)
*/
@TableLogic
private String delFlag;
}
package com.pz.system.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.pz.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 新闻资讯对象 information
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("information")
public class Information extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Integer id;
/**
* 城市
*/
private Long cityId;
/**
* 标题
*/
private String title;
/**
* 封面
*/
private String cover;
/**
* 内容
*/
private String info;
}
package com.pz.system.domain.bo;
import com.pz.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
/**
* 科室业务对象 department
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DepartmentBo extends BaseEntity {
/**
*
*/
private Integer id;
/**
* 上级科室
*/
private Integer parentId;
/**
* 排序
*/
private Integer sortord;
/**
* 名称
*/
private String title;
}
package com.pz.system.domain.bo;
import com.pz.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
/**
* 医生业务对象 doctor
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DoctorBo extends BaseEntity {
/**
*
*/
private Integer id;
/**
* 姓名
*/
private String name;
/**
* 所属医院
*/
private Integer hid;
/**
* 所属科室
*/
private Integer did;
/**
*
*/
private String rank;
/**
*
*/
private String degree;
}
package com.pz.system.domain.bo;
import com.pz.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
/**
* 新闻资讯业务对象 information
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class InformationBo extends BaseEntity {
/**
*
*/
private Integer id;
/**
* 城市
*/
private Long cityId;
/**
* 标题
*/
private String title;
/**
* 封面
*/
private String cover;
/**
* 内容
*/
private String info;
}
package com.pz.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.pz.common.annotation.ExcelDictFormat;
import com.pz.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.List;
/**
* 科室视图对象 department
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@ExcelIgnoreUnannotated
public class DepartmentVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Integer id;
/**
* 上级科室
*/
@ExcelProperty(value = "上级科室")
private Integer parentId;
/**
* 排序
*/
@ExcelProperty(value = "排序")
private Integer sortord;
/**
* 名称
*/
@ExcelProperty(value = "名称")
private String title;
private List<DepartmentVo> children;
}
package com.pz.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.pz.common.annotation.ExcelDictFormat;
import com.pz.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 医生视图对象 doctor
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@ExcelIgnoreUnannotated
public class DoctorVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Integer id;
/**
* 姓名
*/
@ExcelProperty(value = "姓名")
private String name;
/**
* 所属医院
*/
@ExcelProperty(value = "所属医院")
private Integer hid;
/**
* 所属医院名称
*/
private String hName;
/**
* 所属科室名称
*/
private String dName;
/**
* 所属科室
*/
@ExcelProperty(value = "所属科室")
private Integer did;
/**
*
*/
@ExcelProperty(value = "")
private String rank;
/**
*
*/
@ExcelProperty(value = "")
private String degree;
}
package com.pz.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.pz.common.annotation.ExcelDictFormat;
import com.pz.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 新闻资讯视图对象 information
*
* @author ruoyi
* @date 2023-09-07
*/
@Data
@ExcelIgnoreUnannotated
public class InformationVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Integer id;
/**
* 城市
*/
@ExcelProperty(value = "城市")
private Long cityId;
/**
* 标题
*/
@ExcelProperty(value = "标题")
private String title;
/**
* 封面
*/
@ExcelProperty(value = "封面")
private String cover;
/**
* 内容
*/
@ExcelProperty(value = "内容")
private String info;
/**
* 城市名称
*/
private String cityName;
}
package com.pz.system.mapper;
import com.pz.system.domain.Department;
import com.pz.system.domain.vo.DepartmentVo;
import com.pz.common.core.mapper.BaseMapperPlus;
/**
* 科室Mapper接口
*
* @author ruoyi
* @date 2023-09-07
*/
public interface DepartmentMapper extends BaseMapperPlus<DepartmentMapper, Department, DepartmentVo> {
}
package com.pz.system.mapper;
import com.pz.system.domain.Doctor;
import com.pz.system.domain.vo.DoctorVo;
import com.pz.common.core.mapper.BaseMapperPlus;
/**
* 医生Mapper接口
*
* @author ruoyi
* @date 2023-09-07
*/
public interface DoctorMapper extends BaseMapperPlus<DoctorMapper, Doctor, DoctorVo> {
}
package com.pz.system.mapper;
import com.pz.system.domain.Information;
import com.pz.system.domain.vo.InformationVo;
import com.pz.common.core.mapper.BaseMapperPlus;
/**
* 新闻资讯Mapper接口
*
* @author ruoyi
* @date 2023-09-07
*/
public interface InformationMapper extends BaseMapperPlus<InformationMapper, Information, InformationVo> {
}
package com.pz.system.service;
import com.pz.system.domain.Department;
import com.pz.system.domain.vo.DepartmentVo;
import com.pz.system.domain.bo.DepartmentBo;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 科室Service接口
*
* @author ruoyi
* @date 2023-09-07
*/
public interface IDepartmentService {
/**
* 查询科室
*/
DepartmentVo queryById(Integer id);
/**
* 查询科室列表
*/
List<DepartmentVo> queryPageList(DepartmentBo bo);
/**
* 查询科室列表
*/
List<DepartmentVo> queryList(DepartmentBo bo);
/**
* 新增科室
*/
Boolean insertByBo(DepartmentBo bo);
/**
* 修改科室
*/
Boolean updateByBo(DepartmentBo bo);
/**
* 校验并批量删除科室信息
*/
Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid);
}
package com.pz.system.service;
import com.pz.system.domain.Doctor;
import com.pz.system.domain.vo.DoctorVo;
import com.pz.system.domain.bo.DoctorBo;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 医生Service接口
*
* @author ruoyi
* @date 2023-09-07
*/
public interface IDoctorService {
/**
* 查询医生
*/
DoctorVo queryById(Integer id);
/**
* 查询医生列表
*/
TableDataInfo<DoctorVo> queryPageList(DoctorBo bo, PageQuery pageQuery);
/**
* 查询医生列表
*/
List<DoctorVo> queryList(DoctorBo bo);
/**
* 新增医生
*/
Boolean insertByBo(DoctorBo bo);
/**
* 修改医生
*/
Boolean updateByBo(DoctorBo bo);
/**
* 校验并批量删除医生信息
*/
Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid);
}
package com.pz.system.service;
import com.pz.system.domain.Information;
import com.pz.system.domain.vo.InformationVo;
import com.pz.system.domain.bo.InformationBo;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 新闻资讯Service接口
*
* @author ruoyi
* @date 2023-09-07
*/
public interface IInformationService {
/**
* 查询新闻资讯
*/
InformationVo queryById(Integer id);
/**
* 查询新闻资讯列表
*/
TableDataInfo<InformationVo> queryPageList(InformationBo bo, PageQuery pageQuery);
/**
* 查询新闻资讯列表
*/
List<InformationVo> queryList(InformationBo bo);
/**
* 新增新闻资讯
*/
Boolean insertByBo(InformationBo bo);
/**
* 修改新闻资讯
*/
Boolean updateByBo(InformationBo bo);
/**
* 校验并批量删除新闻资讯信息
*/
Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid);
}
package com.pz.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.pz.system.domain.bo.DepartmentBo;
import com.pz.system.domain.vo.DepartmentVo;
import com.pz.system.domain.Department;
import com.pz.system.mapper.DepartmentMapper;
import com.pz.system.service.IDepartmentService;
import java.util.*;
/**
* 科室Service业务层处理
*
* @author ruoyi
* @date 2023-09-07
*/
@RequiredArgsConstructor
@Service
public class DepartmentServiceImpl implements IDepartmentService {
private final DepartmentMapper baseMapper;
/**
* 查询科室
*/
@Override
public DepartmentVo queryById(Integer id) {
return baseMapper.selectVoById(id);
}
/**
* 查询科室列表
*/
@Override
public List<DepartmentVo> queryPageList(DepartmentBo bo) {
LambdaQueryWrapper<Department> lqw = buildQueryWrapper(bo);
List<DepartmentVo> result = baseMapper.selectVoList(lqw);
if (CollectionUtils.isNotEmpty(result)) {
//查询所有菜单
List<DepartmentVo> allMenu = result;
//根节点集合
List<DepartmentVo> rootMenu = new ArrayList<>();
for (DepartmentVo entity : allMenu) {
if (entity.getParentId() == 0) { //父节点是0的,为根节点。
rootMenu.add(entity);
}
}
//为根菜单设置子菜单,getClild是递归调用的
for (DepartmentVo entity : rootMenu) {
/* 获取根节点下的所有子节点 使用getChild方法*/
List<DepartmentVo> childList = getChild(entity.getId().toString(), allMenu);
entity.setChildren(childList);//给根节点设置子节点
}
return rootMenu;
}
return result;
}
/**
* 获取子节点
*
* @param id 父节点id
* @param allMenu 所有菜单列表
* @return 每个根节点下,所有子菜单列表
*/
public List<DepartmentVo> getChild(String id, List<DepartmentVo> allMenu) {
// 子菜单
List<DepartmentVo> childList = new ArrayList<>();
for (DepartmentVo entity : allMenu) {
if (entity.getParentId().toString().equals(id)) {
childList.add(entity);
}
}
// 对子菜单进行排序
Collections.sort(childList, new Comparator<DepartmentVo>() {
@Override
public int compare(DepartmentVo o1, DepartmentVo o2) {
// 根据需要进行排序比较,可以根据实际情况修改
return Integer.compare(o1.getSortord(), o2.getSortord());
}
});
// 递归处理子菜单的子菜单
for (DepartmentVo entity : childList) {
entity.setChildren(getChild(entity.getId().toString(), allMenu));
}
return childList;
}
/**
* 查询科室列表
*/
@Override
public List<DepartmentVo> queryList(DepartmentBo bo) {
LambdaQueryWrapper<Department> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<Department> buildQueryWrapper(DepartmentBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<Department> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getParentId() != null, Department::getParentId, bo.getParentId());
lqw.eq(StringUtils.isNotBlank(bo.getTitle()), Department::getTitle, bo.getTitle());
return lqw;
}
/**
* 新增科室
*/
@Override
public Boolean insertByBo(DepartmentBo bo) {
Department add = BeanUtil.toBean(bo, Department.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改科室
*/
@Override
public Boolean updateByBo(DepartmentBo bo) {
Department update = BeanUtil.toBean(bo, Department.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(Department entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除科室
*/
@Override
public Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
package com.pz.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.pz.system.mapper.DepartmentMapper;
import com.pz.system.mapper.HospitalMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.pz.system.domain.bo.DoctorBo;
import com.pz.system.domain.vo.DoctorVo;
import com.pz.system.domain.Doctor;
import com.pz.system.mapper.DoctorMapper;
import com.pz.system.service.IDoctorService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import java.util.Optional;
/**
* 医生Service业务层处理
*
* @author ruoyi
* @date 2023-09-07
*/
@RequiredArgsConstructor
@Service
public class DoctorServiceImpl implements IDoctorService {
private final DoctorMapper baseMapper;
private final HospitalMapper hospitalMapper;
private final DepartmentMapper departmentMapper;
/**
* 查询医生
*/
@Override
public DoctorVo queryById(Integer id) {
return baseMapper.selectVoById(id);
}
/**
* 查询医生列表
*/
@Override
public TableDataInfo<DoctorVo> queryPageList(DoctorBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<Doctor> lqw = buildQueryWrapper(bo);
Page<DoctorVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
Optional.ofNullable(result.getRecords()).ifPresent(
doctorVos -> {
doctorVos.forEach(doctorVo -> {
//获取所属医院名称
Optional.ofNullable(hospitalMapper.selectVoById(doctorVo.getHid())).ifPresent(
hospitalVo -> {
doctorVo.setHName(hospitalVo.getName());
}
);
//获取所属科室名称
Optional.ofNullable(departmentMapper.selectVoById(doctorVo.getDid())).ifPresent(
departmentVo -> {
doctorVo.setDName(departmentVo.getTitle());
}
);
});
}
);
return TableDataInfo.build(result);
}
/**
* 查询医生列表
*/
@Override
public List<DoctorVo> queryList(DoctorBo bo) {
LambdaQueryWrapper<Doctor> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<Doctor> buildQueryWrapper(DoctorBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<Doctor> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getName()), Doctor::getName, bo.getName());
lqw.eq(bo.getHid() != null, Doctor::getHid, bo.getHid());
lqw.eq(bo.getDid() != null, Doctor::getDid, bo.getDid());
lqw.eq(StringUtils.isNotBlank(bo.getRank()), Doctor::getRank, bo.getRank());
lqw.eq(StringUtils.isNotBlank(bo.getDegree()), Doctor::getDegree, bo.getDegree());
return lqw;
}
/**
* 新增医生
*/
@Override
public Boolean insertByBo(DoctorBo bo) {
Doctor add = BeanUtil.toBean(bo, Doctor.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改医生
*/
@Override
public Boolean updateByBo(DoctorBo bo) {
Doctor update = BeanUtil.toBean(bo, Doctor.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(Doctor entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除医生
*/
@Override
public Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
package com.pz.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.pz.common.enums.HospitalLevel;
import com.pz.common.enums.HospitalType;
import com.pz.common.utils.JsonUtils;
import com.pz.system.domain.Department;
import com.pz.system.mapper.DepartmentMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.pz.system.domain.bo.HospitalBo;
import com.pz.system.domain.vo.HospitalVo;
import com.pz.system.domain.Hospital;
import com.pz.system.mapper.HospitalMapper;
import com.pz.system.service.IHospitalService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import java.util.Optional;
/**
* 医院Service业务层处理
*
* @author ruoyi
* @date 2023-09-07
*/
@RequiredArgsConstructor
@Service
public class HospitalServiceImpl implements IHospitalService {
private final HospitalMapper baseMapper;
private final DepartmentMapper departmentMapper;
/**
* 查询医院
*/
@Override
public HospitalVo queryById(Integer id) {
return baseMapper.selectVoById(id);
}
/**
* 查询医院列表
*/
@Override
public TableDataInfo<HospitalVo> queryPageList(HospitalBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<Hospital> lqw = buildQueryWrapper(bo);
Page<HospitalVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
Optional.ofNullable(result.getRecords()).ifPresent(hospitalVos -> {
hospitalVos.forEach(hospitalVo -> {
//获取医院类型名称
hospitalVo.setCategoryName(HospitalType.getTypeName(hospitalVo.getCategory()));
//获取医院等级名称
hospitalVo.setLevelName(HospitalLevel.getLevelName(hospitalVo.getLevel()));
//获取医院科室
if (StringUtils.isNotBlank(hospitalVo.getDepartments())) {
//关联科室编号
List<Integer> ids = JsonUtils.parseArray(hospitalVo.getDepartments(), Integer.class);
Optional.ofNullable(departmentMapper.selectVoList(Wrappers.<Department>lambdaQuery().in(Department::getId, ids)))
.ifPresent(departmentVos -> {
hospitalVo.setDepartmentVoList(departmentVos);
});
}
});
});
return TableDataInfo.build(result);
}
/**
* 查询医院列表
*/
@Override
public List<HospitalVo> queryList(HospitalBo bo) {
LambdaQueryWrapper<Hospital> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<Hospital> buildQueryWrapper(HospitalBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<Hospital> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getCityId() != null, Hospital::getCityId, bo.getCityId());
lqw.like(StringUtils.isNotBlank(bo.getName()), Hospital::getName, bo.getName());
lqw.eq(StringUtils.isNotBlank(bo.getLogo()), Hospital::getLogo, bo.getLogo());
lqw.eq(bo.getLevel() != null, Hospital::getLevel, bo.getLevel());
lqw.eq(StringUtils.isNotBlank(bo.getLng()), Hospital::getLng, bo.getLng());
lqw.eq(StringUtils.isNotBlank(bo.getLat()), Hospital::getLat, bo.getLat());
lqw.eq(bo.getCategory() != null, Hospital::getCategory, bo.getCategory());
lqw.eq(StringUtils.isNotBlank(bo.getIntroduce()), Hospital::getIntroduce, bo.getIntroduce());
lqw.eq(StringUtils.isNotBlank(bo.getDepartments()), Hospital::getDepartments, bo.getDepartments());
lqw.eq(bo.getStatus() != null, Hospital::getStatus, bo.getStatus());
return lqw;
}
/**
* 新增医院
*/
@Override
public Boolean insertByBo(HospitalBo bo) {
Hospital add = BeanUtil.toBean(bo, Hospital.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改医院
*/
@Override
public Boolean updateByBo(HospitalBo bo) {
Hospital update = BeanUtil.toBean(bo, Hospital.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(Hospital entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除医院
*/
@Override
public Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
package com.pz.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.pz.system.domain.City;
import com.pz.system.mapper.CityMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.pz.system.domain.bo.InformationBo;
import com.pz.system.domain.vo.InformationVo;
import com.pz.system.domain.Information;
import com.pz.system.mapper.InformationMapper;
import com.pz.system.service.IInformationService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import java.util.Optional;
/**
* 新闻资讯Service业务层处理
*
* @author ruoyi
* @date 2023-09-07
*/
@RequiredArgsConstructor
@Service
public class InformationServiceImpl implements IInformationService {
private final InformationMapper baseMapper;
private final CityMapper cityMapper;
/**
* 查询新闻资讯
*/
@Override
public InformationVo queryById(Integer id) {
return baseMapper.selectVoById(id);
}
/**
* 查询新闻资讯列表
*/
@Override
public TableDataInfo<InformationVo> queryPageList(InformationBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<Information> lqw = buildQueryWrapper(bo);
Page<InformationVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
Optional.ofNullable(result.getRecords()).ifPresent(informationVos -> {
informationVos.forEach(informationVo -> {
Optional.ofNullable(cityMapper.selectVoById(informationVo.getCityId()))
.ifPresent(cityVo -> {
informationVo.setCityName(cityVo.getName());
});
});
});
return TableDataInfo.build(result);
}
/**
* 查询新闻资讯列表
*/
@Override
public List<InformationVo> queryList(InformationBo bo) {
LambdaQueryWrapper<Information> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<Information> buildQueryWrapper(InformationBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<Information> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getCityId() != null, Information::getCityId, bo.getCityId());
lqw.eq(StringUtils.isNotBlank(bo.getTitle()), Information::getTitle, bo.getTitle());
lqw.eq(StringUtils.isNotBlank(bo.getCover()), Information::getCover, bo.getCover());
lqw.eq(StringUtils.isNotBlank(bo.getInfo()), Information::getInfo, bo.getInfo());
return lqw;
}
/**
* 新增新闻资讯
*/
@Override
public Boolean insertByBo(InformationBo bo) {
Information add = BeanUtil.toBean(bo, Information.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改新闻资讯
*/
@Override
public Boolean updateByBo(InformationBo bo) {
Information update = BeanUtil.toBean(bo, Information.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(Information entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除新闻资讯
*/
@Override
public Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
package com.pz.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.pz.system.domain.bo.ServicesBo;
import com.pz.system.domain.vo.ServicesVo;
import com.pz.system.domain.Services;
import com.pz.system.mapper.ServicesMapper;
import com.pz.system.service.IServicesService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 服务Service业务层处理
*
* @author ruoyi
* @date 2023-09-07
*/
@RequiredArgsConstructor
@Service
public class ServicesServiceImpl implements IServicesService {
private final ServicesMapper baseMapper;
/**
* 查询服务
*/
@Override
public ServicesVo queryById(Integer id){
return baseMapper.selectVoById(id);
}
/**
* 查询服务列表
*/
@Override
public TableDataInfo<ServicesVo> queryPageList(ServicesBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<Services> lqw = buildQueryWrapper(bo);
Page<ServicesVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询服务列表
*/
@Override
public List<ServicesVo> queryList(ServicesBo bo) {
LambdaQueryWrapper<Services> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<Services> buildQueryWrapper(ServicesBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<Services> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getBid() != null, Services::getBid, bo.getBid());
lqw.like(StringUtils.isNotBlank(bo.getName()), Services::getName, bo.getName());
lqw.eq(StringUtils.isNotBlank(bo.getCover()), Services::getCover, bo.getCover());
lqw.eq(StringUtils.isNotBlank(bo.getPrice()), Services::getPrice, bo.getPrice());
lqw.eq(bo.getFenmo() != null, Services::getFenmo, bo.getFenmo());
lqw.eq(bo.getDuration() != null, Services::getDuration, bo.getDuration());
lqw.eq(bo.getOvertime() != null, Services::getOvertime, bo.getOvertime());
lqw.eq(bo.getStartTime() != null, Services::getStartTime, bo.getStartTime());
lqw.eq(bo.getEndTime() != null, Services::getEndTime, bo.getEndTime());
lqw.eq(StringUtils.isNotBlank(bo.getInfo()), Services::getInfo, bo.getInfo());
return lqw;
}
/**
* 新增服务
*/
@Override
public Boolean insertByBo(ServicesBo bo) {
Services add = BeanUtil.toBean(bo, Services.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改服务
*/
@Override
public Boolean updateByBo(ServicesBo bo) {
Services update = BeanUtil.toBean(bo, Services.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(Services entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除服务
*/
@Override
public Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment