package com.xzx.gc.user.service;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.comparator.PropertyComparator;
|
import cn.hutool.core.convert.Convert;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.util.ReUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.hutool.extra.emoji.EmojiUtil;
|
import com.github.pagehelper.PageInfo;
|
import com.xzx.gc.common.Result;
|
import com.xzx.gc.common.constant.Constants;
|
import com.xzx.gc.common.constant.UserEnum;
|
import com.xzx.gc.common.dto.gdmap.*;
|
import com.xzx.gc.common.exception.RestException;
|
import com.xzx.gc.common.utils.BusinessUtil;
|
import com.xzx.gc.common.utils.ExceptionUtils;
|
import com.xzx.gc.common.utils.StringUtils;
|
import com.xzx.gc.common.utils.gdmap.GdMapUtil;
|
import com.xzx.gc.entity.AddressInfo;
|
import com.xzx.gc.entity.AddressLevelInfo;
|
import com.xzx.gc.entity.OrderInfo;
|
import com.xzx.gc.entity.UserInfo;
|
import com.xzx.gc.model.admin.LongiLatiModel;
|
import com.xzx.gc.model.user.AddressReq;
|
import com.xzx.gc.model.user.AddressVo;
|
import com.xzx.gc.user.mapper.*;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.BeansException;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import tk.mybatis.mapper.common.base.update.UpdateByPrimaryKeySelectiveMapper;
|
import tk.mybatis.mapper.entity.Example;
|
|
import javax.servlet.http.HttpServletRequest;
|
import javax.xml.ws.soap.Addressing;
|
import java.util.List;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
@Service
|
@Slf4j
|
@Transactional
|
public class AddressService{
|
@Autowired
|
AddressMapper addressMapper;
|
|
@Autowired
|
private UserTargetInfoService userTargetInfoService;
|
|
@Autowired
|
private HttpServletRequest request;
|
|
|
@Autowired
|
private BusinessUtil businessUtil;
|
|
@Autowired
|
private AddressLevelService addressLevelService;
|
|
|
@Autowired
|
private AddressLevelMapper addressLevelInfoMapper;
|
|
@Autowired
|
private OrderMapper orderMapper;
|
|
@Autowired
|
private UserService userService;
|
|
|
/**
|
* 根据经纬度获取省市区
|
* @param lon
|
* @param lan
|
* @return
|
*/
|
public AddressInfo getByLon(String lon,String lan) {
|
GdReverseGEODto gdReverseGEODto = new GdReverseGEODto();
|
gdReverseGEODto.setLocation(lon + "," + lan);
|
Result areaInfo = GdMapUtil.getAreaInfo(gdReverseGEODto, 0);
|
if (areaInfo.getCode() == 0) {
|
AddressInfo addressInfo1 = (AddressInfo) areaInfo.getData();
|
AddressLevelInfo addressLevelInfo = new AddressLevelInfo();
|
addressLevelInfo.setAdcode(addressInfo1.getAdcode());
|
AddressLevelInfo addressLevelInfo1 = addressLevelInfoMapper.selectOne(addressLevelInfo);
|
if(addressLevelInfo1!=null) {
|
addressInfo1.setTownshipId(addressLevelInfo1.getLevel3Id());
|
addressInfo1.setProvinceId(addressLevelInfo1.getLevel1Id());
|
addressInfo1.setCityId(addressLevelInfo1.getLevel2Id());
|
return addressInfo1;
|
}
|
}
|
return null;
|
}
|
|
|
public void add(AddressInfo addressInfo){
|
addressInfo.setDelFlag(Constants.DEL_NOT_FLAG+"");
|
addressInfo.setCreateTime(DateUtil.now());
|
addressMapper.insertSelective(addressInfo);
|
}
|
|
public long addressAdd(AddressReq addressReq) {
|
long returnvalue= 0;
|
try {
|
|
addressReq.setDetailAddress(StringUtils.cleanStr(addressReq.getDetailAddress()));
|
//若从微信取的地址则自动转换经纬度
|
if(StrUtil.isBlank(addressReq.getLatitude())){
|
GdGEODto gdGEODto=new GdGEODto();
|
if(StrUtil.isNotBlank(addressReq.getCityName())) {
|
gdGEODto.setCity(addressReq.getCityName());
|
}
|
gdGEODto.setAddress(addressReq.getAddressArea()+addressReq.getDetailAddress());
|
Result locationByAddress = GdMapUtil.getLocationByAddress(gdGEODto);
|
if(locationByAddress.getCode()==0&&locationByAddress.getData()!=null){
|
addressReq.setLongitude(locationByAddress.getData().toString().split(",")[0]);
|
addressReq.setLatitude(locationByAddress.getData().toString().split(",")[1]);
|
}
|
}
|
|
if(StrUtil.isBlank(addressReq.getLatitude())){
|
throw new RestException(-1,"地址经纬度获取失败");
|
}
|
|
|
AddressInfo addressInfo = new AddressInfo();
|
BeanUtils.copyProperties(addressReq, addressInfo);
|
//获取省市区ID
|
completeAddress(addressReq, addressInfo);
|
|
String userId = request.getHeader("userId");
|
addressInfo.setDelFlag(Convert.toStr(Constants.DEL_NOT_FLAG));
|
changeLocation(addressInfo);
|
addressInfo.setUserId(userId);
|
addressInfo.setCreateTime(DateUtil.now());
|
addressInfo.setFlag(UserEnum.默认地址.getValue());
|
//修改用户的所有地址为非默认
|
updateByUserIdSetNoDefault(userId);
|
addressMapper.insertSelective(addressInfo);
|
|
returnvalue=addressInfo.getAddressId();
|
//修改意向客户的地址 来源是新增地址时
|
if(addressReq.getOrigin()==0) {
|
userTargetInfoService.updateTargetUserAddr(addressInfo);
|
}
|
|
//判断地址是属于哪个围栏 从而获取合伙人ID
|
// fenceService.findByPartnerId()
|
|
|
} catch (BeansException e) {
|
ExceptionUtils.err("新增地址失败",e);
|
}
|
|
|
return returnvalue;
|
}
|
|
/**
|
* 替换经纬度 填补省市区
|
* @param addressInfo
|
*/
|
public void changeLocation(AddressInfo addressInfo) {
|
GdPOIDto gdGEODto=new GdPOIDto();
|
gdGEODto.setKeywords(StrUtil.emptyToDefault(addressInfo.getAddressArea(),"")+StrUtil.emptyToDefault(addressInfo.getDetailAddress(),""));
|
//替换地址表的省市区ID
|
if(StrUtil.isBlank(addressInfo.getProvinceId())){
|
addressInfo = GdMapUtil.getLocationByPOI(gdGEODto, addressInfo);
|
AddressReq addressReq = new AddressReq();
|
addressReq.setProvinceName(addressInfo.getProvinceName());
|
addressReq.setCityName(addressInfo.getCityName());
|
addressReq.setTownshipName(addressInfo.getTownshipName());
|
List<AddressVo> addressLevelList = addressMapper.queryAreaIdByName(addressReq);
|
if (addressLevelList != null && addressLevelList.size() > 0) {
|
String provinceId = addressLevelList.get(0).getProvinceId();
|
addressInfo.setProvinceId(provinceId);
|
String cityId = addressLevelList.get(0).getCityId();
|
addressInfo.setCityId(cityId);
|
String townshipId = addressLevelList.get(0).getTownshipId();
|
addressInfo.setTownshipId(townshipId);
|
}
|
}
|
}
|
|
private void getProvinceAndCityId(AddressReq addressReq, AddressInfo addressInfo) {
|
if(StrUtil.isNotBlank(addressReq.getTownshipName())){
|
addressReq.setTownshipName( businessUtil.changeArea(addressReq.getTownshipName()));
|
}
|
List<AddressVo> addressLevelList= addressMapper.queryAreaIdByName(addressReq);
|
if (addressLevelList != null && addressLevelList.size() > 0){
|
String provinceId = addressLevelList.get(0).getProvinceId();
|
String cityId = addressLevelList.get(0).getCityId();
|
String townshipId = addressLevelList.get(0).getTownshipId();
|
String citycode = addressLevelList.get(0).getCitycode();
|
String adcode = addressLevelList.get(0).getAdcode();
|
String pcode = addressLevelList.get(0).getPcode();
|
addressInfo.setProvinceId(provinceId);
|
addressInfo.setCityId(cityId);
|
addressInfo.setTownshipId(townshipId);
|
//用于poi筛选
|
addressInfo.setCityName(addressReq.getCityName());
|
addressInfo.setCitycode(citycode);
|
addressInfo.setAdcode(adcode);
|
addressInfo.setPcode(pcode);
|
addressReq.setProvinceId(provinceId);
|
addressReq.setCityId(cityId);
|
addressReq.setTownshipId(townshipId);
|
}
|
}
|
|
|
|
public void addressModify(AddressReq addressReq) {
|
try {
|
addressReq.setDetailAddress(StringUtils.cleanStr(addressReq.getDetailAddress()));
|
AddressInfo addressInfo = new AddressInfo();
|
BeanUtils.copyProperties(addressReq, addressInfo);
|
//当某一地址设为默认时,其它地址为非默认
|
if (UserEnum.默认地址.getValue().equals(addressReq.getFlag())){
|
addressMapper.updateAddressFlag(addressReq);
|
}
|
|
//获取省市区ID
|
completeAddress(addressReq, addressInfo);
|
|
changeLocation(addressInfo);
|
|
|
//查询地址修改是否跨区 跨区则删除当前地址新增地址
|
AddressInfo addressInfo1 = addressMapper.selectByPrimaryKey(addressInfo.getAddressId());
|
String townshipId = addressInfo1.getTownshipId();
|
if(!townshipId.equals(addressInfo.getTownshipId())){
|
deleteById(addressInfo.getAddressId());
|
AddressInfo obj=new AddressInfo();
|
BeanUtil.copyProperties(addressInfo,obj);
|
obj.setAddressId(null);
|
obj.setDelFlag(Constants.DEL_NOT_FLAG+"");
|
obj.setCreateTime(DateUtil.now());
|
addressMapper.insertSelective(obj);
|
}else {
|
addressMapper.updateByPrimaryKeySelective(addressInfo);
|
}
|
|
if (UserEnum.默认地址.getValue().equals(addressReq.getFlag())) {
|
userTargetInfoService.updateTargetUserAddr(addressInfo);
|
}
|
} catch (BeansException e) {
|
ExceptionUtils.err("修改地址失败",e);
|
}
|
|
}
|
|
|
/**
|
* 删除地址
|
* @param addressId
|
*/
|
public void deleteById(Long addressId){
|
AddressInfo addressInfo=new AddressInfo();
|
addressInfo.setAddressId(addressId);
|
addressInfo.setDelFlag(Constants.DEL_FLAG+"");
|
addressMapper.updateByPrimaryKeySelective(addressInfo);
|
}
|
|
public void deleteByUserId(String userId){
|
AddressInfo addressInfo = new AddressInfo();
|
addressInfo.setDelFlag(Constants.DEL_FLAG+"");
|
Example example = new Example(AddressInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("userId", userId);
|
addressMapper.updateByExampleSelective(addressInfo,example);
|
}
|
|
/**
|
* 完善地址信息
|
* @param addressReq
|
* @param addressInfo
|
*/
|
private void completeAddress(AddressReq addressReq, AddressInfo addressInfo) {
|
if (StringUtils.isBlank(addressReq.getProvinceId())) {
|
getProvinceAndCityId(addressReq, addressInfo);
|
} else {
|
//设置adcode
|
if (StrUtil.isNotBlank(addressReq.getCityId()) && StrUtil.isNotBlank(addressReq.getTownshipId())) {
|
AddressLevelInfo addressLevelInfo = addressLevelService.find(addressReq.getProvinceId(), addressReq.getCityId(), addressReq.getTownshipId());
|
if (addressLevelInfo != null) {
|
addressInfo.setAdcode(addressLevelInfo.getAdcode());
|
addressInfo.setCitycode(addressLevelInfo.getCitycode());
|
}
|
}
|
}
|
//判断详细地址和所选的区域是否正确 高德同一地点存在跨区可能不准 （只判断到市）
|
checkLon(addressReq, addressInfo);
|
}
|
|
/**
|
* 判断详细地址和所选的区域是否正确 高德同一地点存在跨区可能不准 （只判断到市）
|
* @param addressReq
|
* @param addressInfo
|
*/
|
private void checkLon(AddressReq addressReq, AddressInfo addressInfo) {
|
GdReverseGEODto gdReverseGEODto = new GdReverseGEODto();
|
gdReverseGEODto.setLocation(addressReq.getLongitude() + "," + addressReq.getLatitude());
|
Result areaInfo = GdMapUtil.getAreaInfo(gdReverseGEODto, 0);
|
if (areaInfo.getCode() == 0) {
|
AddressInfo addressInfo1 = (AddressInfo) areaInfo.getData();
|
String adcode = addressInfo1.getCitycode();
|
if (StrUtil.isNotBlank(adcode) && StrUtil.isNotBlank(addressInfo.getCitycode())) {
|
if (!StrUtil.equals(adcode, addressInfo.getCitycode())) {
|
throw new RestException(-1, "详细地址与区域不一致，请重新选择");
|
}
|
}
|
}
|
}
|
|
|
public int addressDel(AddressReq addressReq) {
|
int returnvalue= 0;
|
try {
|
Long addressId = addressReq.getAddressId();
|
//查询用户下有几条地址
|
addressReq.setAddressId(null);
|
List<AddressVo> list = addressMapper.addressQuery(addressReq);
|
returnvalue = addressMapper.deleteAddress(addressId);
|
if (UserEnum.默认地址.getValue().equals( addressReq.getFlag() )&&list.size()>1){
|
// 如果删除的是默认地址，则设置第一条数据为默认地址
|
returnvalue = addressMapper.autoSetDefaultAddress(addressReq.getUserId());
|
}
|
} catch (Exception e) {
|
ExceptionUtils.err("删除地址失败",e);
|
}
|
return returnvalue;
|
}
|
|
|
public List<AddressVo> addressQuery(AddressReq addressReq) {
|
List<AddressVo> list = addressMapper.addressQuery(addressReq);
|
return list;
|
}
|
|
|
public void updateByUserIdSetNoDefault(String userId) {
|
if(StrUtil.isNotBlank(userId)) {
|
AddressInfo addressInfo = new AddressInfo();
|
addressInfo.setFlag(UserEnum.非默认地址.getValue());
|
Example example = new Example(AddressInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("userId", userId);
|
criteria.andEqualTo("delFlag",Constants.DEL_NOT_FLAG);
|
addressMapper.updateByExampleSelective(addressInfo,example);
|
}
|
}
|
|
|
public void updateAllById(AddressInfo addressInfo){
|
addressMapper.updateByPrimaryKey(addressInfo);
|
}
|
|
/**
|
* 查询所有地址
|
* @return
|
*/
|
public List<AddressInfo> find(){
|
AddressInfo addressInfo=new AddressInfo();
|
addressInfo.setDelFlag(Convert.toStr(Constants.DEL_NOT_FLAG));
|
List<AddressInfo> select = addressMapper.select(addressInfo);
|
return select;
|
}
|
|
public String updateUserAddress(AddressInfo address) {
|
AddressInfo oldAddre = new AddressInfo();
|
oldAddre.setAddressId(address.getAddressId());
|
AddressInfo oldAddress = addressMapper.selectOne(oldAddre);
|
oldAddress.setLongitude(address.getLongitude());
|
oldAddress.setLatitude(address.getLatitude());
|
String location = address.getLongitude()+","+address.getLatitude();
|
AddressLevelInfo addressLevelInfo = findByLocation(location);
|
String addressArea = "";
|
if(null!=addressLevelInfo.getLevel1Id()&&!"".equals(addressLevelInfo.getLevel1Id())){
|
oldAddress.setProvinceId(addressLevelInfo.getLevel1Id());
|
addressArea = addressLevelInfo.getLevel1Name();
|
}
|
if(null!=addressLevelInfo.getLevel2Id()&&!"".equals(addressLevelInfo.getLevel2Id())){
|
oldAddress.setCityId(addressLevelInfo.getLevel2Id());
|
addressArea = addressArea+addressLevelInfo.getLevel2Name();
|
}
|
if(null!=addressLevelInfo.getLevel3Id()&&!"".equals(addressLevelInfo.getLevel3Id())){
|
oldAddress.setTownshipId(addressLevelInfo.getLevel3Id());
|
addressArea =addressArea+addressLevelInfo.getLevel3Name();
|
}
|
//addressArea = addressArea + address.getDetailAddress();
|
oldAddress.setAddressArea(addressArea);
|
oldAddress.setDetailAddress(address.getDetailAddress());
|
oldAddress.setTagName(address.getTagName());
|
oldAddress.setUnitName(address.getUnitName());
|
oldAddress.setHouseNumber(address.getHouseNumber());
|
oldAddress.setReceiveAddress(address.getReceiveAddress());
|
addressMapper.updateByPrimaryKeySelective(oldAddress);
|
if(null!=address.getOrderId()&&!"".equals(address.getOrderId())){
|
OrderInfo orderInfo = new OrderInfo();
|
orderInfo.setOrderId(address.getOrderId());
|
orderInfo.setOrderStatus("1");
|
orderMapper.updateByPrimaryKeySelective(orderInfo);
|
}
|
return null;
|
}
|
|
public AddressLevelInfo findByLocation(String location){
|
GdReverseGEODto gdReverseGEODto = new GdReverseGEODto();
|
gdReverseGEODto.setLocation(location);
|
Result areaInfo = GdMapUtil.getAreaInfo(gdReverseGEODto, 0);
|
if (areaInfo.getCode() == 0) {
|
AddressInfo addressInfo = (AddressInfo) areaInfo.getData();
|
AddressLevelInfo addressLevelInfo=new AddressLevelInfo();
|
addressLevelInfo.setLevel3Name(addressInfo.getTownshipName());
|
addressLevelInfo.setLevel2Name(addressInfo.getCityName());
|
addressLevelInfo.setLevel1Name(addressInfo.getProvinceName());
|
List<AddressLevelInfo> byAny = findByAny(addressLevelInfo);
|
if(CollUtil.isNotEmpty(byAny)){
|
return byAny.get(0);
|
}else {
|
return null;
|
}
|
} else {
|
return null;
|
}
|
}
|
|
private List<AddressLevelInfo> findByAny(AddressLevelInfo addressLevelInfo) {
|
if(StrUtil.isNotBlank(addressLevelInfo.getLevel3Name())){
|
addressLevelInfo.setLevel3Name(businessUtil.changeArea(addressLevelInfo.getLevel3Name()));
|
}
|
|
List<AddressLevelInfo> addressLevelInfos = addressLevelInfoMapper.select(addressLevelInfo);
|
if(CollUtil.isNotEmpty(addressLevelInfos)){
|
for (AddressLevelInfo levelInfo : addressLevelInfos) {
|
levelInfo.setLevel3Name(businessUtil.changeArea(levelInfo.getLevel3Name()));
|
}
|
}
|
return addressLevelInfos;
|
}
|
|
public List<AddressInfo> findAllByUserId(String userId) {
|
AddressInfo addressInfo=new AddressInfo();
|
addressInfo.setUserId(userId);
|
addressInfo.setDelFlag(Constants.DEL_NOT_FLAG+"");
|
List<AddressInfo> select = addressMapper.select(addressInfo);
|
return select;
|
}
|
public AddressInfo findByUserId(String userId) {
|
AddressInfo addressInfo=new AddressInfo();
|
addressInfo.setUserId(userId);
|
addressInfo.setFlag(Constants.DEL_FLAG+"");
|
List<AddressInfo> select = addressMapper.select(addressInfo);
|
if(CollUtil.isNotEmpty(select)) {
|
List<AddressInfo> collect = select.stream().filter(x -> x.getDelFlag().equals("0")).collect(Collectors.toList());
|
if (CollUtil.isNotEmpty(collect)) {
|
return collect.get(0);
|
} else {
|
CollUtil.sort(select, new PropertyComparator<>("createTime").reversed());
|
return select.get(0);
|
}
|
}else{
|
UserInfo byId = userService.findById(userId);
|
if(StrUtil.isNotBlank(byId.getLatitude())){
|
AddressInfo addressInfo1 = getByLon(byId.getLongitude(),byId.getLatitude());
|
if (addressInfo1 != null) return addressInfo1;
|
}
|
}
|
return null;
|
}
|
|
public AddressInfo findById(Long id){
|
return addressMapper.selectByPrimaryKey(id);
|
}
|
|
/**
|
* 根据经纬度查询附近小区
|
* @param longiLatiModel
|
* @return
|
*/
|
public Result<PageInfo<GdAroundResDto>> findHouseByLon(LongiLatiModel longiLatiModel) {
|
GdAroundDto gdAroundDto =new GdAroundDto();
|
gdAroundDto.setLocation(longiLatiModel.getLongitude()+","+longiLatiModel.getLatitude());
|
gdAroundDto.setTypes(GdMapUtil.HOUSE_POI);
|
gdAroundDto.setPage(longiLatiModel.getPageNo());
|
gdAroundDto.setOffset(longiLatiModel.getPageSize());
|
Result<PageInfo<GdAroundResDto>> aroundPOI = GdMapUtil.findAroundPOI(gdAroundDto);
|
return aroundPOI;
|
}
|
}
|
