hust-epi/whepi-web/src/main/java/com/bofeng/service/WxUserOpenService.java

package com.bofeng.service;

import com.baomidou.mybatisplus.toolkit.IdWorker;
import com.bofeng.dao.*;
import com.bofeng.entity.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
@Transactional(readOnly = true)
public class WxUserOpenService {

    @Autowired
    private HomeService homeService;
    @Autowired
    private UserRoleMapper userRoleMapper;
    @Autowired
    private UptownHouseMapper uptownHouseMapper;
    @Autowired
    private UptownHomeMapper uptownHomeMapper;
    @Autowired
    private OwnerMapper ownerMapper;
    @Autowired
    private OwnerLinkmanMapper ownerLinkmanMapper;
    @Autowired
    private SysUptownUnitMapper sysUptownUnitMapper;
    @Autowired
    private SysAreaMapper sysAreaMapper;
    @Autowired
    private UptownMapper uptownMapper;

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public Long createRole(Long isFamily, Long isYWH) throws Exception {
        if (isFamily == 0L && isYWH == 0L) {
            throw new Exception("请至少选择一个角色");
        }
        UserOpen userOpen = homeService.getUserOpen();
        if (userOpen == null) {
            throw new Exception("微信登录失败");
        }
        //判断该用户是否已经创建了角色
        List<UserRole> list = new ArrayList<>();
        if (userOpen.getUserId() > 0L) {
            list = userRoleMapper.getUserRoleByUserId(userOpen.getUserId());
        }
        if (list.size() > 0) {
            throw new Exception("角色已存在");
        }
        UserRole userRole = new UserRole();
        userRole.setUrId(IdWorker.getId());
        userRole.setUserId(userOpen.getUserId());
        userRole.setUserCreate(userOpen.getUserId());
        userRole.setUserUpdate(userOpen.getUserId());
        //根据页面勾选情况创建角色
        if (isFamily > 0L) {
            userRole.setRoleId(1);  //家庭用户
            userRoleMapper.insert(userRole);
        }
        if (isYWH > 0L) {
            userRole.setRoleId(2);  //业委会成员
            userRoleMapper.insert(userRole);
        }
        return userRole.getUserId();
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public Long createFamily(Long userId, Long unitId, String doorPlate, String linkMan, Integer helpNum, String phone) throws Exception {
        /** 创建家庭用户
         *  1.家庭用户填写电话号码后和ownerlinkman中该小区的电话做比对，如有则自动添加业委会成员角色
         *  2.
         * */
        Long sysUserId = queryUser(userId);

        //判断该用户是否已经创建了家庭用户角色
        List<UserRole> lstUserRole = new ArrayList<>();
        if (sysUserId > 0L) {
            lstUserRole = userRoleMapper.getUserRoleByUserId(sysUserId);
        }
        if (lstUserRole.size() > 0) {
            for (UserRole item : lstUserRole) {
                if (item.getRoleId() == 1L) {
                    throw new Exception("家庭用户角色已存在，请使用编辑功能");   //todo 暂时只允许一个用户角色绑定一个家庭门牌号
                }
            }
        }
        //创建家庭用户角色
        UserRole userRole = new UserRole();
        userRole.setUrId(IdWorker.getId());
        userRole.setUserId(sysUserId);
        userRole.setUserCreate(sysUserId);
        userRole.setUserUpdate(sysUserId);
        userRole.setRoleId(1);  //家庭用户

        //判断该门牌号是否被创建(该楼栋单元下)
        List<UptownHouse> lstUptownHouse = uptownHouseMapper.getUptownHouseBy(unitId, doorPlate);
        if (lstUptownHouse.size() > 0) {
            throw new Exception("当前单元下已有该门牌信息！");
        }
        UptownHouse uptownHouse = new UptownHouse();
        uptownHouse.setHouseId(IdWorker.getId());
        uptownHouse.setUnitId(unitId);
        uptownHouse.setDoorplate(doorPlate);
        uptownHouse.setStatus(1);
        if (uptownHouseMapper.insert(uptownHouse) != 1) {
            throw new Exception("创建门牌失败！");
        }
        userRole.setPropertyId(uptownHouse.getHouseId());   //绑定家庭用户角色的门牌id
        List<UptownHome> list = uptownHomeMapper.getUptownHomeByPhone(phone);
        if (list.size() > 0) {
            throw new Exception("该电话号码已被其他家庭用户注册使用！");
        }
        //判断该门牌是否存在家庭信息
        List<UptownHome> lstUptownHome = uptownHomeMapper.getUptownHomeBy(uptownHouse.getHouseId());
        if (lstUptownHome.size() > 0) {
            throw new Exception("该门牌已有人入住！");
        }
        UptownHome uptownHome = new UptownHome();
        uptownHome.setHouseId(uptownHouse.getHouseId());
        uptownHome.setLinkman(linkMan);
        uptownHome.setPhone(phone);
        uptownHome.setYoung(0);
        uptownHome.setMiddle(0);
        uptownHome.setOld(helpNum);
        uptownHome.setRemark("");
        uptownHome.setStatus(1);
        if (uptownHomeMapper.insert(uptownHome) != 1) {
            throw new Exception("创建家庭信息失败！");
        }
        userRoleMapper.insert(userRole);
        /** 判断是否增加业委会角色
         *  新增时根据所填家庭电话号码，去linkman表去找，如果存在且业委会小区和当前小区一致，则添加业委会角色
         *  找linkman的phone
         * */
        //查询小区id
        List<UptownUnit> lstUnit = sysUptownUnitMapper.selectByUnitId(unitId);
        if (lstUnit == null) {
            throw new Exception("小区不存在！");
        }
        if (lstUnit.size() != 1) {
            throw new Exception("小区数据异常！");
        }
        int phoneCount = 0;
        List<Owner> lstOwner = ownerMapper.getOwnerByUptownId(lstUnit.get(0).getUptownId());
        for (Owner item : lstOwner) {
            if (item.getPhone().equals(phone)) {
                phoneCount++;
            }
        }
        if (phoneCount > 1) {
            throw new Exception("电话号码在该小区业委会中存在多条记录，请联系客服！");
        }
        if (phoneCount == 1) {
            //如果是小区业委会成员，绑定业委会成员和用户id，新增业委会角色
            List<Owner> lst = ownerMapper.getOwnerByPhone(phone);
            if (lst == null) {
                throw new Exception("业委会联系电话数据异常");
            }
            if (lst.size() != 1) {
                throw new Exception("业委会联系电话数据重复");
            }
            if (lst.get(0).getUptownId() != lstUnit.get(0).getUptownId()) {
                throw new Exception("联系电话和所在小区不匹配");
            }
            lst.get(0).setUserId(sysUserId);
            lst.get(0).setUserUpdate(sysUserId);
            ownerMapper.updateById(lst.get(0));

            //增加业委会成员角色
            UserRole userRoleYWH = new UserRole();
            userRoleYWH.setUrId(IdWorker.getId());
            userRoleYWH.setUserId(sysUserId);
            userRoleYWH.setUserUpdate(sysUserId);
            userRoleYWH.setRoleId(2);   //业委会成员
            userRoleYWH.setPropertyId(lst.get(0).getOwnerId());
            userRoleMapper.insert(userRoleYWH);
        }

        return userRole.getUrId();
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public int createYWHRule(Long userId) throws Exception {
        /** 创建业委会资格
         *  1.当前用户有无家庭角色，无则退出
         *  2.小区已有业委会，退出
         * */
        Long sysUserId = queryUser(userId);
        List<UserRole> lstUserRole = new ArrayList<>();
        if (sysUserId > 0L) {
            lstUserRole = userRoleMapper.getUserRoleByUserId(sysUserId);
        }
        boolean hasFamily = false;
        Long myUptownId = 0L;
        Long myOwnerId = 0L;
        Long myHouseId = 0L;
        if (lstUserRole.size() > 0) {
            //判断该用户是否创建了业委会的角色
            for (UserRole item : lstUserRole) {
                if (item.getRoleId() == 1L) {
                    hasFamily = true;
                    myHouseId = item.getPropertyId();
                }
                if (item.getRoleId() == 2L) {
                    myOwnerId = item.getPropertyId();
                }
            }
        }
        if (!hasFamily) {
            throw new Exception("请先完善家庭地址！");
        }
        if (myHouseId == 0L) {
            throw new Exception("家庭地址中尚未生成门牌号！");
        }
        //根据门牌找小区id
        myUptownId = sysUptownUnitMapper.getUptownIdByHouseId(myHouseId);
        if (myUptownId == 0L) {
            throw new Exception("家庭所在小区未找到！");
        }
        //判断业委会是否已经建立
        List<Owner> lstSysOwner = ownerMapper.getOwnerByUptownId(myUptownId);
        if (lstSysOwner != null && lstSysOwner.size() > 0) {
            for (Owner item : lstSysOwner) {
                if (item.getUserId() == sysUserId && item.getType() == 1) {
                    //业委会负责人的绑定用户是自己
                    return 1;  //该小区已成立业委会，且业委会负责人的绑定用户是自己，可以进入编辑
//                    break;
                }
            }
            throw new Exception("小区业委会已建立，非业委会负责人不能编辑！");
        } else {
            return 1;  //该小区没有成立业委会，可以进入新增
        }
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public Long createYWH(Long userId, Long uptownId, List<Owner> lstOwner) throws Exception {
        /** 创建业委会
         *  0.流程上业委会负责人是第一个创建业委会的人
         *  1.在创建业委会之前，必须有家庭用户角色？
         *  2.小区已有业委会，不允许再创建业委会
         *  3.小区已有业委会，其他人不允许再进此页面
         *  4.业委会所在小区必须和当前用户的家庭用户所在小区一致
         * */
        Long sysUserId = queryUser(userId);
        Long myUptownId = 0L;
        Long myHouseId = 0L;
        if (uptownId <= 0L) {
            throw new Exception("小区id为空！");
        }
        Uptown uptown = uptownMapper.selectById(uptownId);
        if (uptown == null) {
            throw new Exception("小区不存在！");
        }
        //判断该用户是否已经创建了业委会角色
        List<UserRole> lstUserRole = new ArrayList<>();
        if (sysUserId > 0L) {
            lstUserRole = userRoleMapper.getUserRoleByUserId(sysUserId);
        }
        if (lstUserRole.size() > 0) {
            //判断该用户是否创建了业委会的角色
            for (UserRole item : lstUserRole) {
                if (item.getRoleId() == 2L) {
                    throw new Exception("业委会用户角色已存在！");   //todo 暂时只允许一个用户角色绑定一个业委会
                }
                if (item.getRoleId() == 1L) {

                    myHouseId = item.getPropertyId();
                }
            }
        }
        if (myHouseId == 0L) {
            throw new Exception("请先创建家庭用户！");
        }
        //根据门牌找小区id
        myUptownId = sysUptownUnitMapper.getUptownIdByHouseId(myHouseId);
        if (myUptownId == 0L) {
            throw new Exception("家庭所在小区未找到！");
        }
        if (myUptownId != uptownId) {
            throw new Exception("家庭所在小区和业委会所在小区不一致！");
        }
        //创建业委会用户角色
        UserRole userRole = new UserRole();
        userRole.setUrId(IdWorker.getId());
        userRole.setUserId(sysUserId);
        userRole.setUserCreate(sysUserId);
        userRole.setUserUpdate(sysUserId);
        userRole.setRoleId(2);  //业委会角色
        userRole.setStatus(0);  //需后台审核后变更为1

        //判断业委会是否已经建立
        List<Owner> lstSysOwner;
        if (uptownId > 0L) {
            lstSysOwner = ownerMapper.getOwnerByUptownId(uptownId);
            if (lstSysOwner != null && lstSysOwner.size() > 0) {
                throw new Exception("该小区已建立业委会");
            }
        }
        //建立业委会负责人和成员
        if (lstOwner == null) {
            throw new Exception("请新增业委会成员");
        }
        int masterNum = 0;
        for (Owner item : lstOwner) {
            if (item.getType() == 1L) {
                masterNum++;
            }
        }
        if (masterNum == 0) {
            throw new Exception("必须指定一个业委会负责人！");
        }
        if (masterNum != 1) {
            throw new Exception("业委会负责人只允许有一个！");
        }
        //判断业委会中的联系电话是否重复
        List<String> lstPhone = new ArrayList<>();
        for (Owner item : lstOwner) {
            if (!lstPhone.contains(item.getPhone())) {
                lstPhone.add(item.getPhone());
            }
        }
        if (lstPhone.size() != lstOwner.size()) {
            throw new Exception("联系电话有重复！");
        }
        for (Owner item : lstOwner) {
            item.setOwnerId(IdWorker.getId());
            item.setUptownId(uptownId);
            item.setUserCreate(sysUserId);
            item.setUserUpdate(sysUserId);
            if (item.getType() == 1L) {
                item.setUserId(sysUserId);  //业委会负责人绑定用户
                userRole.setPropertyId(item.getOwnerId()); //设置业委会id给角色的PropertyId
            }
            //新增时还需判断业委会中是否已存在该电话号码
            List<Owner> lst = ownerMapper.getOwnerByPhone(item.getPhone());
            if (lst != null && lst.size() > 1) {
                throw new Exception(item.getPhone() + "电话已被其他业委会使用！");
            }
            ownerMapper.insert(item);
        }
        userRoleMapper.insert(userRole);
        //业委会其他成员不创建userRole

        return userRole.getUrId();
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public List<UserRole> queryUserRoles(Long userId) throws Exception {
        //获取角色信息
        Long sysUserId = queryUser(userId);
        List<UserRole> lstUserRole = new ArrayList<>();
        if (sysUserId > 0L) {
            lstUserRole = userRoleMapper.getUserRoleByUserId(sysUserId);
        }
        if (lstUserRole.size() > 2) {
            throw new Exception("每个用户最多只能有两个角色");
        }
        for (int i = 0; i < lstUserRole.size(); i++) {
            //获取家庭角色的家庭信息
            if (lstUserRole.get(i).getRoleId() == 1L) {
                if (lstUserRole.get(i).getPropertyId() > 0L) {
                    UptownHome uptownHome = uptownHomeMapper.selectById(lstUserRole.get(i).getPropertyId());
                    if (uptownHome != null) {
                        UptownHouse uptownHouse = uptownHouseMapper.selectById(lstUserRole.get(i).getPropertyId());
                        if (uptownHouse == null) {
                            throw new Exception("门牌信息丢失");
                        }
                        uptownHome.setDoorplate(uptownHouse.getDoorplate());
                        Map<String, Long> map = new HashMap<>();
                        map.put("unitId", uptownHouse.getUnitId());     //栋单元
                        sysUptownUnit uptownUnit = sysUptownUnitMapper.selectById(uptownHouse.getUnitId());
                        if (uptownUnit == null || uptownUnit.getUptownId() == 0L) {
                            throw new Exception("单元中小区信息丢失");
                        }
                        map.put("uptownId", uptownUnit.getUptownId()); //小区
                        Uptown uptown = uptownMapper.selectById(uptownUnit.getUptownId());
                        if (uptown == null || uptown.getUptownId() == 0L) {
                            throw new Exception("小区信息丢失");
                        }
                        SysArea sysArea = sysAreaMapper.selectById(uptown.getArea());
                        map.put("areaId", sysArea.getAreaId());         //县区
                        SysArea sysCity = sysAreaMapper.selectById(sysArea.getAreaUp());
                        map.put("cityId", sysCity.getAreaId());         //城市
                        SysArea sysProvince = sysAreaMapper.selectById(sysCity.getAreaUp());
                        map.put("provinceId", sysProvince.getAreaId()); //省份
                        uptownHome.setLocation(map);
                        lstUserRole.get(i).setUptownHome(uptownHome);
                    }
                }
            }
            //获取业委会角色的业委会及其成员信息
            if (lstUserRole.get(i).getRoleId() == 2L) {
                if (lstUserRole.get(i).getPropertyId() > 0L) {
                    Owner owner = ownerMapper.selectById(lstUserRole.get(i).getPropertyId());
                    if (owner != null && owner.getOwnerId() > 0L) {
                        List<OwnerLinkman> lstOwnerLinkman = ownerLinkmanMapper.getOwnerLinkmanByOwnerId(owner.getOwnerId());
                        if (lstOwnerLinkman != null && lstOwnerLinkman.size() > 0) {
                            owner.setLstOwnerLinkman(lstOwnerLinkman);
                        }
                        lstUserRole.get(i).setOwner(owner);
                        Map<String, Long> map = new HashMap<>();
                        map.put("uptownId", owner.getUptownId());       //小区
                        Uptown uptown = uptownMapper.selectById(owner.getUptownId());
                        SysArea sysArea = sysAreaMapper.selectById(uptown.getArea());
                        map.put("areaId", sysArea.getAreaId());         //县区
                        SysArea sysCity = sysAreaMapper.selectById(sysArea.getAreaUp());
                        map.put("cityId", sysCity.getAreaId());         //城市
                        SysArea sysProvince = sysAreaMapper.selectById(sysCity.getAreaUp());
                        map.put("provinceId", sysProvince.getAreaId()); //省份
                        owner.setLocation(map);
                    }
                }
            }
        }
        return lstUserRole;
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public List<UptownHome> queryFamily(Long userId) throws Exception {
        Long sysUserId = queryUser(userId);
        Long userHouseId = 0L;
        int roleFamilyNum = 0;
        List<UserRole> lstUserRole = new ArrayList<>();
        if (sysUserId > 0L) {
            lstUserRole = userRoleMapper.getUserRoleByUserId(sysUserId);
        }
        if (lstUserRole.size() > 0) {
            for (UserRole item : lstUserRole) {
                if (item.getRoleId() == 1L) {
                    roleFamilyNum++;
                    userHouseId = item.getPropertyId();
                }
            }
        }
        if (roleFamilyNum == 0) {
            throw new Exception("尚未创建家庭角色");
        }
        if (roleFamilyNum > 1) {
            throw new Exception("该用户创建的家庭角色大于1个");
        }
        List<UptownHome> lstUptownHome = new ArrayList<>();
        if (userHouseId > 0L) {
            lstUptownHome = uptownHomeMapper.getUptownHomeBy(userHouseId);
        }
        return lstUptownHome;
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public Long queryUser(Long userId) throws Exception {
        //这里是为了调试方便，userId由前端传过来
        Long sysUserId = 0L;
        if (userId == null || userId == 0L) {
            UserOpen userOpen = homeService.getUserOpen();
            if (userOpen == null) {
                throw new Exception("微信登录失败");
            }
            sysUserId = userOpen.getUserId();
        } else {
            sysUserId = userId;
        }
        return sysUserId;
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public Long editFamily(Long userId, Long unitId, String doorPlate, String linkMan, Integer helpNum, String phone, Long urId) throws Exception {
        Long sysUserId = queryUser(userId);
        if (urId == 0L) {
            throw new Exception("尚未建立家庭用户角色,无法编辑");
        }
        UserRole userRole = userRoleMapper.selectById(urId);
        if (userRole == null) {
            throw new Exception("尚未建立家庭用户角色,无法编辑");
        }
        if (userRole.getRoleId() != 1L) {
            throw new Exception("当前角色不是家庭用户角色");
        }
        if (userRole.getUserId() != sysUserId) {
            throw new Exception("角色与当前用户不匹配");
        }
        if (userRole.getPropertyId() == 0L) {
            throw new Exception("【数据异常】角色尚未创建家庭");  //有家庭角色但没有家里家庭属于不正常的情况（在createFamily中应该一并创建）
        }
        //原小区、栋、单元、门牌
        UptownHouse uptownHouse = uptownHouseMapper.selectById(userRole.getPropertyId());
        if (uptownHouse == null) {
            throw new Exception("尚未创建门牌号");
        }
        if (uptownHouse.getUnitId() != unitId) {
            throw new Exception("小区选择后不允许修改");
        }
        if (uptownHouse.getDoorplate() != doorPlate) {
            //查找更换之后的单元、门牌是否被占用
            List<UptownHouse> lstUptownHouse = uptownHouseMapper.getUptownHouseBy(unitId, doorPlate);
            if (lstUptownHouse != null && lstUptownHouse.size() > 0) {
                throw new Exception("该小区单元下的门牌已被人注册！");
            }
            uptownHouse.setUnitId(unitId);
            uptownHouse.setDoorplate(doorPlate);
            uptownHouseMapper.updateById(uptownHouse);
        }
        UptownHome uptownHome = uptownHomeMapper.selectById(uptownHouse.getHouseId());
        if (uptownHome == null || uptownHome.getHouseId() == 0L) {
            throw new Exception("该门牌尚未填写家庭信息！");
        }
        uptownHome.setLinkman(linkMan);
        uptownHome.setPhone(phone);
        uptownHome.setOld(helpNum);
        uptownHomeMapper.updateById(uptownHome);

        return 1L;
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public Long editYWH(Long urId, Long userId, Long uptownId, List<OwnerLinkman> lstOwnerMan) throws Exception {
        Long sysUserId = queryUser(userId);
        if (urId == 0L) {
            throw new Exception("尚未建立家庭用户角色,无法编辑");
        }
        UserRole userRole = userRoleMapper.selectById(urId);
        if (userRole == null) {
            throw new Exception("尚未建立家庭用户角色,无法编辑");
        }
        if (userRole.getRoleId() != 2L) {
            throw new Exception("当前角色不是业委会角色");
        }
        if (userRole.getUserId() != sysUserId) {
            throw new Exception("角色与当前用户不匹配");
        }
        if (userRole.getPropertyId() == 0L) {
            throw new Exception("【数据异常】角色尚未创建家庭");  //有家庭角色但没有家里家庭属于不正常的情况（在createFamily中应该一并创建）
        }
        Owner owner = ownerMapper.selectById(userRole.getPropertyId());
        if (owner == null) {
            throw new Exception("尚未创建业委会");
        }
        if (owner.getUptownId() != uptownId) {
            //查找更换小区之后业委会是否被占用
            List<Owner> lstOwner = ownerMapper.getOwnerByUptownId(uptownId);
            if (lstOwner != null && lstOwner.size() > 0) {
                throw new Exception("该小区业委会已被人注册！");
            }
            owner.setUptownId(uptownId);
            ownerMapper.updateById(owner);
        }
        //修改业委会成员
        if (lstOwnerMan == null) {
            throw new Exception("请新增业委会成员");
        }
        int masterNum = 0;
        for (OwnerLinkman item : lstOwnerMan) {
            if (item.getType() == 1L) {
                masterNum++;
            }
        }
        if (masterNum != 1) {
            throw new Exception("业委会负责人只允许有一个");
        }
        for (OwnerLinkman item : lstOwnerMan) {
            if (item.getType() == 1L) {
                owner.setLinkman(item.getLinkman());
                owner.setPhone(item.getPhone());
            }
            item.setOwnerId(owner.getOwnerId());
            ownerLinkmanMapper.insert(item);
        }
        ownerMapper.insert(owner);

        return userRole.getUrId();
    }

}