package com.huiju.estateagents.service.impl;

import cn.binarywang.wx.miniapp.bean.WxMaUserInfo;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
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.huiju.estateagents.base.ResponseBean;
import com.huiju.estateagents.common.CommConstant;
import com.huiju.estateagents.common.DateUtils;
import com.huiju.estateagents.common.MD5Utils;
import com.huiju.estateagents.common.StringUtils;
import com.huiju.estateagents.entity.*;
import com.huiju.estateagents.mapper.*;
import com.huiju.estateagents.service.ITaPersonService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * <p>
 * 人员表 服务实现类
 * </p>
 *
 * @author jobob
 * @since 2019-05-10
 */
@Service
public class TaPersonServiceImpl extends ServiceImpl<TaPersonMapper, TaPerson> implements ITaPersonService {

    @Autowired
    TaPersonMapper taPersonMapper;

    @Autowired
    TaPersonSignMapper taPersonSignMapper;

    @Autowired
    TaUvMapper taUvMapper;

    @Autowired
    TaFavorMapper taFavorMapper;

    @Autowired
    TaPersonBuildingMapper taPersonBuildingMapper;

    @Autowired
    TaRecommendCustomerMapper taRecommendCustomerMapper;

    @Autowired
    TaChatMapper taChatMapper;
    
    @Autowired
    private TdPointsRulesMapper tdPointsRulesMapper;
    
    @Autowired
    private TaPointsRecordsMapper taPointsRecordsMapper;

    @Override
    public TaPerson mergePersonWxInfo(WxMaUserInfo userInfo) {
        // 先查询是否存在用户
        String openid = userInfo.getOpenId();
        List<TaPerson> persons = taPersonMapper.getPersonByOpenId(openid);

        if (null == persons || persons.size() != 1) {
//            // 没有则插入新记录
//            person = new TaPerson();
//            person.setMiniOpenid(openid);
//            person.setNickname(userInfo.getNickName());
//            person.setAvatarurl(userInfo.getAvatarUrl());
//            person.setStatus(CommConstant.STATUS_NORMAL);
//            person.setCreateDate(LocalDateTime.now());
//            person.setIsSignup(CommConstant.STATUS_NORMAL);
//
//            if (taPersonMapper.insert(person) > 0) {
//                return person;
//            }
            return null;
        } else {
            // 否则更新
            TaPerson person = persons.get(0);
            UpdateWrapper<TaPerson> wrapper = new UpdateWrapper<>();
            wrapper.eq("mini_openid", openid);
            wrapper.set("nickname", userInfo.getNickName());
            wrapper.set("avatarurl", userInfo.getAvatarUrl());
            taPersonMapper.update(person, wrapper);

            person.setAvatarurl(userInfo.getAvatarUrl());
            person.setNickname(userInfo.getNickName());

            return person;
        }
    }

    @Override
    public TaPerson updatePersonPhone(String miniOpenid, String phone) {
        // 先查询是否存在用户
        TaPerson person = null;
        List<TaPerson> taPersons = getPersonsByOpenId(miniOpenid);
        if (null != taPersons && taPersons.size() > 0) {
            person = taPersons.get(0);
        }

        if (null == person) {
            // 发生了未知错误
            return null;
        }

//        if (null == phone || "".equals(phone)) {
//            return null;
//        }

        String tel = person.getTel();

        UpdateWrapper<TaPerson> wrapper = new UpdateWrapper<>();
        wrapper.set("phone", phone);
        wrapper.set("person_type",CommConstant.PERSON_ESTATE_AGENT);
//        wrapper.set(null == tel || "".equals(tel), "tel", phone);
        wrapper.eq("mini_openid", miniOpenid);
//        wrapper.eq("person_type",null);
        wrapper.isNull("person_type");
        taPersonMapper.update(new TaPerson(), wrapper);

        person.setPhone(phone);
        if (null == tel || "".equals(tel)){
            person.setTel(phone);
        }
    
        //查看是否领取过授权积分
        QueryWrapper<TaPointsRecords> taPointsRecordsQueryWrapper = new QueryWrapper<>();
        taPointsRecordsQueryWrapper.eq("change_type",CommConstant.POINTS_AUTHORIZE);
        taPointsRecordsQueryWrapper.like("change_params","%\""+person.getPersonId()+"\"%");
        List<TaPointsRecords> taPointsRecordsList = taPointsRecordsMapper.selectList(taPointsRecordsQueryWrapper);
        if (taPointsRecordsList.size() < 0){
            //发放积分
            QueryWrapper<TdPointsRules> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("rule_id",2);
            queryWrapper.eq("status",CommConstant.STATUS_NORMAL);
            TdPointsRules tdPointsRules = tdPointsRulesMapper.selectOne(queryWrapper);
            if (null != tdPointsRules) {
                //插入积分消费流水表
                TaPointsRecords taPointsRecords = new TaPointsRecords();
                taPointsRecords.setPersonId(person.getPersonId());
                taPointsRecords.setPersonName(com.huiju.estateagents.common.StringUtils.ifNull(person.getName(),person.getNickname()));
                taPointsRecords.setPersonType(person.getPersonType());
                taPointsRecords.setPointsAmount(tdPointsRules.getPointsAmount());
                taPointsRecords.setChangeType(CommConstant.POINTS_AUTHORIZE);
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("person_id",person.getPersonId());
                taPointsRecords.setChangeParams(jsonObject.toJSONString());
                taPointsRecords.setCreateDate(LocalDateTime.now());
                taPointsRecords.setStatus(CommConstant.STATUS_NORMAL);
                taPointsRecordsMapper.insert(taPointsRecords);
                //添加积分
                UpdateWrapper<TaPerson> taPersonwrapper = new UpdateWrapper<>();
                wrapper.eq("person_id", person.getPersonId());
                wrapper.setSql("points = IFNULL(points, 0) + " + String.valueOf(tdPointsRules.getPointsAmount()));
                taPersonMapper.update(new TaPerson(), taPersonwrapper);
            }
        }

        return person;
    }

    @Override
    public IPage<Map<String, Object>> getCardList(int pageNumber, int pageSize) {
        Page<Map<String, Object>> page = new Page<>();
        page.setSize(pageSize);
        page.setPages(pageNumber);
        page.setCurrent(pageNumber);

        List<Map<String, Object>> result = taPersonMapper.selectCardList(page, CommConstant.PERSON_REALTY_CONSULTANT, CommConstant.STATUS_NORMAL);
        page.setRecords(result);

        return page;
    }

    @Override
    public ResponseBean checkPhoneAndPass(String phone, String pass) {
        QueryWrapper<TaPerson> query = new QueryWrapper<>();
        query.eq("tel", phone);
        query.eq("person_type", CommConstant.PERSON_REALTY_CONSULTANT);

        List<TaPerson> result = taPersonMapper.selectList(query);
        if (null == result || result.size() == 0) {
            return ResponseBean.error("数据异常: 电话号码不存在", ResponseBean.ERROR_UNAVAILABLE);
        }

        if (result.size() > 1) {
            return ResponseBean.error("数据异常: 电话记录重复, 或者重复绑定不同人员", ResponseBean.ERROR_UNAVAILABLE);
        }

        TaPerson person = result.get(0);
        if (person.getStatus() != CommConstant.STATUS_NORMAL) {
            return ResponseBean.error("数据异常: 该置业可能被禁用", ResponseBean.ERROR_UNAVAILABLE);
        }

        // todo
        // 验证密码

        return ResponseBean.success(person);
    }

    @Override
    public ResponseBean getCardDetail(String openid, String id) {
        // 卡片人员
        TaPerson person = taPersonMapper.selectById(id);
        if (null == person) {
            return ResponseBean.success("");
        }

        if (person.getStatus() != CommConstant.STATUS_NORMAL) {
            return ResponseBean.error("数据异常: 该数据可能被禁用", ResponseBean.ERROR_UNAVAILABLE);
        }

        // 获取访问记录
        List<Map<String, Object>> visitors = taUvMapper.getLastVisitors(CommConstant.FAVOR_CONSULTANT, person.getPersonId(), 10);

        // 获取关联项目
        List<TaPersonBuilding> buildingList = getPersonBuildings(person.getPersonId());
        List<String> buildings = new ArrayList<>();
        if (null != buildingList && buildingList.size() > 0) {
            for(TaPersonBuilding b: buildingList) {
                buildings.add(b.getBuildingId());
            }
        }

        Map<String, Object> result = new HashMap<>();
        result.put("id", person.getPersonId());
        result.put("name", person.getName());
        result.put("company", person.getCompany());
        result.put("department", person.getDepartment());
        result.put("picture", person.getPhoto());
        result.put("hotNum", person.getHotNum());
        result.put("likeNum", person.getLikeNum());
        result.put("pvNum", person.getPvNum());
        result.put("post", person.getPost());
        result.put("phone", person.getTel());
        result.put("avatar", person.getAvatarurl());
        result.put("visitors", visitors);
        result.put("liked", false);
        result.put("unReadNum", 0);
        result.put("projects", buildings);
        result.put("address", person.getAddress());
        result.put("personTags",person.getPersonTags());

        // 当前人员
        List<TaPerson> taPersonList = getPersonsByOpenId(openid);
        if (null == taPersonList || taPersonList.size() != 1) {
            return ResponseBean.error("验证当前人员信息失败", ResponseBean.ERROR_UNAVAILABLE);
        }
        TaPerson currentPerson = taPersonList.get(0);
        if (!currentPerson.getPersonId().equals(person.getPersonId())) {
            // 如果不是请求当前人员的卡片, 那么验证下当前人员是否对卡片人员点过赞
            List<TaFavor> taUvList = getFavorListBy(currentPerson, person);
            result.put("liked", null != taUvList && taUvList.size() > 0);

            // 获取未读消息数量
            Integer unReadNum = taChatMapper.getUnReadMessage(person.getPersonId(), currentPerson.getPersonId());
            result.put("unReadNum", null == unReadNum ? 0 : unReadNum);
        } else {
            result.put("liked", true);
            Integer unReadNum = taChatMapper.getAllUnReadMessage(person.getPersonId());
            result.put("unReadNum", null == unReadNum ? 0 : unReadNum);
        }

        return ResponseBean.success(result);
    }

    @Override
    public ResponseBean resgiteAgent(String name, String phone, Integer sex, String explain, String openid) {
        List<TaPerson> taPersons = getPersonsByOpenId(openid);
        if (null == taPersons || taPersons.size() != 1) {
            return ResponseBean.error("验证当前人员信息失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        TaPerson taPerson = taPersons.get(0);
        if (taPerson.getSignupStatus() == CommConstant.STATUS_NORMAL) {
            return ResponseBean.error("请不要重复注册", ResponseBean.ERROR_ILLEGAL_PARAMS);
        }

        taPerson.setTel(phone);
        taPerson.setName(name);
        taPerson.setSex(sex);
        taPerson.setRemark(explain);
        taPerson.setCreateDate(LocalDateTime.now());
        taPerson.setStatus(CommConstant.STATUS_NORMAL);
        taPerson.setPersonType(CommConstant.PERSON_ESTATE_AGENT);
        taPerson.setSignupStatus(CommConstant.STATUS_NORMAL);

        return ResponseBean.success(taPerson);
    }

    @Override
    public ResponseBean getWxUser(String openid) {
        List<TaPerson> taPersons = getPersonsByOpenId(openid);
        if (null == taPersons || taPersons.size() != 1) {
            return ResponseBean.error("验证当前人员信息失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        TaPerson taPerson = taPersons.get(0);
        Map<String, Object> result = new HashMap<>();
        result.put("id", taPerson.getPersonId());
        result.put("name", taPerson.getName());
        result.put("nickname", taPerson.getNickname());
        result.put("avatar", taPerson.getAvatarurl());
        result.put("sex", taPerson.getSex());
        result.put("phone", taPerson.getTel());
        result.put("points", taPerson.getPoints());

       // 查询最早的签到记录
        TaPersonSign taPersonSign = taPersonSignMapper.getLastSignRecord(taPerson.getPersonId());
        int havaSigned =  null == taPersonSign || !DateUtils.sameDay(LocalDateTime.now(), taPersonSign.getSignDate()) ? 0 : 1;

        result.put("havaSigned", havaSigned);

        // 查詢我的客戶數量
        Integer customerNum = taRecommendCustomerMapper.getMyCutsomerNum(taPerson.getPersonId());
        result.put("customerNum", customerNum);

        // 收藏數
        // todo
        result.put("saved", 0);

        return ResponseBean.success(result);
    }

    @Override
    public ResponseBean getWxUserSign(String openid) {
        List<TaPerson> taPersons = getPersonsByOpenId(openid);
        if (null == taPersons || taPersons.size() != 1) {
            return ResponseBean.error("验证当前人员信息失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        TaPerson taPerson = taPersons.get(0);
        TaPersonSign taPersonSign = taPersonSignMapper.getLastSignRecord(taPerson.getPersonId());
        boolean todaySigned =  null != taPersonSign && DateUtils.sameDay(LocalDateTime.now(), taPersonSign.getSignDate());
        boolean yestodaySigned = null != taPersonSign && DateUtils.sameDay(LocalDateTime.now().minusDays(1), taPersonSign.getSignDate());

        if (todaySigned) {
            return ResponseBean.error("请不要重复签到", ResponseBean.ERROR_ILLEGAL_PARAMS);
        }

        int durationDays = !yestodaySigned ? 1 : taPersonSign.getDurationDays() + 1;

        TaPersonSign sign = new TaPersonSign();
        sign.setPersonId(taPerson.getPersonId());
        sign.setSignDate(LocalDateTime.now());
        sign.setDurationDays(durationDays);

        int row = taPersonSignMapper.insert(sign);
        if (row <= 0) {
            return ResponseBean.error("签到失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        // 增加积分
        // 1-7 天积分 1-7, 超过7天按 7 个积分算
        int points = durationDays >= 7 ? 7 : durationDays;
        //签到获取积分
        //TdPointsRules tdPointsRules = tdPointsRulesMapper.selectById(1);
        //int points = tdPointsRules.getPointsAmount();
        UpdateWrapper<TaPerson> wrapper = new UpdateWrapper<>();
        wrapper.eq("person_id", taPerson.getPersonId());
        wrapper.setSql("points = IFNULL(points, 0) + " + String.valueOf(points));
//        wrapper.set("points", "points + " + String.valueOf(points));
        taPersonMapper.update(new TaPerson(), wrapper);
        
        //插入积分消费流水表
        TaPointsRecords taPointsRecords = new TaPointsRecords();
        taPointsRecords.setPersonId(taPerson.getPersonId());
        taPointsRecords.setPersonName(StringUtils.ifNull(taPerson.getName(),taPerson.getNickname()));
        taPointsRecords.setPersonType(taPerson.getPersonType());
        taPointsRecords.setPointsAmount(points);
        taPointsRecords.setChangeType(CommConstant.POINTS_CHECKIN);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("person_id",taPerson.getPersonId());
        taPointsRecords.setChangeParams(jsonObject.toJSONString());
        taPointsRecords.setCreateDate(LocalDateTime.now());
        taPointsRecords.setStatus(CommConstant.STATUS_NORMAL);
        taPointsRecordsMapper.insert(taPointsRecords);

        Map<String, Object> result = new HashMap<>();

        Integer oldPoints = taPerson.getPoints();
        if (null == oldPoints) oldPoints = 0;

        result.put("integral", oldPoints + points);
        return ResponseBean.success(result, "签到成功");
    }

    @Override
    public TaPerson getPersonByTel(String userPhone) {
        QueryWrapper<TaPerson> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("tel", userPhone);

        List<TaPerson> taPersonList = taPersonMapper.selectList(queryWrapper);
        if (null == taPersonList || taPersonList.size() == 0) return null;

        return taPersonList.get(0);
    }

    @Override
    public IPage<TaPerson> getPersonList(int pageNumber, int pageSize, String personType, String name, String phone) {
        QueryWrapper<TaPerson> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(!StringUtils.isEmpty(personType), "person_type", personType);
        queryWrapper.like(!StringUtils.isEmpty(name), "name", name);
        queryWrapper.like(!StringUtils.isEmpty(phone), "tel", phone);

        IPage<TaPerson> page = new Page<>(pageNumber, pageSize);
        return taPersonMapper.selectPage(page, queryWrapper);
    }

    @Override
    public TaPerson newPersonByOpenid(String openid) {
        List<TaPerson> taPersons = getPersonsByOpenId(openid);
        if (null == taPersons || taPersons.size() != 1) {
            TaPerson taPerson = new TaPerson();
            taPerson.setMiniOpenid(openid);
            taPerson.setNickname("匿名用户");
            taPerson.setAvatarurl(CommConstant.MINIAPP_DEFAULT_AVATAR);
            taPerson.setStatus(CommConstant.STATUS_NORMAL);
            taPerson.setCreateDate(LocalDateTime.now());
            if (taPersonMapper.insert(taPerson) > 0) {
                return taPerson;
            }
        } else {
            return taPersons.get(0);
        }

        return null;
    }

    @Override
    public ResponseBean bindCard(String phone, String pass, String openid) {

        QueryWrapper<TaPerson> query = new QueryWrapper<>();
        query.eq("tel", phone);

        // 可能不仅仅只置业, 只要后台有的，应该都可以绑定
//        query.eq("person_type", CommConstant.PERSON_REALTY_CONSULTANT);

        List<TaPerson> result = taPersonMapper.selectList(query);
        if (result == null || result.size() != 1) {
            return ResponseBean.error("数据异常: 电话记录重复", ResponseBean.ERROR_UNAVAILABLE);
        }

        TaPerson person = result.get(0);
        if (person.getStatus() != CommConstant.STATUS_NORMAL) {
            return ResponseBean.error("数据异常: 该置业可能被禁用", ResponseBean.ERROR_UNAVAILABLE);
        }

        //
        List<TaPerson> crus = getPersonsByOpenId(openid);
        TaPerson current = crus.get(0);

        // 绑卡操作
        // 如果是同一个人, 不操作
        if (current.getPersonId().equals(person.getPersonId())) {
            return ResponseBean.success("");
        }

        // 如果不是同一个人, 把 current 的信息更新到 person 上, 但是 personId 不变
        // 同时把 person 信息置为不可用

        UpdateWrapper<TaPerson> up2 = new UpdateWrapper<>();
        up2.set("mini_openid", ""); // openid 更新为空, 避免多用户问题
        up2.set("status", CommConstant.STATUS_DELETE); // 人员置为已删除
        up2.set("remark", person.getPersonId()); // 备注里面填写被合并到的人员ID
        up2.set("person_id", current.getPersonId() + "-bak"); // 变更主键
        up2.eq("person_id", current.getPersonId());

        if (taPersonMapper.update(new TaPerson(), up2) < 1) {
            return ResponseBean.error("绑定卡片, 清除无效数据失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        UpdateWrapper<TaPerson> up1 = new UpdateWrapper<>();
        up1.set("mini_openid", current.getMiniOpenid());
        up1.set("nickname", current.getNickname());
        up1.set("avatarurl", current.getAvatarurl());
        up1.set("phone", current.getPhone());
        up1.set("person_id", current.getPersonId());  // 变更主键
        up1.eq("person_id", person.getPersonId());

        if (taPersonMapper.update(new TaPerson(), up1) < 1) {
            return ResponseBean.error("绑定卡片失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        // 变更授权项目, 从 current 变更到 person
        UpdateWrapper<TaPersonBuilding> up3 = new UpdateWrapper<>();
        up3.set("person_id", current.getPersonId());
        up3.eq("person_id", person.getPersonId());

        if (taPersonBuildingMapper.update(new TaPersonBuilding(), up3) < 1) {
            return ResponseBean.error("绑定卡片失败", ResponseBean.ERROR_UNAVAILABLE);
        }

        return ResponseBean.success(current.getPersonId());
    }

    @Override
    public ResponseBean newConsultant(String paramStr) {
        TaPerson taPerson = JSONObject.parseObject(paramStr, TaPerson.class);
        taPerson.setCreateDate(LocalDateTime.now());
        taPerson.setPersonType(CommConstant.PERSON_REALTY_CONSULTANT);

        if (taPersonMapper.insert(taPerson) > 0) {
            // 授权项目
            addConsultantBuildings(taPerson.getPersonId(), paramStr);

            return ResponseBean.success(taPerson);
        }

        return ResponseBean.error("新增信息失败", ResponseBean.ERROR_UNAVAILABLE);
    }

    @Override
    public ResponseBean editConsultant(String id, String paramStr) {
        TaPerson taPerson = JSONObject.parseObject(paramStr, TaPerson.class);
        taPerson.setPersonId(id);

        // 授权项目
        addConsultantBuildings(id, paramStr);

        if (taPersonMapper.updateById(taPerson) > 0) {
            return ResponseBean.success("更新信息成功");
        }

        return ResponseBean.error("更新信息失败", ResponseBean.ERROR_UNAVAILABLE);
    }

    @Override
    public Map<String, Object> getExtraInfo(String personId) {
        Map<String, Object> result = new HashMap<>();

        // 查询最早的签到记录
        TaPersonSign taPersonSign = taPersonSignMapper.getLastSignRecord(personId);
        int havaSigned =  null == taPersonSign || !DateUtils.sameDay(LocalDateTime.now(), taPersonSign.getSignDate()) ? 0 : 1;
        result.put("havaSigned", havaSigned);

        // 查询我的客户记录
        Integer customerNum = taRecommendCustomerMapper.getMyCutsomerNum(personId);
        result.put("customerNum", null == customerNum ? 0 : customerNum.intValue());

        return result;
    }

    public void addConsultantBuildings(String personId, String paramStr) {
        JSONObject params = JSONObject.parseObject(paramStr);
        String building = params.getString("buildings");
//        JSONArray buildings = params.getJSONArray("buildings");

//        if (null != buildings && !buildings.isEmpty()) {
            // 先删除原来授权楼栋
            QueryWrapper<TaPersonBuilding> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("person_id", personId);
            taPersonBuildingMapper.delete(queryWrapper);

            // 再插入新的授权
//            for (Object b : buildings) {
                TaPersonBuilding taPersonBuilding = new TaPersonBuilding();
//                taPersonBuilding.setBuildingId(b.toString());
                taPersonBuilding.setBuildingId(building);
                taPersonBuilding.setPersonId(personId);
                taPersonBuilding.setCreateDate(LocalDateTime.now());
                taPersonBuildingMapper.insert(taPersonBuilding);
//            }
//        }
    }

    @Override
    public ResponseBean resetPassword(String phone, String pass, String plat) {
        // todo 待修复 三目表达式
        String personType = "wx".equals(plat) ? CommConstant.PERSON_REALTY_CONSULTANT : "";

        QueryWrapper<TaPerson> query = new QueryWrapper<>();
        query.eq("tel", phone);
        query.eq("person_type", personType);

        List<TaPerson> result = taPersonMapper.selectList(query);
        if (result.size() > 1) {
            return ResponseBean.error("数据异常: 电话记录重复", ResponseBean.ERROR_UNAVAILABLE);
        }

        TaPerson person = result.get(0);
        if (person.getStatus() != CommConstant.STATUS_NORMAL) {
            return ResponseBean.error("数据异常: 该置业可能被禁用", ResponseBean.ERROR_UNAVAILABLE);
        }

        String newPass = MD5Utils.md5(pass, person.getPersonId());

        UpdateWrapper<TaPerson> wrapper = new UpdateWrapper<>();
        wrapper.set("password", newPass);
        wrapper.eq("person_id", person.getPersonId());

        taPersonMapper.update(new TaPerson(), wrapper);
        return ResponseBean.success("");
    }

    // from 给 to 点赞
    List<TaFavor> getFavorListBy(TaPerson from, TaPerson to) {
        QueryWrapper<TaFavor> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("person_id", from.getPersonId());
        queryWrapper.eq("be_favor", to.getPersonId());
        queryWrapper.eq("tagert_type", CommConstant.FAVOR_CONSULTANT);

        return taFavorMapper.selectList(queryWrapper);
    }

    @Override
    public List<TaPerson> getPersonsByOpenId(String openid) {
        return taPersonMapper.getPersonByOpenId(openid);
    }

    List<TaPersonBuilding> getPersonBuildings(String personId) {
        QueryWrapper<TaPersonBuilding> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("person_id", personId);
        return taPersonBuildingMapper.selectList(queryWrapper);
    }

    @Override
    public IPage<TaPerson> getDriftCustomerList (int pageNumber, int pageSize,String building){
        QueryWrapper<TaPerson> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("person_type");
        if(building.equals("") && null != building){
            queryWrapper.eq("building_id",building);
        }
        IPage<TaPerson> page = new Page<>(pageNumber, pageSize);
        return taPersonMapper.selectPage(page,queryWrapper);
    }

    @Override
    public String getPersonIdByCustomerId(String customerId){
        return taRecommendCustomerMapper.getCustomerPersonId(customerId);
    }
}