package com.doumee.service.business.impl;
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.doumee.biz.system.SystemDictDataBiz;
|
import com.doumee.core.constants.ResponseStatus;
|
import com.doumee.core.exception.BusinessException;
|
import com.doumee.core.model.LoginUserInfo;
|
import com.doumee.core.model.PageData;
|
import com.doumee.core.model.PageWrap;
|
import com.doumee.core.utils.Constants;
|
import com.doumee.core.utils.DESUtil;
|
import com.doumee.core.utils.DateUtil;
|
import com.doumee.core.utils.Utils;
|
import com.doumee.core.wx.MeetConstants;
|
import com.doumee.dao.admin.request.QrOpenDoorDto;
|
import com.doumee.dao.business.RoomsMapper;
|
import com.doumee.dao.business.join.*;
|
import com.doumee.dao.business.model.*;
|
import com.doumee.dao.system.model.SystemUser;
|
import com.doumee.dao.web.request.MeetingPageRequest;
|
import com.doumee.dao.web.request.RoomsRequest;
|
import com.doumee.dao.web.response.MeetingListResponse;
|
import com.doumee.dao.web.response.ProjectsResponse;
|
import com.doumee.dao.web.response.RoomsResponse;
|
import com.doumee.service.business.RoomsService;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 会议室信息表Service实现
|
*
|
* @author 江蹄蹄
|
* @date 2023/05/04 18:18
|
*/
|
@Service
|
public class RoomsServiceImpl implements RoomsService {
|
|
@Value("${des_pwd}")
|
private String desPwd;
|
@Autowired
|
private RoomsMapper roomsMapper;
|
@Autowired
|
private RoomsJoinMapper roomsJoinMapper;
|
|
@Autowired
|
private RoomTimeJoinMapper roomTimeJoinMapper;
|
@Autowired
|
private BookingsJoinMapper bookingsJoinMapper;
|
|
@Autowired
|
private ProjectRelJoinMapper projectRelJoinMapper;
|
@Autowired
|
private UserRelJoinMapper userRelJoinMapper;
|
|
@Autowired
|
private SystemDictDataBiz systemDictDataBiz;
|
@Override
|
@Transactional(rollbackFor = {BusinessException.class, Exception.class})
|
public Integer create(Rooms rooms) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
isCreateParamValid(rooms, user);
|
|
Calendar starttime = Calendar.getInstance();
|
starttime.set(Calendar.HOUR_OF_DAY, timeFormat(rooms.getStartTime(), "HH"));
|
starttime.set(Calendar.MINUTE, timeFormat(rooms.getStartTime(), "mm"));
|
starttime.set(Calendar.MILLISECOND, 1);
|
|
Calendar endtime = Calendar.getInstance();
|
endtime.set(Calendar.HOUR_OF_DAY, timeFormat(rooms.getEndTime(), "HH"));
|
endtime.set(Calendar.MINUTE, timeFormat(rooms.getEndTime(), "mm"));
|
endtime.set(Calendar.MILLISECOND, 1);
|
if (starttime.after(endtime) || starttime.equals(endtime)) {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "日期区间错误");
|
}
|
|
|
rooms.setCreateDate(new Date());
|
rooms.setIsdeleted(Constants.ZERO);
|
rooms.setCreator(user.getId());
|
rooms.setStatus(Constants.ZERO);
|
rooms.setEditDate(rooms.getCreateDate());
|
roomsMapper.insert(rooms);
|
|
rooms.setStartTime(rooms.getStartTime()+":00");
|
rooms.setEndTime(rooms.getEndTime()+":00");
|
rooms.setStartTime(DateUtil.formatDate(starttime.getTime(), "yyyy-MM-dd HH:mm:ss"));
|
rooms.setEndTime(DateUtil.formatDate(endtime.getTime(), "yyyy-MM-dd HH:mm:ss"));
|
|
//TODO 更新会议室时间段
|
updateRoomTimes(rooms, user);
|
|
//TODO 添加管理人员
|
updateManager(rooms, user);
|
//TODO 添加管服务项目
|
updateProjectRel(rooms, user);
|
return rooms.getId();
|
}
|
|
public void isCreateParamValid(Rooms rooms, LoginUserInfo user) {
|
if (StringUtils.isBlank(rooms.getName()) ||
|
StringUtils.isBlank(rooms.getStartTime()) ||
|
StringUtils.isBlank(rooms.getEndTime()) ||
|
rooms.getIntervalTime() == null
|
) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), ResponseStatus.BAD_REQUEST.getMessage());
|
}
|
|
|
|
MPJLambdaWrapper<Rooms> queryWrapper = new MPJLambdaWrapper<>();
|
queryWrapper.eq(Rooms::getIsdeleted, Constants.ZERO);
|
queryWrapper.eq(Rooms::getName, rooms.getName());
|
queryWrapper.last("limit 1");
|
Rooms result = roomsJoinMapper.selectJoinOne(Rooms.class, queryWrapper);
|
if (Objects.nonNull(result)) {
|
if (rooms.getId() != null) {
|
//编辑时判断
|
/* Integer re = recordisExist(rooms.getId());
|
if (Constants.equalsInteger(re, Constants.ONE)) {
|
//存下预约记录不允许更新开放时间和粒度分钟
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "会议室存在预约中的记录，不允许修改");
|
}
|
*/
|
if (!Constants.equalsInteger(rooms.getId(), result.getId())) {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "会议室名称已存在，不允许重复！");
|
}
|
|
|
} else {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "会议室名称已存在，不允许重复！");
|
}
|
|
}
|
|
|
}
|
|
public Integer recordisExist(Integer roomsId) {
|
MPJLambdaWrapper<Bookings> queryBooke = new MPJLambdaWrapper<>();
|
queryBooke.eq(Bookings::getIsdeleted, Constants.ZERO);
|
queryBooke.eq(Bookings::getRoomId, roomsId);
|
queryBooke.eq(Bookings::getStatus, Constants.ZERO);
|
List<Bookings> bookList = bookingsJoinMapper.selectList(queryBooke);
|
for (Bookings res : bookList) {
|
Calendar bj = Calendar.getInstance();
|
bj.setTime(res.getEndTime());
|
Calendar bjnow = Calendar.getInstance();
|
if (bjnow.before(bj)) {
|
return Constants.ONE;
|
}
|
}
|
return Constants.ZERO;
|
}
|
|
public static Integer timeFormat(String time, String mark) {
|
if (StringUtils.equals(mark, "HH")) {
|
if (time.contains(":")) {
|
String[] res = time.split(":");
|
return Integer.parseInt(res[0]);
|
}
|
}
|
|
if (StringUtils.equals(mark, "mm")) {
|
if (time.contains(":")) {
|
String[] res = time.split(":");
|
return Integer.parseInt(res[1]);
|
}
|
}
|
|
return 0;
|
}
|
|
public void updateRoomTimes(Rooms rooms, LoginUserInfo user) {
|
Calendar starttime = Calendar.getInstance();
|
starttime.setTime(DateUtil.StringToDate(rooms.getStartTime()));
|
Calendar endtime = Calendar.getInstance();
|
endtime.setTime(DateUtil.StringToDate(rooms.getEndTime()));
|
|
List<Map<String, Date>> list = new ArrayList<>();
|
while (starttime.before(endtime)) {
|
Map<String, Date> map = new HashMap<>();
|
map.put("start", starttime.getTime());
|
|
starttime.add(Calendar.MINUTE, rooms.getIntervalTime());
|
map.put("end", starttime.getTime());
|
list.add(map);
|
}
|
RoomTime roomTime = new RoomTime();
|
|
UpdateWrapper<RoomTime> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.lambda().eq(RoomTime::getIsdeleted, Constants.ZERO);
|
updateWrapper.lambda().eq(RoomTime::getRoomId, rooms.getId());
|
|
RoomTime rt = new RoomTime();
|
rt.setIsdeleted(Constants.ONE);
|
roomTimeJoinMapper.update(rt, updateWrapper);
|
|
list.stream().forEach(s -> {
|
if (s.get("end").before(endtime.getTime()) || s.get("end").equals(endtime.getTime())) {
|
roomTime.setId(null);
|
roomTime.setIsdeleted(Constants.ZERO);
|
roomTime.setCreator(user.getId());
|
roomTime.setCreateDate(new Date());
|
roomTime.setRoomId(rooms.getId());
|
roomTime.setStatus(Constants.ZERO);
|
roomTime.setStartTime(DateUtil.formatDate(s.get("start"), "HH:mm"));
|
roomTime.setEndTime(DateUtil.formatDate(s.get("end"), "HH:mm"));
|
roomTimeJoinMapper.insert(roomTime);
|
}
|
});
|
|
}
|
|
|
public void updateManager(Rooms rooms, LoginUserInfo user){
|
QueryWrapper<UserRel> updateWrapper = new QueryWrapper<>();
|
updateWrapper.lambda().eq(UserRel::getIsdeleted,Constants.ZERO);
|
updateWrapper.lambda().eq(UserRel::getObjId,rooms.getId());
|
updateWrapper.lambda().eq(UserRel::getObjType,Constants.ZERO);
|
UserRel userRel=new UserRel();
|
userRel.setIsdeleted(Constants.ONE);
|
userRelJoinMapper.update(userRel,updateWrapper);
|
if(org.apache.commons.collections4.CollectionUtils.isNotEmpty(rooms.getSysList())){
|
|
rooms.getSysList().stream().forEach(s ->{
|
|
s.setIsdeleted(Constants.ZERO);
|
s.setCreateDate(new Date());
|
s.setCreator(user.getId());
|
s.setUserId(s.getUserId());
|
s.setObjId(rooms.getId());
|
s.setObjType(Constants.ZERO);
|
userRelJoinMapper.insert(s);
|
});
|
|
}
|
|
|
}
|
|
public void updateProjectRel(Rooms rooms, LoginUserInfo user){
|
|
QueryWrapper<ProjectRel> updateWrapper = new QueryWrapper<>();
|
updateWrapper.lambda().eq(ProjectRel::getIsdeleted,Constants.ZERO);
|
updateWrapper.lambda().eq(ProjectRel::getObjId,rooms.getId());
|
updateWrapper.lambda().eq(ProjectRel::getObjType,Constants.ZERO);
|
ProjectRel projectRel=new ProjectRel();
|
projectRel.setIsdeleted(Constants.ONE);
|
projectRelJoinMapper.update(projectRel,updateWrapper);
|
if(org.apache.commons.collections4.CollectionUtils.isNotEmpty(rooms.getProjectList())){
|
rooms.getProjectList().stream().forEach(s ->{
|
|
s.setIsdeleted(Constants.ZERO);
|
s.setCreateDate(new Date());
|
s.setCreator(user.getId());
|
s.setProjectId(s.getProjectId());
|
s.setObjId(rooms.getId());
|
s.setObjType(Constants.ZERO);
|
projectRelJoinMapper.insert(s);
|
});
|
}
|
}
|
|
@Override
|
public void deleteById(Integer id) {
|
|
Integer re = recordisExist(id);
|
if (Constants.equalsInteger(re, Constants.ONE)) {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "会议室存在预约中的记录，不允许删除");
|
}
|
Rooms rooms=new Rooms();
|
rooms.setId(id);
|
rooms.setIsdeleted(Constants.ONE);
|
roomsMapper.updateById(rooms);
|
}
|
|
@Override
|
public void delete(Rooms rooms) {
|
UpdateWrapper<Rooms> deleteWrapper = new UpdateWrapper<>(rooms);
|
roomsMapper.delete(deleteWrapper);
|
}
|
|
@Override
|
public void deleteByIdInBatch(List<Integer> ids) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return;
|
}
|
// roomsMapper.deleteBatchIds(ids);
|
|
for(Integer id:ids){
|
Rooms res= roomsMapper.selectById(id);
|
Integer re = recordisExist(id);
|
if (Constants.equalsInteger(re, Constants.ONE)) {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), res.getName()+":会议室存在预约中的记录，不允许删除");
|
}
|
Rooms rooms=new Rooms();
|
rooms.setId(id);
|
rooms.setIsdeleted(Constants.ONE);
|
roomsMapper.updateById(rooms);
|
}
|
}
|
|
|
|
@Override
|
@Transactional(rollbackFor = {BusinessException.class, Exception.class})
|
public void updateById(Rooms rooms) {
|
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
isCreateParamValid(rooms, user);
|
|
Calendar starttime = Calendar.getInstance();
|
starttime.set(Calendar.HOUR_OF_DAY, timeFormat(rooms.getStartTime(), "HH"));
|
starttime.set(Calendar.MINUTE, timeFormat(rooms.getStartTime(), "mm"));
|
starttime.set(Calendar.MILLISECOND, 1);
|
|
Calendar endtime = Calendar.getInstance();
|
endtime.set(Calendar.HOUR_OF_DAY, timeFormat(rooms.getEndTime(), "HH"));
|
endtime.set(Calendar.MINUTE, timeFormat(rooms.getEndTime(), "mm"));
|
endtime.set(Calendar.MILLISECOND, 1);
|
if (starttime.after(endtime) || starttime.equals(endtime)) {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "日期区间错误");
|
}
|
|
Integer re = recordisExist(rooms.getId());
|
if (Constants.equalsInteger(re, Constants.ONE)) {
|
//存下预约记录不允许更新开放时间和粒度分钟
|
// throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "会议室存在预约中的记录，不允许修改");
|
rooms.setStartTime(null);
|
rooms.setEndTime(null);
|
rooms.setIntervalTime(null);
|
}
|
|
|
rooms.setEditDate(new Date());
|
rooms.setEditor(user.getId());
|
roomsMapper.update(rooms, Wrappers.<Rooms>lambdaUpdate()
|
.set(Rooms::getLimitNum, rooms.getLimitNum())
|
.set(Rooms::getTips, rooms.getTips())
|
.set(Rooms::getImgurl, rooms.getImgurl())
|
.eq(Rooms::getId, rooms.getId()));
|
|
|
rooms.setStartTime(rooms.getStartTime()+":00");
|
rooms.setEndTime(rooms.getEndTime()+":00");
|
rooms.setStartTime(DateUtil.formatDate(starttime.getTime(), "yyyy-MM-dd HH:mm:ss"));
|
rooms.setEndTime(DateUtil.formatDate(endtime.getTime(), "yyyy-MM-dd HH:mm:ss"));
|
|
|
//TODO 更新会议室时间段
|
if (!Constants.equalsInteger(re, Constants.ONE)) {
|
updateRoomTimes(rooms, user);
|
}
|
|
//TODO 添加管理人员
|
updateManager(rooms, user);
|
//TODO 添加管服务项目
|
updateProjectRel(rooms, user);
|
}
|
|
@Override
|
public void updateByIdInBatch(List<Rooms> roomss) {
|
if (CollectionUtils.isEmpty(roomss)) {
|
return;
|
}
|
for (Rooms rooms : roomss) {
|
// this.updateById(rooms);
|
}
|
}
|
@Override
|
public void updateStatusById(Rooms rooms) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
|
Integer re = recordisExist(rooms.getId());
|
if (Constants.equalsInteger(re, Constants.ONE)) {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "会议室存在预约中的记录，禁止操作");
|
}
|
rooms.setEditDate(new Date());
|
rooms.setEditor(user.getId());
|
roomsMapper.updateById(rooms);
|
}
|
|
|
@Override
|
public Rooms findById(Integer id) {
|
|
return roomsMapper.selectById(id);
|
}
|
|
@Override
|
public Rooms findOne(Rooms rooms) {
|
QueryWrapper<Rooms> wrapper = new QueryWrapper<>(rooms);
|
return roomsMapper.selectOne(wrapper);
|
}
|
|
@Override
|
public List<Rooms> findList(Rooms rooms) {
|
|
MPJLambdaWrapper<Rooms> wrapper = new MPJLambdaWrapper<>();
|
wrapper.eq(Rooms::getIsdeleted,Constants.ZERO);
|
wrapper.eq(rooms.getStatus()!=null,Rooms::getStatus,rooms.getStatus());
|
wrapper.orderByDesc(Rooms::getCreateDate);
|
List<Rooms> list=roomsJoinMapper.selectList(wrapper);
|
/* if(list!=null){
|
list.stream().forEach(s ->{
|
MPJLambdaWrapper<RoomTime> findrt = new MPJLambdaWrapper<>();
|
findrt.eq(RoomTime::getIsdeleted, Constants.ZERO);
|
findrt.eq(RoomTime::getRoomId, s.getId());
|
List<RoomTime> list1= roomTimeJoinMapper.selectList(findrt);
|
s.setRoomTimeList(list1);
|
});
|
}*/
|
return list;
|
}
|
|
@Override
|
public PageData<Rooms> findPage(PageWrap<Rooms> pageWrap) {
|
IPage<Rooms> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
|
MPJLambdaWrapper<Rooms> queryWrapper = new MPJLambdaWrapper<>();
|
Utils.MP.blankToNull(pageWrap.getModel());
|
|
queryWrapper.selectAll(Rooms.class);
|
|
queryWrapper.orderByDesc(Rooms::getCreateDate);
|
queryWrapper.eq(Rooms::getIsdeleted, Constants.ZERO);
|
queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getName()),Rooms::getName, pageWrap.getModel().getName());
|
|
if(org.apache.commons.collections4.CollectionUtils.isNotEmpty(pageWrap.getModel().getSysList())){
|
// queryWrapper.leftJoin(UserRel.class,UserRel::getObjId,Rooms::getId);
|
List<Integer> collect = pageWrap.getModel().getSysList().stream().map(UserRel::getUserId).collect(Collectors.toList());
|
|
queryWrapper.exists("select u.id from user_rel u where u.ISDELETED=0 and u.OBJ_ID =t.id and u.USER_ID in (" + StringUtils.strip(collect.toString(),"[]")+" )");
|
}
|
|
String path = systemDictDataBiz.queryByCode(Constants.SYSTEM, Constants.FILE_DIR).getCode() + systemDictDataBiz.queryByCode(MeetConstants.OSS, MeetConstants.PROJECTS).getCode();
|
|
IPage<Rooms> result = roomsJoinMapper.selectJoinPage(page, Rooms.class, queryWrapper);
|
result.getRecords().stream().forEach(s ->{
|
|
if(StringUtils.isNotBlank(s.getImgurl())){
|
s.setImgFullUrl(path+s.getImgurl());
|
}
|
|
MPJLambdaWrapper<UserRel> finduser = new MPJLambdaWrapper<>();
|
finduser.selectAll(UserRel.class);
|
finduser.selectAs(SystemUser::getRealname,UserRel::getRealName);
|
finduser.eq(UserRel::getIsdeleted,Constants.ZERO);
|
finduser.eq(UserRel::getObjId,s.getId());
|
finduser.eq(UserRel::getObjType,Constants.ZERO);
|
finduser.leftJoin(SystemUser.class,SystemUser::getId,UserRel::getUserId);
|
finduser.orderByDesc(UserRel::getCreateDate);
|
List<UserRel> sysList=userRelJoinMapper.selectJoinList(UserRel.class,finduser);
|
s.setSysList(sysList);
|
|
|
MPJLambdaWrapper<ProjectRel> findpr = new MPJLambdaWrapper<>();
|
findpr.selectAll(ProjectRel.class);
|
findpr.selectAs(Projects::getName,ProjectRel::getProjectName);
|
findpr.eq(ProjectRel::getIsdeleted,Constants.ZERO);
|
findpr.eq(ProjectRel::getObjId,s.getId());
|
findpr.eq(ProjectRel::getObjType,Constants.ZERO);
|
findpr.leftJoin(Projects.class,Projects::getId,ProjectRel::getProjectId);
|
List<ProjectRel> projectLisr= projectRelJoinMapper.selectJoinList(ProjectRel.class,findpr);
|
s.setProjectList(projectLisr);
|
});
|
|
return PageData.from(result);
|
}
|
|
@Override
|
public long count(Rooms rooms) {
|
QueryWrapper<Rooms> wrapper = new QueryWrapper<>(rooms);
|
return roomsMapper.selectCount(wrapper);
|
}
|
|
|
|
|
/****************************************移动端接口开始********************************************************************/
|
|
@Override
|
public List<RoomsResponse> getRoomsList() {
|
return roomsMapper.getRoomsList(new QueryWrapper<RoomsResponse>()
|
.eq("ISDELETED",Constants.ZERO)
|
.eq("STATUS",Constants.ZERO)
|
.orderByDesc(" CREATE_DATE ")
|
);
|
}
|
|
/**
|
* 获取开门二维码
|
* @param id
|
* @param userId
|
* @return
|
*/
|
@Override
|
public String getQrCode(Integer id,Integer userId){
|
Rooms model = roomsMapper.selectById(id);
|
if(model == null || !Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到会议室详情");
|
}
|
QrOpenDoorDto dto = new QrOpenDoorDto();
|
dto.setType(Constants.ONE);
|
dto.setUserId(userId);
|
dto.setTimestamp(System.currentTimeMillis());
|
dto.setObjId(id);
|
return DESUtil.encrypt(desPwd,QrOpenDoorDto.getParamFromObject(dto));
|
}
|
|
|
|
@Override
|
public IPage<RoomsResponse> getRoomsPage(PageWrap<RoomsRequest> pageWrap) {
|
IPage<RoomsResponse> page = roomsMapper.myRoomsPage(pageWrap.toPage(),new QueryWrapper<RoomsResponse>()
|
.eq("STATUS",Constants.ZERO)
|
.eq("ISDELETED",Constants.ZERO)
|
.like(StringUtils.isNotBlank(pageWrap.getModel().getRoomsName()),"NAME",pageWrap.getModel().getRoomsName())
|
.exists(" select 1 from user_rel u where u.USER_ID = "+pageWrap.getModel().getUserId()+" and u.ISDELETED = 0 and u.OBJ_ID = rooms.id and u.OBJ_TYPE = 0 ")
|
.orderByDesc("CREATE_DATE")
|
);
|
String prefixUrl = systemDictDataBiz.queryByCode(Constants.SYSTEM, Constants.FILE_DIR).getCode()
|
+ systemDictDataBiz.queryByCode(MeetConstants.OSS, MeetConstants.PROJECTS).getCode();
|
page.getRecords().forEach(s->{
|
s.setPrefixUrl(prefixUrl);
|
|
MPJLambdaWrapper<UserRel> findUser = new MPJLambdaWrapper<>();
|
findUser.selectAll(UserRel.class);
|
findUser.selectAs(SystemUser::getRealname,UserRel::getRealName);
|
findUser.eq(UserRel::getIsdeleted,Constants.ZERO);
|
findUser.eq(UserRel::getObjId,s.getId());
|
findUser.eq(UserRel::getObjType,Constants.ZERO);
|
findUser.leftJoin(SystemUser.class,SystemUser::getId,UserRel::getUserId);
|
findUser.orderByDesc(UserRel::getCreateDate);
|
List<UserRel> sysList=userRelJoinMapper.selectJoinList(UserRel.class,findUser);
|
s.setSysList(sysList);
|
|
MPJLambdaWrapper<ProjectRel> findProjectRel = new MPJLambdaWrapper<>();
|
findProjectRel.selectAll(ProjectRel.class);
|
findProjectRel.selectAs(Projects::getName,ProjectRel::getProjectName);
|
findProjectRel.eq(ProjectRel::getIsdeleted,Constants.ZERO);
|
findProjectRel.eq(ProjectRel::getObjId,s.getId());
|
findProjectRel.eq(ProjectRel::getObjType,Constants.ZERO);
|
findProjectRel.leftJoin(Projects.class,Projects::getId,ProjectRel::getProjectId);
|
List<ProjectRel> projectList= projectRelJoinMapper.selectJoinList(ProjectRel.class,findProjectRel);
|
s.setProjectList(projectList);
|
|
});
|
return page;
|
}
|
|
@Override
|
public RoomsResponse getRoomDetail(Integer roomId) {
|
RoomsResponse roomsResponse = roomsMapper.myRoomsDetail(roomId);
|
if(Objects.isNull(roomsResponse)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到会议室信息");
|
}
|
|
String prefixUrl = systemDictDataBiz.queryByCode(Constants.SYSTEM, Constants.FILE_DIR).getCode() + systemDictDataBiz.queryByCode(MeetConstants.OSS, MeetConstants.PROJECTS).getCode();
|
|
roomsResponse.setPrefixUrl(prefixUrl);
|
|
MPJLambdaWrapper<ProjectRel> findProjectRel = new MPJLambdaWrapper<>();
|
findProjectRel.selectAll(ProjectRel.class);
|
findProjectRel.selectAs(Projects::getName,ProjectRel::getProjectName);
|
findProjectRel.eq(ProjectRel::getIsdeleted,Constants.ZERO);
|
findProjectRel.eq(ProjectRel::getObjId,roomsResponse.getId());
|
findProjectRel.eq(ProjectRel::getObjType,Constants.ZERO);
|
findProjectRel.innerJoin(Projects.class,Projects::getId,ProjectRel::getProjectId);
|
findProjectRel.orderByAsc(Projects::getSortnum);
|
List<ProjectRel> projectList= projectRelJoinMapper.selectJoinList(ProjectRel.class,findProjectRel);
|
|
roomsResponse.setProjectList(projectList);
|
|
return roomsResponse;
|
}
|
|
|
}
|
