235 lines
9.5 KiB
Java
235 lines
9.5 KiB
Java
package com.peanut.modules.book.controller;
|
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
|
import com.peanut.common.utils.R;
|
|
import com.peanut.modules.book.entity.*;
|
|
import com.peanut.modules.book.entity.SysDictDataEntity;
|
|
import com.peanut.modules.book.service.*;
|
|
import com.peanut.modules.sys.service.SysDictDataService;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.apache.commons.lang.StringUtils;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.web.bind.annotation.RequestBody;
|
|
import org.springframework.web.bind.annotation.RequestMapping;
|
|
import org.springframework.web.bind.annotation.RestController;
|
|
|
|
import java.awt.print.Book;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
@Slf4j
|
|
@RestController
|
|
@RequestMapping("book/medicaldes")
|
|
public class MedicaldesController {
|
|
|
|
@Autowired
|
|
private MedicaldesLightService lightService;
|
|
@Autowired
|
|
private MedicaldesBookService medicaldesBookService;
|
|
@Autowired
|
|
private MedicaldesInheritService inheritService;
|
|
@Autowired
|
|
private MedicaldesInheritRelationService relationService;
|
|
@Autowired
|
|
private SysDictDataService sysDictDataService;
|
|
@Autowired
|
|
private BookService bookService;
|
|
|
|
|
|
/**
|
|
* 类型列表
|
|
*/
|
|
@RequestMapping(path = "/typeList")
|
|
public R typeList(String label) {
|
|
LambdaQueryWrapper<SysDictDataEntity> wrapper = new LambdaQueryWrapper();
|
|
wrapper.eq(SysDictDataEntity::getDictLabel,label);
|
|
return R.ok().put("result",sysDictDataService.list(wrapper));
|
|
}
|
|
|
|
/**
|
|
* 专著出版关系列表
|
|
*/
|
|
@RequestMapping(path = "/bookRelationListByType")
|
|
public R bookRelationListByType(@RequestBody Map map) {
|
|
MPJLambdaWrapper<MedicaldesBook> wrapper = new MPJLambdaWrapper();
|
|
wrapper.selectAll(MedicaldesBook.class);
|
|
wrapper.leftJoin(BookEntity.class,BookEntity::getId,MedicaldesBook::getBookId);
|
|
if (map.containsKey("dictType")&&StringUtils.isNotEmpty(map.get("dictType").toString())){
|
|
wrapper.eq(MedicaldesBook::getTypeId,map.get("dictType"));
|
|
}
|
|
if (map.containsKey("bookName")&&StringUtils.isNotEmpty(map.get("bookName").toString())){
|
|
wrapper.like(BookEntity::getName,map.get("bookName"));
|
|
}
|
|
Page<MedicaldesBook> res = medicaldesBookService.page(new Page<MedicaldesBook>(
|
|
Long.parseLong(map.get("current").toString()), Long.parseLong(map.get("limit").toString())), wrapper);
|
|
List<MedicaldesBook> list = res.getRecords();
|
|
if (list.size() > 0) {
|
|
for (MedicaldesBook b : list) {
|
|
b.setBook(bookService.getById(b.getBookId()));
|
|
}
|
|
res.setRecords(list);
|
|
}
|
|
return R.ok().put("result", res);
|
|
}
|
|
|
|
/**
|
|
* 专著出版列表
|
|
*/
|
|
@RequestMapping(path = "/bookListByType")
|
|
public R bookListByType(String type) {
|
|
MPJLambdaWrapper<BookEntity> wrapper = new MPJLambdaWrapper();
|
|
wrapper.selectAll(BookEntity.class);
|
|
wrapper.leftJoin(MedicaldesBook.class,MedicaldesBook::getBookId,BookEntity::getId);
|
|
wrapper.eq(MedicaldesBook::getTypeId,type);
|
|
List<BookEntity> list = bookService.list(wrapper);
|
|
return R.ok().put("result", list);
|
|
}
|
|
|
|
@RequestMapping(path = "/saveOrUpdateBookRelation")
|
|
public R saveOrUpdateBookRelation(@RequestBody MedicaldesBook medicaldesBook) {
|
|
medicaldesBookService.saveOrUpdate(medicaldesBook);
|
|
return R.ok();
|
|
}
|
|
|
|
@RequestMapping(path = "/delBookRelation")
|
|
public R delBookRelation(String id) {
|
|
medicaldesBookService.removeById(id);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 学术传承列表分页
|
|
*/
|
|
@RequestMapping(path = "/inheritListByPage")
|
|
public R inheritListByPage(@RequestBody Map map) {
|
|
MPJLambdaWrapper<MedicaldesInherit> wrapper = new MPJLambdaWrapper();
|
|
wrapper.leftJoin(MedicaldesInheritRelation.class,MedicaldesInheritRelation::getInheritId,MedicaldesInherit::getId);
|
|
wrapper.leftJoin(City.class,City::getCityId,MedicaldesInherit::getCityId);
|
|
wrapper.leftJoin(Province.class,Province::getProvId,City::getProvId);
|
|
wrapper.selectAll(MedicaldesInherit.class);
|
|
if (map.containsKey("dictType")&&StringUtils.isNotEmpty(map.get("dictType").toString())){
|
|
wrapper.eq(MedicaldesInheritRelation::getTypeId,map.get("dictType"));
|
|
}
|
|
if (map.containsKey("name")&&StringUtils.isNotEmpty(map.get("name").toString())){
|
|
wrapper.like(MedicaldesInherit::getName,map.get("name"));
|
|
}
|
|
Page<MedicaldesInherit> page = inheritService.page(new Page<>(
|
|
Long.parseLong(map.get("current").toString()), Long.parseLong(map.get("limit").toString())),wrapper);
|
|
return R.ok().put("result", page);
|
|
}
|
|
|
|
/**
|
|
* 学术传承列表按类型、地区
|
|
*/
|
|
@RequestMapping(path = "/inheritListByTypeProvId")
|
|
public R inheritListByTypeProvId(String type,String provId) {
|
|
MPJLambdaWrapper<MedicaldesInherit> wrapper = new MPJLambdaWrapper();
|
|
wrapper.leftJoin(MedicaldesInheritRelation.class,MedicaldesInheritRelation::getInheritId,MedicaldesInherit::getId);
|
|
wrapper.eq(MedicaldesInheritRelation::getTypeId,type);
|
|
wrapper.leftJoin(City.class,City::getCityId,MedicaldesInherit::getCityId);
|
|
wrapper.leftJoin(Province.class,Province::getProvId,City::getProvId);
|
|
wrapper.selectAll(MedicaldesInherit.class);
|
|
wrapper.eq(Province::getProvId,provId);
|
|
List<MedicaldesInherit> list = inheritService.list(wrapper);
|
|
return R.ok().put("result", list);
|
|
}
|
|
|
|
@RequestMapping(path = "/getInheritById")
|
|
public R getInheritById(String id) {
|
|
return R.ok().put("result",inheritService.getById(id));
|
|
}
|
|
|
|
@RequestMapping(path = "/saveOrUpdateInherit")
|
|
public R addInherit(@RequestBody MedicaldesInherit inherit) {
|
|
MedicaldesInheritRelation relation = null;
|
|
if (inherit.getId()==null) {
|
|
relation = new MedicaldesInheritRelation();
|
|
}else {
|
|
LambdaQueryWrapper<MedicaldesInheritRelation> wrapper = new LambdaQueryWrapper();
|
|
wrapper.eq(MedicaldesInheritRelation::getInheritId,inherit.getId());
|
|
relation = relationService.getOne(wrapper);
|
|
}
|
|
inheritService.saveOrUpdate(inherit);
|
|
relation.setTypeId(inherit.getType());
|
|
relation.setInheritId(inherit.getId());
|
|
relationService.saveOrUpdate(relation);
|
|
return R.ok();
|
|
}
|
|
|
|
@RequestMapping(path = "/delInherit")
|
|
public R delInherit(String id) {
|
|
inheritService.removeById(id);
|
|
LambdaQueryWrapper<MedicaldesInheritRelation> wrapper = new LambdaQueryWrapper();
|
|
wrapper.eq(MedicaldesInheritRelation::getInheritId,id);
|
|
relationService.removeById(relationService.getOne(wrapper));
|
|
return R.ok();
|
|
}
|
|
|
|
@RequestMapping(path = "/getList")
|
|
public List<Map<String,Object>> getList(String type) {
|
|
MPJLambdaWrapper<MedicaldesInherit> wrapper = new MPJLambdaWrapper();
|
|
wrapper.leftJoin(MedicaldesInheritRelation.class,MedicaldesInheritRelation::getInheritId,MedicaldesInherit::getId);
|
|
wrapper.eq(MedicaldesInheritRelation::getTypeId,type);
|
|
wrapper.leftJoin(City.class,City::getCityId,MedicaldesInherit::getCityId);
|
|
wrapper.leftJoin(Province.class,Province::getProvId,City::getProvId);
|
|
wrapper.selectAs(Province::getProvName,"provinceName");
|
|
wrapper.selectAs(Province::getProvId,"provinceId");
|
|
wrapper.select("count(*) as count");
|
|
wrapper.groupBy("provinceName");
|
|
List<Map<String,Object>> list = inheritService.listMaps(wrapper);
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* 吴门之光列表
|
|
*/
|
|
@RequestMapping(path = "/lightListByType")
|
|
public R lightListByType(String type) {
|
|
LambdaQueryWrapper<MedicaldesLight> wrapper = new LambdaQueryWrapper();
|
|
if (StringUtils.isNotEmpty(type)){
|
|
wrapper.eq(MedicaldesLight::getType,type);
|
|
}
|
|
List<MedicaldesLight> list = lightService.list(wrapper);
|
|
return R.ok().put("result", list);
|
|
}
|
|
|
|
/**
|
|
* 吴门之光列表
|
|
*/
|
|
@RequestMapping(path = "/lightListByPage")
|
|
public R lightListByPage(@RequestBody Map map) {
|
|
LambdaQueryWrapper<MedicaldesLight> wrapper = new LambdaQueryWrapper();
|
|
if (map.containsKey("type")&&StringUtils.isNotEmpty(map.get("type").toString())){
|
|
wrapper.eq(MedicaldesLight::getType,map.get("type"));
|
|
}
|
|
if (map.containsKey("name")&&StringUtils.isNotEmpty(map.get("name").toString())){
|
|
wrapper.like(MedicaldesLight::getName,map.get("name"));
|
|
}
|
|
Page<MedicaldesLight> page = lightService.page(new Page<>(
|
|
Long.parseLong(map.get("current").toString()), Long.parseLong(map.get("limit").toString())),wrapper);
|
|
return R.ok().put("result", page);
|
|
}
|
|
|
|
@RequestMapping(path = "/getLightById")
|
|
public R getLightById(String id) {
|
|
return R.ok().put("result",lightService.getById(id));
|
|
}
|
|
|
|
@RequestMapping(path = "/saveOrUpdateLight")
|
|
public R addLight(@RequestBody MedicaldesLight light) {
|
|
lightService.saveOrUpdate(light);
|
|
return R.ok();
|
|
}
|
|
|
|
@RequestMapping(path = "/delLight")
|
|
public R delLight(String id) {
|
|
lightService.removeById(id);
|
|
return R.ok();
|
|
}
|
|
|
|
}
|