package com.panzhihua.service_community.service.impl;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
import javax.annotation.Resource;
|
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.ObjectUtils;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.panzhihua.common.model.dtos.community.ExcelHouseDTO;
|
import com.panzhihua.common.model.vos.LoginUserInfoVO;
|
import com.panzhihua.common.model.vos.R;
|
import com.panzhihua.common.model.vos.community.BatchhouseVO;
|
import com.panzhihua.common.model.vos.community.ComMngStructAreaVO;
|
import com.panzhihua.common.model.vos.community.ComMngStructHouseVO;
|
import com.panzhihua.service_community.dao.ComMngStructAreaDAO;
|
import com.panzhihua.service_community.dao.ComMngStructHouseDAO;
|
import com.panzhihua.service_community.dao.ComMngStructHouseUserDAO;
|
import com.panzhihua.service_community.model.dos.ComMngStructAreaDO;
|
import com.panzhihua.service_community.model.dos.ComMngStructHouseDO;
|
import com.panzhihua.service_community.model.dos.ComMngStructHouseUserDO;
|
import com.panzhihua.service_community.service.ComMngStructHouseService;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
/**
|
* @program: springcloud_k8s_panzhihuazhihuishequ
|
* @description: 房屋
|
* @author: huang.hongfa weixin hhf9596 qq 959656820
|
* @create: 2020-12-15 15:07
|
**/
|
@Slf4j
|
@Service
|
public class ComMngStructHouseServiceImpl extends ServiceImpl<ComMngStructHouseDAO, ComMngStructHouseDO>
|
implements ComMngStructHouseService {
|
@Resource
|
private ComMngStructHouseDAO comMngStructHouseDAO;
|
@Resource
|
private ComMngStructHouseUserDAO comMngStructHouseUserDAO;
|
@Resource
|
private ComMngStructAreaDAO comMngStructAreaDAO;
|
|
/**
|
* 房屋信息
|
*
|
* @param userId
|
* 用户id
|
* @return 房屋信息
|
*/
|
@Override
|
public R detailHouse(Long userId) {
|
List<ComMngStructHouseVO> comMngStructHouseVOS = new ArrayList<>();
|
List<ComMngStructHouseUserDO> comMngStructHouseUserDOS = comMngStructHouseUserDAO.selectList(
|
new QueryWrapper<ComMngStructHouseUserDO>().lambda().eq(ComMngStructHouseUserDO::getUserId, userId));
|
if (!ObjectUtils.isEmpty(comMngStructHouseUserDOS)) {
|
String areaCode = comMngStructHouseUserDOS.get(0).getAreaCode();
|
ComMngStructHouseDO comMngStructHouseDO1 = comMngStructHouseDAO.selectOne(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getHouseCode, areaCode));
|
String houseName = comMngStructHouseDO1.getHouseName();
|
comMngStructHouseUserDOS.forEach(comMngStructHouseUserDO -> {
|
ComMngStructHouseDO comMngStructHouseDO =
|
comMngStructHouseDAO.selectOne(new QueryWrapper<ComMngStructHouseDO>().lambda()
|
.eq(ComMngStructHouseDO::getHouseCode, comMngStructHouseUserDO.getHouseCode()));
|
ComMngStructHouseVO comMngStructHouseVO = new ComMngStructHouseVO();
|
BeanUtils.copyProperties(comMngStructHouseDO, comMngStructHouseVO);
|
comMngStructHouseVO.setIdentity(comMngStructHouseUserDO.getIdentity());
|
comMngStructHouseVOS.add(comMngStructHouseVO);
|
});
|
return R.ok(comMngStructHouseVOS);
|
}
|
return R.ok(comMngStructHouseVOS);
|
}
|
|
/**
|
* 小区批量建房
|
*
|
* @param batchhouseVO
|
* 建房参数
|
* @return 建房结果
|
*/
|
@Override
|
public R batchHouse(BatchhouseVO batchhouseVO) {
|
String areaCode = batchhouseVO.getAreaCode();
|
Integer integer = comMngStructHouseDAO.selectCount(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getParentCode, areaCode));
|
if (null != integer && integer.intValue() > 0) {
|
return R.fail("小区房屋已经存在，删除后批量创建或者使用编辑功能单独创建");
|
}
|
this.batchSaveHouse(batchhouseVO);
|
return R.ok();
|
}
|
|
/**
|
* 批量添加地址功能提取出一个公共方法
|
*
|
* @param batchhouseVO
|
* 批量添加小区、同级（楼栋、单元、楼层、房间）
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
void batchSaveHouse(BatchhouseVO batchhouseVO) {
|
String areaCode = batchhouseVO.getAreaCode();
|
ComMngStructHouseDO comMngStructHouseDO = comMngStructHouseDAO.selectOne(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getHouseCode, areaCode));
|
String areaName = comMngStructHouseDO.getHouseName();// 小区地址
|
int buildingBegin = batchhouseVO.getBuildingBegin().intValue();
|
int buildingEnd = batchhouseVO.getBuildingEnd().intValue();
|
int unitBegin = batchhouseVO.getUnitBegin().intValue();
|
int unitEnd = batchhouseVO.getUnitEnd().intValue();
|
int floorBegin = batchhouseVO.getFloorBegin().intValue();
|
int floorEnd = batchhouseVO.getFloorEnd().intValue();
|
int doorBegin = batchhouseVO.getDoorBegin().intValue();
|
int doorEnd = batchhouseVO.getDoorEnd().intValue();
|
int isAccumulation = batchhouseVO.getIsAccumulation().intValue();
|
String ruleFloor = batchhouseVO.getRuleFloor();
|
String ruleConnector = batchhouseVO.getRuleConnector();
|
String ruleDoor = batchhouseVO.getRuleDoor();
|
List<ComMngStructHouseDO> comMngStructHouseDOList = new ArrayList<>();
|
long buildCode = 510000;
|
long unitCode = 410000;
|
long floorCode = 310000;
|
long doorCode = 210000;
|
Integer type = batchhouseVO.getType();
|
ComMngStructHouseDO comMngStructHouseDOParent =
|
comMngStructHouseDAO.selectOne(new QueryWrapper<ComMngStructHouseDO>().lambda()
|
.eq(ComMngStructHouseDO::getHouseCode, batchhouseVO.getParentCode()));
|
// 2楼栋 3 单元 4楼层 5门牌号
|
for (int i = buildingBegin; i <= buildingEnd; i++) {// 楼栋
|
ComMngStructHouseDO comMngStructHouseDO1 = new ComMngStructHouseDO();
|
if (buildingBegin == buildingEnd && null != type && type == 3) {
|
comMngStructHouseDO1 = comMngStructHouseDOParent;
|
} else {
|
comMngStructHouseDO1.setHouseName(areaName + i + "栋");
|
comMngStructHouseDO1.setHouseCode(areaCode + (buildCode + i));
|
comMngStructHouseDO1.setParentCode(areaCode);
|
comMngStructHouseDO1.setType(2);
|
comMngStructHouseDOList.add(comMngStructHouseDO1);
|
}
|
|
for (int m = unitBegin; m <= unitEnd; m++) {// 单元
|
ComMngStructHouseDO comMngStructHouseDO2 = new ComMngStructHouseDO();
|
if (unitBegin == unitEnd && null != type && type == 4) {
|
comMngStructHouseDO2 = comMngStructHouseDOParent;
|
} else {
|
comMngStructHouseDO2.setType(3);
|
comMngStructHouseDO2.setParentCode(comMngStructHouseDO1.getHouseCode());
|
comMngStructHouseDO2.setHouseName(comMngStructHouseDO1.getHouseName() + m + "单元");
|
comMngStructHouseDO2.setHouseCode(comMngStructHouseDO1.getHouseCode() + (unitCode + m));
|
comMngStructHouseDOList.add(comMngStructHouseDO2);
|
}
|
int num = 0;// 门牌累加时使用
|
|
for (int k = floorBegin; k <= floorEnd; k++) {// 楼层
|
ComMngStructHouseDO comMngStructHouseDO3 = new ComMngStructHouseDO();
|
if (floorBegin == floorEnd && null != type && type == 5) {
|
comMngStructHouseDO3 = comMngStructHouseDOParent;
|
} else {
|
comMngStructHouseDO3.setType(4);
|
comMngStructHouseDO3.setParentCode(comMngStructHouseDO2.getHouseCode());
|
comMngStructHouseDO3.setHouseName(comMngStructHouseDO2.getHouseName() + k + "层");
|
comMngStructHouseDO3.setHouseCode(comMngStructHouseDO2.getHouseCode() + (floorCode + k));
|
comMngStructHouseDOList.add(comMngStructHouseDO3);
|
}
|
|
for (int h = doorBegin; h <= doorEnd; h++) {// 门牌
|
num++;
|
ComMngStructHouseDO comMngStructHouseDO4 = new ComMngStructHouseDO();
|
comMngStructHouseDO4.setType(5);
|
comMngStructHouseDO4.setParentCode(comMngStructHouseDO3.getHouseCode());
|
String doorName = "";
|
String floorName = "";
|
// 楼层规则
|
if (ruleFloor.equals("1")) {
|
floorName = k + "";
|
} else if (ruleFloor.equals("01")) {
|
if (k < 10) {
|
floorName = "0" + k;
|
} else {
|
floorName = "" + k;
|
}
|
} else {// 001
|
if (k < 10) {
|
floorName = "00" + k;
|
} else if (k < 100) {
|
floorName = "0" + k;
|
} else {
|
floorName = "" + k;
|
}
|
}
|
// 门牌规则
|
if (ruleDoor.equals("1")) {
|
if (isAccumulation == 1) {// 累加
|
doorName = "" + num;
|
} else {
|
doorName = "" + h;
|
}
|
} else if (ruleDoor.equals("01")) {
|
if (k < 10) {
|
if (isAccumulation == 1) {// 累加
|
doorName = "0" + num;
|
} else {
|
doorName = "0" + h;
|
}
|
} else {
|
if (isAccumulation == 1) {// 累加
|
doorName = "" + num;
|
} else {
|
doorName = "" + h;
|
}
|
}
|
|
} else if (ruleDoor.equals("001")) {
|
if (k < 10) {
|
if (isAccumulation == 1) {// 累加
|
doorName = "00" + num;
|
} else {
|
doorName = "00" + h;
|
}
|
} else if (k < 100) {
|
if (isAccumulation == 1) {// 累加
|
doorName = "0" + num;
|
} else {
|
doorName = "0" + h;
|
}
|
} else {
|
if (isAccumulation == 1) {// 累加
|
doorName = "" + num;
|
} else {
|
doorName = "" + h;
|
}
|
}
|
}
|
comMngStructHouseDO4
|
.setHouseName(comMngStructHouseDO3.getHouseName() + floorName + ruleConnector + doorName);
|
comMngStructHouseDO4.setHouseCode(comMngStructHouseDO3.getHouseCode() + (doorCode + num));
|
comMngStructHouseDO4.setType(5);
|
comMngStructHouseDO4.setParentCode(comMngStructHouseDO3.getHouseCode());
|
comMngStructHouseDOList.add(comMngStructHouseDO4);
|
}
|
|
}
|
}
|
}
|
boolean b = this.saveBatch(comMngStructHouseDOList);
|
if (b) {
|
log.info("batchhouse----楼栋数一共【{}】", buildingEnd - buildingBegin + 1);
|
log.info("batchhouse----单元数一共【{}】", (unitEnd - unitBegin + 1) * (buildingEnd - buildingBegin + 1));
|
log.info("batchhouse----楼层数一共【{}】",
|
(unitEnd - unitBegin + 1) * (buildingEnd - buildingBegin + 1) * (floorEnd - floorBegin + 1));
|
log.info("batchhouse----房间数量一共【{}】", (unitEnd - unitBegin + 1) * (buildingEnd - buildingBegin + 1)
|
* (floorEnd - floorBegin + 1) * (doorEnd - doorBegin + 1));
|
log.info("batchhouse----批量新增房屋地址数量【{}】", comMngStructHouseDOList.size());
|
}
|
}
|
|
/**
|
* 新增小区地址
|
*
|
* @param comMngStructAreaVO
|
* 小区地址
|
*/
|
@Override
|
public R addHouseArea(ComMngStructAreaVO comMngStructAreaVO) {
|
ComMngStructHouseDO comMngStructHouseDO = new ComMngStructHouseDO();
|
comMngStructHouseDO.setHouseCode(comMngStructAreaVO.getAreaCode());
|
comMngStructHouseDO.setHouseName(comMngStructAreaVO.getAddressDetail());
|
comMngStructHouseDO.setType(1);
|
comMngStructHouseDO.setParentCode("0");
|
int insert = 0;
|
try {
|
insert = comMngStructHouseDAO.insert(comMngStructHouseDO);
|
} catch (Exception e) {
|
log.error("新增地址错误【{}】", e.getMessage());
|
if (e.getMessage().contains("unique_house_name")) {
|
return R.fail("小区已经存在");
|
}
|
}
|
if (insert > 0) {
|
return R.ok();
|
}
|
return R.fail();
|
}
|
|
/**
|
* 先删除小区小面所有房屋、删除用户和小区房屋的绑定关系
|
*
|
* @param comMngStructAreaVO
|
* 小区地址编码
|
* @return 删除结果
|
*/
|
@Override
|
public R batchDeleteHouse(ComMngStructAreaVO comMngStructAreaVO) {
|
String areaCode = comMngStructAreaVO.getAreaCode();
|
try {
|
int i = comMngStructHouseDAO.batchDeleteHouse(areaCode);// 调用存储过程删除
|
log.info("调用存储工程共删除地址数量【{}】", i);
|
} catch (Exception e) {
|
log.error(e.getMessage());
|
return R.fail();
|
}
|
return R.ok();
|
}
|
|
/**
|
* 展示下级建筑
|
*
|
* @param houseCode
|
* 房屋编号
|
* @return 下级建筑列表
|
*/
|
@Override
|
public R listSubordinatebuilding(String houseCode) {
|
List<ComMngStructHouseVO> comMngStructHouseVOS = new ArrayList<>();
|
List<ComMngStructHouseDO> comMngStructHouseDOList = comMngStructHouseDAO.selectList(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getParentCode, houseCode));
|
if (!ObjectUtils.isEmpty(comMngStructHouseDOList)) {
|
comMngStructHouseDOList.forEach(comMngStructHouseDO -> {
|
ComMngStructHouseVO comMngStructHouseVO = new ComMngStructHouseVO();
|
int type = comMngStructHouseDO.getType().intValue();
|
String houseCode1 = comMngStructHouseDO.getHouseCode();
|
BeanUtils.copyProperties(comMngStructHouseDO, comMngStructHouseVO);
|
if (type == 5) {
|
List<LoginUserInfoVO> loginUserInfoVOS = comMngStructHouseUserDAO.selectListHouseUser(houseCode1);
|
if (!ObjectUtils.isEmpty(loginUserInfoVOS)) {
|
String names = loginUserInfoVOS.stream().map(loginUserInfoVO -> loginUserInfoVO.getName())
|
.collect(Collectors.joining(","));
|
String phones = loginUserInfoVOS.stream().map(loginUserInfoVO -> loginUserInfoVO.getPhone())
|
.collect(Collectors.joining(","));
|
comMngStructHouseVO.setNames(names);
|
comMngStructHouseVO.setPhones(phones);
|
}
|
}
|
|
comMngStructHouseVOS.add(comMngStructHouseVO);
|
});
|
}
|
return R.ok(comMngStructHouseVOS);
|
}
|
|
/**
|
* 添加同级地址
|
*
|
* @param batchhouseVO
|
* 添加参数
|
* @param comMngStructAreaDO
|
* 小区信息-规则
|
* @return 添加结果
|
*/
|
@Override
|
public R addHouse(BatchhouseVO batchhouseVO, ComMngStructAreaDO comMngStructAreaDO) {
|
String roleConnector = comMngStructAreaDO.getRoleConnector();
|
String roleDoor = comMngStructAreaDO.getRoleDoor();
|
String roleFloor = comMngStructAreaDO.getRoleFloor();
|
int type = batchhouseVO.getType().intValue();
|
String parentCode1 = batchhouseVO.getParentCode();
|
List<ComMngStructHouseDO> comMngStructHouseDOList =
|
comMngStructHouseDAO.selectList(new QueryWrapper<ComMngStructHouseDO>().lambda()
|
.eq(ComMngStructHouseDO::getType, type).eq(ComMngStructHouseDO::getParentCode, parentCode1));
|
List<String> stringList = new ArrayList<>();
|
if (!ObjectUtils.isEmpty(comMngStructHouseDOList)) {
|
stringList = comMngStructHouseDOList.stream().map(comMngStructHouseDO -> comMngStructHouseDO.getHouseName())
|
.collect(Collectors.toList());
|
}
|
int begin = 0, end = 0;
|
String typeName = "";
|
// 2楼栋 3 单元 4楼层 5房间
|
switch (type) {
|
case 2:
|
begin = batchhouseVO.getBuildingBegin().intValue();
|
end = batchhouseVO.getBuildingEnd().intValue();
|
typeName = "栋";
|
break;
|
case 3:
|
begin = batchhouseVO.getUnitBegin();
|
end = batchhouseVO.getUnitEnd();
|
typeName = "单元";
|
batchhouseVO.setBuildingBegin(1);
|
batchhouseVO.setBuildingEnd(1);
|
break;
|
case 4:
|
begin = batchhouseVO.getFloorBegin();
|
end = batchhouseVO.getFloorEnd();
|
typeName = "层";
|
batchhouseVO.setBuildingBegin(1);
|
batchhouseVO.setBuildingEnd(1);
|
batchhouseVO.setUnitBegin(1);
|
batchhouseVO.setUnitEnd(1);
|
break;
|
case 5:
|
begin = batchhouseVO.getDoorBegin();
|
end = batchhouseVO.getDoorEnd();
|
batchhouseVO.setBuildingBegin(1);
|
batchhouseVO.setBuildingEnd(1);
|
batchhouseVO.setUnitBegin(1);
|
batchhouseVO.setUnitEnd(1);
|
batchhouseVO.setFloorBegin(1);
|
batchhouseVO.setFloorEnd(1);
|
break;
|
default:
|
break;
|
}
|
if (!ObjectUtils.isEmpty(stringList)) {
|
for (int i = begin; i <= end; i++) {
|
String address = i + typeName;
|
if (stringList.contains(address)) {
|
return R.fail(address + "已经存在，请删除后重新添加");
|
}
|
}
|
}
|
batchhouseVO.setRuleConnector(roleConnector);
|
batchhouseVO.setRuleDoor(roleDoor);
|
batchhouseVO.setRuleFloor(roleFloor);
|
this.batchSaveHouse(batchhouseVO);
|
return R.ok();
|
}
|
|
/**
|
* 编辑地址
|
*
|
* @param comMngStructHouseVO
|
* 编辑内容
|
* @return 编辑结果
|
*/
|
@Override
|
public R putHouse(ComMngStructHouseVO comMngStructHouseVO) {
|
ComMngStructHouseDO comMngStructHouseDO = new ComMngStructHouseDO();
|
comMngStructHouseDO.setSquare(comMngStructHouseVO.getSquare());
|
int update = comMngStructHouseDAO.update(comMngStructHouseDO, new UpdateWrapper<ComMngStructHouseDO>().lambda()
|
.eq(ComMngStructHouseDO::getHouseCode, comMngStructHouseVO.getHouseCode()));
|
if (update > 0) {
|
return R.ok();
|
}
|
return R.fail();
|
}
|
|
/**
|
* 删除地址
|
*
|
* @param comMngStructHouseVO
|
* 删除指定地址和所有下级
|
* @return 删除结果
|
*/
|
@Override
|
public R deleteHouse(ComMngStructHouseVO comMngStructHouseVO) {
|
String houseCode = comMngStructHouseVO.getHouseCode();
|
int i = comMngStructHouseDAO.batchDeleteHouse(houseCode);
|
if (i > 0) {
|
return R.ok();
|
}
|
return R.fail();
|
}
|
|
/**
|
* 房屋地址下拉列表
|
*
|
* @param parentCode
|
* 父级编码
|
* @return 下级列表
|
*/
|
@Override
|
public R putVolunteerPhone(String parentCode) {
|
List<ComMngStructHouseVO> comMngStructHouseVOS = new ArrayList<>();
|
ComMngStructHouseDO comMngStructHouseDO1 = comMngStructHouseDAO.selectOne(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getHouseCode, parentCode));
|
String houseName = comMngStructHouseDO1.getHouseName();
|
List<ComMngStructHouseDO> comMngStructHouseDOList = comMngStructHouseDAO.selectList(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getParentCode, parentCode));
|
if (!ObjectUtils.isEmpty(comMngStructHouseDOList)) {
|
comMngStructHouseDOList.forEach(comMngStructHouseDO -> {
|
ComMngStructHouseVO comMngStructHouseVO = new ComMngStructHouseVO();
|
BeanUtils.copyProperties(comMngStructHouseDO, comMngStructHouseVO);
|
comMngStructHouseVO.setHouseShortName(comMngStructHouseVO.getHouseName().replaceAll(houseName, ""));
|
comMngStructHouseVOS.add(comMngStructHouseVO);
|
});
|
}
|
return R.ok(comMngStructHouseVOS);
|
}
|
|
/**
|
* 新增房屋
|
*
|
* @param comMngStructHouseVO
|
* 房屋信息
|
* @return 新增结果
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R addHouses(ComMngStructHouseVO comMngStructHouseVO) {
|
String houseCode = comMngStructHouseVO.getHouseCode();
|
Integer states1 = comMngStructHouseVO.getState();
|
ComMngStructHouseDO comMngStructHouseDO1 = comMngStructHouseDAO.selectOne(
|
new QueryWrapper<ComMngStructHouseDO>().lambda().eq(ComMngStructHouseDO::getHouseCode, houseCode));
|
if (ObjectUtils.isEmpty(comMngStructHouseDO1)) {
|
return R.fail("房屋不存在");
|
}
|
Integer states = comMngStructHouseDO1.getState();
|
if (null != states && 0 != states.intValue()) {
|
if (states1.intValue() != states.intValue()) {
|
return R.fail("房屋已经被绑定了,请通过意见反馈联系后台处理");
|
}
|
}
|
ComMngStructHouseDO comMngStructHouseDO = new ComMngStructHouseDO();
|
comMngStructHouseDO.setSquare(comMngStructHouseVO.getSquare());
|
comMngStructHouseDO.setState(states1);
|
comMngStructHouseDO.setId(comMngStructHouseDO1.getId());
|
int update = comMngStructHouseDAO.updateById(comMngStructHouseDO);
|
if (update == 0) {
|
return R.fail("修改房屋面积、状态失败");
|
}
|
ComMngStructHouseUserDO comMngStructHouseUserDO1 =
|
comMngStructHouseUserDAO.selectOne(new QueryWrapper<ComMngStructHouseUserDO>().lambda()
|
.eq(ComMngStructHouseUserDO::getUserId, comMngStructHouseVO.getUserId())
|
.eq(ComMngStructHouseUserDO::getHouseCode, comMngStructHouseVO.getHouseCode()));
|
if (!ObjectUtils.isEmpty(comMngStructHouseUserDO1)) {
|
return R.ok();
|
}
|
ComMngStructHouseUserDO comMngStructHouseUserDO = new ComMngStructHouseUserDO();
|
comMngStructHouseUserDO.setUserId(comMngStructHouseVO.getUserId());
|
comMngStructHouseUserDO.setIdentity(comMngStructHouseVO.getIdentity());
|
comMngStructHouseUserDO.setAreaCode(comMngStructHouseVO.getAreaCode());
|
comMngStructHouseUserDO.setHouseCode(comMngStructHouseVO.getHouseCode());
|
int insert = comMngStructHouseUserDAO.insert(comMngStructHouseUserDO);
|
if (insert > 0) {
|
return R.ok();
|
}
|
throw new RuntimeException("绑定房屋和人员关系失败");
|
}
|
|
@Override
|
public R houseExport(Long areaId) {
|
ComMngStructAreaDO comMngStructAreaDO = comMngStructAreaDAO.selectById(areaId);
|
if (ObjectUtils.isEmpty(comMngStructAreaDO)) {
|
return R.fail("小区不存在");
|
}
|
List<ExcelHouseDTO> houseDTOS = comMngStructHouseDAO.houseExport(comMngStructAreaDO.getAreaCode());
|
return R.ok(houseDTOS);
|
}
|
|
}
|
