潘钊 / bsth_control · Files

package com.bsth.service.impl;

import com.bsth.annotation.BusinessDescription;
import com.bsth.entity.*;
import com.bsth.entity.search.CustomerSpecs;
import com.bsth.repository.*;
import com.bsth.service.LsStationRouteService;
import com.bsth.util.CustomBeanUtils;
import com.bsth.util.Geo.GeoUtils;
import com.bsth.util.Geo.Point;
import com.bsth.util.GeoConverter;
import org.geolatte.geom.LineString;
import org.geolatte.geom.Polygon;
import org.geolatte.geom.Position;
import org.geolatte.geom.codec.Wkt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.*;

/**
 * @author Hill
 */
@Service
public class LsStationRouteServiceImpl extends BaseServiceImpl<LsStationRoute, Integer> implements LsStationRouteService {

    @Autowired
    private LsStationRouteRepository lsStationRouteRepository;

    @Autowired
    private StationRouteRepository stationRouteRepository;

    @Autowired
    private StationRepository stationRepository;

    @Autowired
    private LsSectionRouteRepository lsSectionRouteRepository;

    @Autowired
    private SectionRouteRepository sectionRouteRepository;

    @Autowired
    private SectionRepository sectionRepository;

    @Autowired
    private LineRepository lineRepository;

    @Autowired
    private LineVersionsRepository lineVersionsRepository;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Iterable<LsStationRoute> findAllByParams(Map<String, Object> map) {
        List<Sort.Order> orders = new ArrayList<>();
        orders.add(new Sort.Order(Sort.Direction.ASC, "directions"));
        orders.add(new Sort.Order(Sort.Direction.ASC, "stationRouteCode"));

        return lsStationRouteRepository.findAll(new CustomerSpecs<>(map), Sort.by(orders));
    }

    /**
     * 获取历史站点和路段路由
     * @param map
     * @return
     */
    @Override
    public Map<String, Object> findRoutes(Map<String, Object> map) {
        Map<String, Object> result = new HashMap<>();
        List<LsStationRoute> stationList = lsStationRouteRepository.findAll(new CustomerSpecs<>(map), Sort.by(Sort.Direction.ASC, "directions", "stationRouteCode"));
        List<LsSectionRoute> sectionList = lsSectionRouteRepository.findAll(new CustomerSpecs<>(map), Sort.by(Sort.Direction.ASC, "directions", "sectionrouteCode"));

        result.put("stationRoutes", stationList);
        result.put("sectionRoutes", sectionList);

        return result;
    }

    /**
     * 获取历史站点路由
     * @param map
     * @return
     */
    public List<LsStationRoute> findStationRoutes(Map<String, Object> map) {
        return lsStationRouteRepository.findAll(new CustomerSpecs<>(map), Sort.by(Sort.Direction.ASC, "directions", "stationRouteCode"));
    }

    /**
     * 获取当前站点以及下一站点路由
     * @param id
     * @return
     */
    @Override
    public List<LsStationRoute> findCurrentAndNext(Integer id) {
        if (id == null) {
            throw new IllegalArgumentException("需正确传入站点路由ID参数");
        }
        List<LsStationRoute> stationRoutes = new ArrayList<>();
        LsStationRoute stationRoute = lsStationRouteRepository.findById(id).get();
        Map<String, Object> params = new HashMap<>();
        params.put("line.id_eq", stationRoute.getLine().getId());
        params.put("versions_eq", stationRoute.getVersions());
        params.put("directions_eq", stationRoute.getDirections());
        params.put("destroy_eq", 0);
        params.put("stationRouteCode_gt", stationRoute.getStationRouteCode());
        List<LsStationRoute> stationRoutes1 = lsStationRouteRepository.findAll(new CustomerSpecs<>(params), Sort.by(Sort.Order.asc("stationRouteCode")));
        stationRoutes.add(stationRoute);
        if (stationRoutes1.size() > 0) {
            stationRoutes.add(stationRoutes1.get(0));
        }

        return stationRoutes;
    }

    /**
     * 批量撤销站点路由
     * @param ids
     */
    @BusinessDescription(value = "批量撤销站点路由")
    @Transactional(rollbackFor = RuntimeException.class)
    @Override
    public void batchDestroy(List<Integer> ids) {
        if (ids.size() > 0) {
            Integer id = ids.get(0);
            LsStationRoute stationRoute = lsStationRouteRepository.findById(id).get();
            Integer lineId = stationRoute.getLine().getId();
            Integer currentVersion = lineVersionsRepository.findCurrentVersion(lineId);
            if (stationRoute.getVersions() < currentVersion) {
                throw new IllegalArgumentException("历史版本不可变更");
            }

            lsStationRouteRepository.batchDestroy(ids);
            remark(stationRoute);
            if (stationRoute.getVersions().equals(currentVersion)) {
                refreshCurrent(lineId, currentVersion);
            }
        }
    }

    /**
     * 批量恢复撤销站点路由
     * @param ids
     */
    @BusinessDescription(value = "批量恢复撤销站点路由")
    @Transactional(rollbackFor = RuntimeException.class)
    @Override
    public void batchRecover(List<Integer> ids) {
        if (ids.size() > 0) {
            Integer id = ids.get(0);
            LsStationRoute stationRoute = lsStationRouteRepository.findById(id).get();
            Integer lineId = stationRoute.getLine().getId();
            Integer currentVersion = lineVersionsRepository.findCurrentVersion(lineId);
            if (stationRoute.getVersions() < currentVersion) {
                throw new IllegalArgumentException("历史版本不可变更");
            }

            lsStationRouteRepository.batchRecover(ids);
            remark(stationRoute);
            if (stationRoute.getVersions().equals(currentVersion)) {
                refreshCurrent(lineId, currentVersion);
            }
        }
    }

    /**
     * 保存线路某个版本下的站点路由
     * 常规使用在选择已有站点生成线路路由的情况
     * @param lineId
     * @param versions
     * @param directions
     * @param stationIds
     * @return
     */
    @Transactional
    @Override
    public Map<String, Object> addStationRoutes(Integer lineId, Integer versions, Integer directions, List<Integer> stationIds) {
        Map<String, Object> result = new HashMap<>();
        Line line = lineRepository.findById(lineId).get();
        Integer version = lineVersionsRepository.findCurrentVersion(lineId);
        if (line == null) {
            throw new RuntimeException(String.format("未找到ID为%d的线路信息", lineId));
        }
        Map<String, Object> params = new HashMap<>();
        params.put("id_ids", stationIds);
        List<Station> stations = stationRepository.findAll(new CustomerSpecs<>(params));
        Map<Integer, Station> id2station = new HashMap<>();
        if (stations.size() > 0) {
            for (Station station : stations) {
                id2station.put(station.getId(), station);
            }
        }
        List<LsStationRoute> stationRoutes = new ArrayList<>();
        for (int i = 0;i < stationIds.size();i++) {
            Integer stationId = stationIds.get(i);
            LsStationRoute stationRoute = new LsStationRoute();
            Station station = id2station.get(stationId);
            stationRoute.setStation(station);
            stationRoute.setLine(line);
            stationRoute.setLineCode(line.getLineCode());
            stationRoute.setDirections(directions);
            stationRoute.setVersions(versions);
            stationRoute.setStationName(station.getStationName());
            stationRoute.setStationCode(station.getStationCode());
            stationRoute.setCenterPoint(station.getCenterPoint());
            stationRoute.setCenterPointWgs(station.getCenterPointWgs());
            stationRoute.setShapedType("r");
            stationRoute.setRadius(80);
            stationRoute.setStationRouteCode(100 + i * 10);
            if (i == 0) {
                stationRoute.setStationMark("B");
            } else if (i == stationIds.size() - 1) {
                stationRoute.setStationMark("E");
            } else {
                stationRoute.setStationMark("Z");
            }

            stationRoutes.add(stationRoute);
        }

        lsStationRouteRepository.saveAll(stationRoutes);
        if (versions.equals(version)) {
            refreshCurrent(lineId, version);
        }

        return result;
    }

    @Transactional
    @Override
    public Map<String, Object> addRoutes(Integer lineId, Integer versions, Integer directions, List<LsStationRoute> stationRoutes, List<LsSectionRoute> sectionRoutes) {
        Map<String, Object> result = new HashMap<>();
        Line line = lineRepository.findById(lineId).get();
        Integer version = lineVersionsRepository.findCurrentVersion(lineId);
        if (line == null) {
            throw new RuntimeException(String.format("未找到ID为%d的线路信息", lineId));
        }
        List<Station> stations = stationRoutesHandle(line, versions, directions, stationRoutes);
        List<Section> sections = sectionRoutesHandle(line, versions, directions, sectionRoutes);

        stationRepository.saveAll(stations);
        sectionRepository.saveAll(sections);
        lsStationRouteRepository.saveAll(stationRoutes);
        lsSectionRouteRepository.saveAll(sectionRoutes);
        if (versions.equals(version)) {
            refreshCurrent(lineId, version);
        }

        return result;
    }

    private List<Station> stationRoutesHandle(Line line, Integer versions, Integer directions, List<LsStationRoute> stationRoutes) {
        List<Station> stations = new ArrayList<>();
        int currentId = stationRepository.findLatestStationId(), count = 0;
        for (int len = stationRoutes.size();count < len;) {
            LsStationRoute stationRoute = stationRoutes.get(count);
            stationRoute.setStationMark(count == 0 ? "B" : count == len - 1 ? "E" : "Z");
            count++;
            stationRoute.setLine(line);
            stationRoute.setVersions(versions);
            stationRoute.setDirections(directions);
            stationRoute.setLineCode(line.getLineCode());
            stationRoute.setStationRouteCode(100 * count);
            stationRoute.setStationCode(stationRoute.getStation().getStationCode());

            Station station = stationRoute.getStation();
            stationRoute.setCenterPointWkt(station.getCenterPointWkt());
            if (!StringUtils.isEmpty(stationRoute.getCenterPointWkt())) {
                centerPoint(stationRoute);
            }

            if (station.getId() == null) {
                station.setId(currentId + count);
                station.setStationCode(station.getId().toString());
                stationRoute.setStationCode(station.getStationCode());
                centerPoint(station);
                stations.add(station);
            }
        }

        return stations;
    }

    private List<Section> sectionRoutesHandle(Line line, Integer versions, Integer directions, List<LsSectionRoute> sectionRoutes) {
        List<Section> sections = new ArrayList<>();
        int currentId = sectionRepository.findLatestSectionId(), count = 0;
        for (int len = sectionRoutes.size();count < len;) {
            LsSectionRoute sectionRoute = sectionRoutes.get(count++);
            sectionRoute.setLine(line);
            sectionRoute.setVersions(versions);
            sectionRoute.setDirections(directions);
            sectionRoute.setLineCode(line.getLineCode());
            sectionRoute.setSectionrouteCode(100 * count);
            String wkt = sectionRoute.getSection().getBsectionVectorWkt();
            Section section = sectionRoute.getSection();
            section.setBsectionVector((LineString) Wkt.fromWkt(wkt));
            section.setGsectionVector(GeoConverter.lineStringBd2wgs(wkt));
            section.setId(currentId + count);
            section.setSectionCode(section.getId().toString());
            sectionRoute.setSectionCode(section.getSectionCode());
            sections.add(section);
        }

        return sections;
    }

    @BusinessDescription(value = "添加站点路由")
    @Transactional
    @Override
    public Map<String, Object> add(LsStationRoute stationRoute) {
        Station station = stationRoute.getStation();
        Line line = lineRepository.findById(stationRoute.getLine().getId()).get();
        Integer currentVersion = lineVersionsRepository.findCurrentVersion(line.getId());
        boolean isPresent = stationRepository.findById(station.getId()).isPresent();
        stationRoute.setLineCode(line.getLineCode());
        stationRoute.setCenterPointWkt(station.getCenterPointWkt());
        if (stationRoute.getVersions() < currentVersion) {
            throw new IllegalArgumentException("历史版本不可变更");
        }

        if (!StringUtils.isEmpty(stationRoute.getCenterPointWkt())) {
            centerPoint(stationRoute);
        }

        // 中心点坐标信息
        if (!isPresent) {
            centerPoint(station);
            stationRoute.setCenterPoint(station.getCenterPoint());
            stationRoute.setCenterPointWgs(station.getCenterPointWgs());
        }

        // 多边形缓冲区
        if ("d".equals(stationRoute.getShapedType())) {
            bufferPolygon(stationRoute);
        }

        lsStationRouteRepository.updateStatiouRouteCode(stationRoute);
        if (!isPresent) {
            stationRepository.save(station);
        }
        lsStationRouteRepository.save(stationRoute);
        remark(stationRoute);
        if (stationRoute.getVersions().equals(currentVersion)) {
            refreshCurrent(line.getId(), currentVersion);
        }

        return new HashMap<>();
    }

    @Transactional
    @Override
    public Map<String, Object> modify(LsStationRoute stationRoute) {
        LsStationRoute stationRoute1 = lsStationRouteRepository.findById(stationRoute.getId()).get();
        Integer currentVersion = lineVersionsRepository.findCurrentVersion(stationRoute1.getLine().getId());
        if (stationRoute1.getVersions() < currentVersion) {
            throw new IllegalArgumentException("历史版本不可变更");
        }

        if (!StringUtils.isEmpty(stationRoute.getCenterPointWkt())) {
            centerPoint(stationRoute);
        }

        // 多边形缓冲区
        if ("d".equals(stationRoute.getShapedType())) {
            bufferPolygon(stationRoute);
        }

        lsStationRouteRepository.updateStatiouRouteCode(stationRoute);
        CustomBeanUtils.copyPropertiesIgnoredNull(stationRoute, stationRoute1);
        lsStationRouteRepository.save(stationRoute1);
        remark(stationRoute1);
        if (stationRoute.getVersions().equals(currentVersion)) {
            refreshCurrent(stationRoute1.getLine().getId(), currentVersion);
        }

        return new HashMap<>();
    }

    @Transactional
    @Override
    public Map<String, Object> exchangeDirection(int lineId, int version) {
        lsStationRouteRepository.exchangeDirection(lineId, version);
        lsSectionRouteRepository.exchangeDirection(lineId, version);

        return new HashMap<>();
    }

    @Transactional
    @Override
    public Map<String, Object> modifyDistance(List<Integer> ids, List<Double> distances) {
        LsStationRoute stationRoute = lsStationRouteRepository.findById(ids.get(0)).get();
        int currentVersion = lineVersionsRepository.findCurrentVersion(stationRoute.getLine().getId());
        if (stationRoute.getVersions() < currentVersion) {
            throw new IllegalArgumentException("历史版本不可变更");
        }

        jdbcTemplate.batchUpdate("UPDATE bsth_c_ls_stationroute SET distances = ? WHERE id = ?", new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                ps.setDouble(1, distances.get(i));
                ps.setInt(2, ids.get(i));
            }

            @Override
            public int getBatchSize() {
                return ids.size();
            }
        });

        if (stationRoute.getVersions() == currentVersion) {
            refreshCurrent(stationRoute.getLine().getId(), currentVersion);
        }

        return new HashMap<>();
    }

    @Transactional
    @Override
    public Map<String, Object> circularRouteHandle(Integer lineId, Integer version) {
        Line line = lineRepository.findById(lineId).get();
        Integer currentVersion = lineVersionsRepository.findCurrentVersion(lineId);
        if (version < currentVersion) {
            throw new IllegalArgumentException("历史版本不可变更");
        }

        Map<String, Object> params = new HashMap<>();
        params.put("line.id_eq", lineId);
        params.put("versions_eq", version);
        params.put("destroy_eq", 0);
        params.put("stationMark_in", "B,E");

        Sort sort = Sort.by(Sort.Order.asc("directions"), Sort.Order.asc("stationRouteCode"));
        List<LsStationRoute> routes = lsStationRouteRepository.findAll(new CustomerSpecs<>(params), sort);
        LsStationRoute route = routes.get(0);
        for (int i = 1;i < routes.size();i++) {
            LsStationRoute route1 = routes.get(i);
            if (line.getLinePlayType() == 1 && route1.getDirections() == 1) {
                break;
            }
            route1.setStationCode(route.getStationCode());
            route1.setStation(route.getStation());
        }
        lsStationRouteRepository.saveAll(routes);
        if (version.equals(currentVersion)) {
            refreshCurrent(lineId, version);
        }

        return new HashMap<>();
    }

    @Override
    public Map<String, Object> analyzeRoutes(Integer lineId, Integer version, Integer direction) {
        Map<String, Object> result = new HashMap<>(), params = new HashMap<>();
        params.put("line.id_eq", lineId);
        params.put("versions_eq", version);
        params.put("directions_eq", direction);
        params.put("destroy_eq", 0);
        List<Sort.Order> orders1 = new ArrayList<>(), orders2 = new ArrayList<>();
        orders1.add(new Sort.Order(Sort.Direction.ASC, "directions"));
        orders1.add(new Sort.Order(Sort.Direction.ASC, "stationRouteCode"));
        orders2.add(new Sort.Order(Sort.Direction.ASC, "directions"));
        orders2.add(new Sort.Order(Sort.Direction.ASC, "sectionrouteCode"));

        boolean isCircularRoute = false;
        List<LsStationRoute> stationRoutes = lsStationRouteRepository.findAll(new CustomerSpecs<>(params), Sort.by(orders1));
        List<LsSectionRoute> sectionRoutes = lsSectionRouteRepository.findAll(new CustomerSpecs<>(params), Sort.by(orders2));
        List<String> indexes = new ArrayList<>();
        if (stationRoutes.get(0).getStationCode().equals(stationRoutes.get(stationRoutes.size() - 1).getStationCode())) {
            isCircularRoute = true;
        }
        for (LsSectionRoute sectionRoute : sectionRoutes) {
            LineString lineString = sectionRoute.getSection().getGsectionVector();
            for (int i = 0; i < lineString.getNumPositions() - 1; i++) {
                List<Point> points = new ArrayList<>();
                Position start = lineString.getPositionN(i), end = lineString.getPositionN(i + 1);
                Point point1 = new Point(start.getCoordinate(0), start.getCoordinate(1));
                Point point2 = new Point(end.getCoordinate(0), end.getCoordinate(1));
                int size = (int) (GeoUtils.getDistance(point1, point2) / 10) + 1;
                points.add(point1);
                if (size > 1) {
                    double offsetLon = (point2.getLon() - point1.getLon()) / size;
                    double offsetLat = (point2.getLat() - point1.getLat()) / size;
                    for (int j = 1; j < size; j++) {
                        Point mid = new Point(point1.getLon() + offsetLon * j, point1.getLat() + offsetLat * j);
                        points.add(mid);
                    }
                }
                points.add(point2);
                for (Point p : points) {
                    for (int j = 0; j < stationRoutes.size(); j++) {
                        LsStationRoute stationRoute = stationRoutes.get(j);
                        if ("r".equals(stationRoute.getShapedType())) {
                            org.geolatte.geom.Point center = stationRoute.getStation().getCenterPointWgs();
                            if (GeoUtils.getDistance(p, new Point(center.getPositionN(0).getCoordinate(0), center.getPositionN(0).getCoordinate(1))) <= stationRoute.getRadius()) {
                                if (indexes.size() == 0 || !indexes.get(indexes.size() - 1).endsWith(String.format("-%d", j))) {
                                    indexes.add(String.format("%s-%d", stationRoute.getStationCode(), j));
                                }
                            }
                        } else {
                            Polygon polygon = stationRoute.getBufferPolygonWgs();
                            List<com.bsth.util.Geo.Point> polygonPoint = new ArrayList<>();
                            for (int k = 0; k < polygon.getNumPositions(); k++) {
                                polygonPoint.add(new Point(polygon.getPositionN(k).getCoordinate(0), polygon.getPositionN(k).getCoordinate(1)));
                            }
                            com.bsth.util.Geo.Polygon polygon1 = new com.bsth.util.Geo.Polygon(polygonPoint);
                            if (GeoUtils.isPointInPolygon(p, polygon1)) {
                                if (indexes.size() == 0 || !indexes.get(indexes.size() - 1).endsWith(String.format("-%d", j))) {
                                    indexes.add(String.format("%s-%d", stationRoute.getStationCode(), j));
                                }
                            }
                        }
                    }
                }
            }
        }
        Set<String> specialStations = new LinkedHashSet<>();
        result.put("data", specialStations);
        for (int i = 0; i < stationRoutes.size(); ) {
            if (indexes.size() == 0) {
                break;
            }
            String lastMatch = null;
            int j = 0;
            for (; j < indexes.size(); j++) {
                String index = indexes.get(j), suffix = String.format("-%d", i);
                if (index.endsWith(suffix) || isCircularRoute && i == stationRoutes.size() - 1 && index.endsWith("-0")) {
                    lastMatch = index;
                    i++;
                } else {
                    if (!index.equals(lastMatch)) {
                        specialStations.add(String.format("%s, %s", index, lastMatch));
                    }
                }
            }
            if (j == indexes.size()) {
                break;
            }
        }

        return result;
    }

    public List<LsStationRoute> findByLineDirectionDate(Integer lineId, Integer direction, Date begin, Date end) {
        return lsStationRouteRepository.findByLineDirectionDate(lineId, direction, begin, end);
    }

    protected void centerPoint(Station station) {
        // 中心点坐标信息
        String wkt = station.getCenterPointWkt();
        if (!StringUtils.isEmpty(wkt)) {
            org.geolatte.geom.Point baidu = (org.geolatte.geom.Point) Wkt.fromWkt(wkt);
            org.geolatte.geom.Point wgs = GeoConverter.pointBd2wgs(wkt);
            station.setCenterPoint(baidu);
            station.setCenterPointWgs(wgs);
        }
    }

    protected void centerPoint(LsStationRoute route) {
        // 中心点坐标信息
        String wkt = route.getCenterPointWkt();
        if (!StringUtils.isEmpty(wkt)) {
            org.geolatte.geom.Point baidu = (org.geolatte.geom.Point) Wkt.fromWkt(wkt);
            org.geolatte.geom.Point wgs = GeoConverter.pointBd2wgs(wkt);
            route.setCenterPoint(baidu);
            route.setCenterPointWgs(wgs);
        }
    }

    protected void bufferPolygon(LsStationRoute stationRoute) {
        String wkt = stationRoute.getBufferPolygonWkt();
        if (!StringUtils.isEmpty(wkt)) {
            stationRoute.setBufferPolygon((Polygon) Wkt.fromWkt(wkt));
            stationRoute.setBufferPolygonWgs(GeoConverter.polygonBd2wgs(wkt));
        }
    }

    protected void remark(LsStationRoute stationRoute) {
        lsStationRouteRepository.updateStartZ(stationRoute);
        lsStationRouteRepository.updateStartB(stationRoute);
        lsStationRouteRepository.updateStartE(stationRoute);
    }

    protected void refreshCurrent(int lineId, int version) {
        stationRouteRepository.deleteByLine(lineId);
        stationRouteRepository.updateFromHistory(lineId, version);
    }
}