feat(数据查看): 补齐网约车总数/网约车订单/个体客运三类查看（含市州派生）+ 测试报告与日结

zhizhijie

9 天以前 2d74b99f1cb1ba745e32f5cfdfed82a8fb22f37f

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/controller/DataViewController.java

@@ -6,14 +6,41 @@
import com.trafficaudit.common.Result;
import com.trafficaudit.dataimport.entity.FreightTurnoverImport;
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
import com.trafficaudit.dataimport.entity.PassengerAuthVehicle;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiAuth;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import com.trafficaudit.dataimport.entity.ScaleSplitTransport;
import com.trafficaudit.dataimport.entity.TransportAuthVehicle;
import com.trafficaudit.dataimport.entity.VehicleTrackMileage;
import com.trafficaudit.dataimport.entity.InvestmentMonthly;
import com.trafficaudit.dataimport.entity.InvestmentProject;
import com.trafficaudit.dataimport.entity.InvestmentSystem;
import com.trafficaudit.dataimport.entity.EnergyVehicleQuarterly;
import com.trafficaudit.dataimport.entity.EnergyAuthVehicle;
import com.trafficaudit.dataimport.entity.PassengerIndividualMonthly;
import com.trafficaudit.dataimport.entity.WycOrderMonthly;
import com.trafficaudit.dataimport.entity.WycTotalMonthly;
import com.trafficaudit.common.util.RegionUtil;
import com.trafficaudit.dataimport.mapper.FreightTurnoverImportMapper;
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiAuthMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.ScaleSplitTransportMapper;
import com.trafficaudit.dataimport.mapper.TransportAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.VehicleTrackMileageMapper;
import com.trafficaudit.dataimport.mapper.InvestmentMonthlyMapper;
import com.trafficaudit.dataimport.mapper.InvestmentProjectMapper;
import com.trafficaudit.dataimport.mapper.InvestmentSystemMapper;
import com.trafficaudit.dataimport.mapper.EnergyVehicleQuarterlyMapper;
import com.trafficaudit.dataimport.mapper.EnergyAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.PassengerIndividualMonthlyMapper;
import com.trafficaudit.dataimport.mapper.WycOrderMonthlyMapper;
import com.trafficaudit.dataimport.mapper.WycTotalMonthlyMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@@ -44,6 +71,32 @@
    private ScaleSplitTransportMapper scaleSplitMapper;
    @Resource
    private FreightTurnoverImportMapper freightTurnoverMapper;
    @Resource
    private PassengerEnterpriseMonthlyMapper passengerMapper;
    @Resource
    private PassengerAuthVehicleMapper passengerAuthMapper;
    @Resource
    private CityBusMonthlyMapper cityBusMapper;
    @Resource
    private CityTaxiMonthlyMapper cityTaxiMapper;
    @Resource
    private CityTaxiAuthMapper cityTaxiAuthMapper;
    @Resource
    private InvestmentMonthlyMapper investmentMonthlyMapper;
    @Resource
    private InvestmentProjectMapper investmentProjectMapper;
    @Resource
    private InvestmentSystemMapper investmentSystemMapper;
    @Resource
    private EnergyVehicleQuarterlyMapper energyVehicleMapper;
    @Resource
    private EnergyAuthVehicleMapper energyAuthMapper;
    @Resource
    private PassengerIndividualMonthlyMapper passengerIndividualMapper;
    @Resource
    private WycOrderMonthlyMapper wycOrderMapper;
    @Resource
    private WycTotalMonthlyMapper wycTotalMapper;

    @GetMapping("/list")
    public Result<Map<String, Object>> list(@RequestParam("type") String type,
@@ -113,6 +166,61 @@
                fillPage(result, r);
                break;
            }
            case "h2031": {
                LambdaQueryWrapper<PassengerEnterpriseMonthly> w = new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                        .eq(notEmpty(period), PassengerEnterpriseMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), PassengerEnterpriseMonthly::getEnterpriseName, kw)
                        .orderByDesc(PassengerEnterpriseMonthly::getId);
                Page<PassengerEnterpriseMonthly> p = new Page<>(safePage, safeSize);
                Page<PassengerEnterpriseMonthly> r = passengerMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(H2031_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "cityBus": {
                LambdaQueryWrapper<CityBusMonthly> w = new LambdaQueryWrapper<CityBusMonthly>()
                        .eq(notEmpty(period), CityBusMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), CityBusMonthly::getEnterpriseName, kw)
                        .orderByDesc(CityBusMonthly::getId);
                Page<CityBusMonthly> p = new Page<>(safePage, safeSize);
                Page<CityBusMonthly> r = cityBusMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(BUS_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "cityTaxi": {
                LambdaQueryWrapper<CityTaxiMonthly> w = new LambdaQueryWrapper<CityTaxiMonthly>()
                        .eq(notEmpty(period), CityTaxiMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), CityTaxiMonthly::getCity, kw)
                        .orderByAsc(CityTaxiMonthly::getId);
                Page<CityTaxiMonthly> p = new Page<>(safePage, safeSize);
                Page<CityTaxiMonthly> r = cityTaxiMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(TAXI_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "cityTaxiAuth": {
                LambdaQueryWrapper<CityTaxiAuth> w = new LambdaQueryWrapper<CityTaxiAuth>()
                        .eq(notEmpty(period), CityTaxiAuth::getReportPeriod, period)
                        .like(!kw.isEmpty(), CityTaxiAuth::getCity, kw)
                        .orderByDesc(CityTaxiAuth::getId);
                Page<CityTaxiAuth> p = new Page<>(safePage, safeSize);
                Page<CityTaxiAuth> r = cityTaxiAuthMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(TAXI_AUTH_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "passengerAuth": {
                LambdaQueryWrapper<PassengerAuthVehicle> w = new LambdaQueryWrapper<PassengerAuthVehicle>()
                        .eq(notEmpty(period), PassengerAuthVehicle::getReportPeriod, period)
                        .like(!kw.isEmpty(), PassengerAuthVehicle::getEnterpriseName, kw)
                        .orderByDesc(PassengerAuthVehicle::getId);
                Page<PassengerAuthVehicle> p = new Page<>(safePage, safeSize);
                Page<PassengerAuthVehicle> r = passengerAuthMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(PAUTH_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "freightTurnover": {
                LambdaQueryWrapper<FreightTurnoverImport> w = new LambdaQueryWrapper<FreightTurnoverImport>()
                        .eq(notEmpty(period), FreightTurnoverImport::getReportPeriod, period)
@@ -121,6 +229,113 @@
                Page<FreightTurnoverImport> p = new Page<>(safePage, safeSize);
                Page<FreightTurnoverImport> r = freightTurnoverMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(FREIGHT_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "investmentMonthly": {
                java.util.List<Long> pids = new ArrayList<>();
                if (!kw.isEmpty()) {
                    for (InvestmentProject ip : investmentProjectMapper.selectList(
                            new LambdaQueryWrapper<InvestmentProject>().like(InvestmentProject::getProjectName, kw))) {
                        pids.add(ip.getId());
                    }
                    if (pids.isEmpty()) {
                        result.put("records", new ArrayList<>());
                        result.put("total", 0L);
                        result.put("current", safePage);
                        result.put("size", safeSize);
                        break;
                    }
                }
                LambdaQueryWrapper<InvestmentMonthly> w = new LambdaQueryWrapper<InvestmentMonthly>()
                        .eq(notEmpty(period), InvestmentMonthly::getReportPeriod, period)
                        .in(!pids.isEmpty(), InvestmentMonthly::getProjectId, pids)
                        .orderByAsc(InvestmentMonthly::getProjectId)
                        .orderByAsc(InvestmentMonthly::getId);
                Page<InvestmentMonthly> p = new Page<>(safePage, safeSize);
                Page<InvestmentMonthly> r = investmentMonthlyMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(INVEST_MONTHLY_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "investmentProject": {
                LambdaQueryWrapper<InvestmentProject> w = new LambdaQueryWrapper<InvestmentProject>()
                        .like(!kw.isEmpty(), InvestmentProject::getProjectName, kw)
                        .orderByAsc(InvestmentProject::getCity)
                        .orderByAsc(InvestmentProject::getId);
                Page<InvestmentProject> p = new Page<>(safePage, safeSize);
                Page<InvestmentProject> r = investmentProjectMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(INVEST_PROJECT_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "investmentSystem": {
                LambdaQueryWrapper<InvestmentSystem> w = new LambdaQueryWrapper<InvestmentSystem>()
                        .eq(notEmpty(period), InvestmentSystem::getReportPeriod, period)
                        .like(!kw.isEmpty(), InvestmentSystem::getProjectName, kw)
                        .orderByDesc(InvestmentSystem::getId);
                Page<InvestmentSystem> p = new Page<>(safePage, safeSize);
                Page<InvestmentSystem> r = investmentSystemMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(INVEST_SYSTEM_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "energyVehicle": {
                LambdaQueryWrapper<EnergyVehicleQuarterly> w = new LambdaQueryWrapper<EnergyVehicleQuarterly>()
                        .eq(notEmpty(period), EnergyVehicleQuarterly::getReportPeriod, period)
                        .like(!kw.isEmpty(), EnergyVehicleQuarterly::getEnterpriseName, kw)
                        .orderByDesc(EnergyVehicleQuarterly::getId);
                Page<EnergyVehicleQuarterly> p = new Page<>(safePage, safeSize);
                Page<EnergyVehicleQuarterly> r = energyVehicleMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(ENERGY_VEHICLE_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "energyAuth": {
                LambdaQueryWrapper<EnergyAuthVehicle> w = new LambdaQueryWrapper<EnergyAuthVehicle>()
                        .eq(notEmpty(period), EnergyAuthVehicle::getReportPeriod, period)
                        .like(!kw.isEmpty(), EnergyAuthVehicle::getPlateNo, kw)
                        .orderByDesc(EnergyAuthVehicle::getId);
                Page<EnergyAuthVehicle> p = new Page<>(safePage, safeSize);
                Page<EnergyAuthVehicle> r = energyAuthMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(ENERGY_AUTH_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "passengerIndividual": {
                LambdaQueryWrapper<PassengerIndividualMonthly> w = new LambdaQueryWrapper<PassengerIndividualMonthly>()
                        .eq(notEmpty(period), PassengerIndividualMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), PassengerIndividualMonthly::getEnterpriseName, kw)
                        .orderByDesc(PassengerIndividualMonthly::getId);
                Page<PassengerIndividualMonthly> p = new Page<>(safePage, safeSize);
                Page<PassengerIndividualMonthly> r = passengerIndividualMapper.selectPage(p, w);
                List<Map<String, Object>> rows = toMaps(r.getRecords(), propsOf(PAX_INDIVIDUAL_COLUMNS));
                for (Map<String, Object> row : rows) {
                    Object rc = row.get("regionCode");
                    String cityName = rc == null ? null : RegionUtil.cityByCode(String.valueOf(rc));
                    row.put("city", cityName == null ? "" : cityName);
                }
                result.put("records", rows);
                fillPage(result, r);
                break;
            }
            case "wycTotal": {
                LambdaQueryWrapper<WycTotalMonthly> w = new LambdaQueryWrapper<WycTotalMonthly>()
                        .eq(notEmpty(period), WycTotalMonthly::getReportPeriod, period)
                        .orderByDesc(WycTotalMonthly::getId);
                Page<WycTotalMonthly> p = new Page<>(safePage, safeSize);
                Page<WycTotalMonthly> r = wycTotalMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(WYC_TOTAL_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "wycOrder": {
                LambdaQueryWrapper<WycOrderMonthly> w = new LambdaQueryWrapper<WycOrderMonthly>()
                        .eq(notEmpty(period), WycOrderMonthly::getReportPeriod, period)
                        .orderByDesc(WycOrderMonthly::getId);
                Page<WycOrderMonthly> p = new Page<>(safePage, safeSize);
                Page<WycOrderMonthly> r = wycOrderMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(WYC_ORDER_COLUMNS)));
                fillPage(result, r);
                break;
            }
@@ -171,6 +386,19 @@
            case "trackMileage": return TRACK_COLUMNS;
            case "scaleSplit": return SPLIT_COLUMNS;
            case "freightTurnover": return FREIGHT_COLUMNS;
            case "h2031": return H2031_COLUMNS;
            case "cityBus": return BUS_COLUMNS;
            case "cityTaxi": return TAXI_COLUMNS;
            case "cityTaxiAuth": return TAXI_AUTH_COLUMNS;
            case "passengerAuth": return PAUTH_COLUMNS;
            case "investmentMonthly": return INVEST_MONTHLY_COLUMNS;
            case "investmentProject": return INVEST_PROJECT_COLUMNS;
            case "investmentSystem": return INVEST_SYSTEM_COLUMNS;
            case "energyVehicle": return ENERGY_VEHICLE_COLUMNS;
            case "energyAuth": return ENERGY_AUTH_COLUMNS;
            case "passengerIndividual": return PAX_INDIVIDUAL_COLUMNS;
            case "wycTotal": return WYC_TOTAL_COLUMNS;
            case "wycOrder": return WYC_ORDER_COLUMNS;
            default: return new ArrayList<>();
        }
    }
@@ -181,6 +409,7 @@
        m.put("label", label);
        m.put("width", width);
        return m;

    }

    private static final List<Map<String, Object>> H2032_COLUMNS = new ArrayList<>();
@@ -188,6 +417,19 @@
    private static final List<Map<String, Object>> TRACK_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> SPLIT_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> FREIGHT_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> H2031_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> PAUTH_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> BUS_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> TAXI_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> TAXI_AUTH_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> INVEST_MONTHLY_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> INVEST_PROJECT_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> INVEST_SYSTEM_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> ENERGY_VEHICLE_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> ENERGY_AUTH_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> PAX_INDIVIDUAL_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> WYC_TOTAL_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> WYC_ORDER_COLUMNS = new ArrayList<>();

    static {
        H2032_COLUMNS.add(col("reportPeriod", "报表期", 100));
@@ -268,5 +510,184 @@
        for (int m = 1; m <= 12; m++) {
            FREIGHT_COLUMNS.add(col(String.format("lastTurnoverM%02d", m), "去年周转量" + m + "月", 140));
        }

        H2031_COLUMNS.add(col("reportPeriod", "报表期", 100));
        H2031_COLUMNS.add(col("regionCode", "所属地区", 100));
        H2031_COLUMNS.add(col("enterpriseCode", "企业代码", 130));
        H2031_COLUMNS.add(col("enterpriseName", "企业名称", 220));
        H2031_COLUMNS.add(col("unifiedCreditCode", "统一社会信用代码", 180));
        H2031_COLUMNS.add(col("reportUnit", "填报单位", 160));
        H2031_COLUMNS.add(col("vehicleTotal", "客运车辆合计", 110));
        H2031_COLUMNS.add(col("seatTotal", "核定载客位合计", 130));
        H2031_COLUMNS.add(col("vehicleSchedule", "班线车辆数", 110));
        H2031_COLUMNS.add(col("seatSchedule", "班线载客位", 110));
        H2031_COLUMNS.add(col("vehicleCharter", "包车车辆数", 110));
        H2031_COLUMNS.add(col("seatCharter", "包车载客位", 110));
        H2031_COLUMNS.add(col("passengerTotal", "客运量合计", 110));
        H2031_COLUMNS.add(col("turnoverTotal", "周转量合计", 110));
        H2031_COLUMNS.add(col("passengerClass1", "客运量一类", 110));
        H2031_COLUMNS.add(col("passengerClass2", "客运量二类", 110));
        H2031_COLUMNS.add(col("passengerClass3", "客运量三类", 110));
        H2031_COLUMNS.add(col("passengerClass4", "客运量四类", 110));
        H2031_COLUMNS.add(col("passengerCharter", "客运量包车", 110));
        H2031_COLUMNS.add(col("turnoverClass1", "周转量一类", 110));
        H2031_COLUMNS.add(col("turnoverClass2", "周转量二类", 110));
        H2031_COLUMNS.add(col("turnoverClass3", "周转量三类", 110));
        H2031_COLUMNS.add(col("turnoverClass4", "周转量四类", 110));
        H2031_COLUMNS.add(col("turnoverCharter", "周转量包车", 110));
        H2031_COLUMNS.add(col("avgDistanceTotal", "平均运距合计", 120));
        H2031_COLUMNS.add(col("avgDistanceClass1", "一类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceClass2", "二类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceClass3", "三类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceClass4", "四类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceCharter", "包车平均运距", 120));
        BUS_COLUMNS.add(col("reportPeriod", "报表期", 100));
        BUS_COLUMNS.add(col("regionCode", "所属地区", 100));
        BUS_COLUMNS.add(col("city", "市州", 110));
        BUS_COLUMNS.add(col("enterpriseName", "企业名称", 220));
        BUS_COLUMNS.add(col("opVehicles", "运营车数", 100));
        BUS_COLUMNS.add(col("stopTotal", "站点总个数", 110));
        BUS_COLUMNS.add(col("stopCity", "城市内站点", 110));
        BUS_COLUMNS.add(col("passengerVolume", "客运量", 100));
        BUS_COLUMNS.add(col("passengerCity", "城市内客运量", 120));
        BUS_COLUMNS.add(col("turnover", "旅客周转量", 110));
        BUS_COLUMNS.add(col("turnoverCity", "城市内周转量", 120));
        BUS_COLUMNS.add(col("avgDistance", "平均运距", 100));
        BUS_COLUMNS.add(col("avgDistanceCity", "城市内平均运距", 130));
        BUS_COLUMNS.add(col("passengerChengxiang", "城际城乡客运量", 130));
        BUS_COLUMNS.add(col("turnoverChengxiang", "城际城乡周转量", 130));
        BUS_COLUMNS.add(col("avgDistanceChengxiang", "城际城乡平均运距", 140));
        BUS_COLUMNS.add(col("ratePassengerMom", "客运量环比", 100));
        BUS_COLUMNS.add(col("ratePassengerCityMom", "城市内环比", 100));
        BUS_COLUMNS.add(col("rateChengxiangMom", "城际城乡环比", 110));
        BUS_COLUMNS.add(col("ratePassengerYoy", "客运量同比", 100));
        BUS_COLUMNS.add(col("passengerCityRatio", "城市内占比", 100));
        BUS_COLUMNS.add(col("chengxiangRatio", "城际城乡占比", 110));
        BUS_COLUMNS.add(col("contactPerson", "填表人", 100));
        BUS_COLUMNS.add(col("reportDate", "报出日期", 110));
        BUS_COLUMNS.add(col("verifyExplanation", "核实解释", 220));
        TAXI_COLUMNS.add(col("reportPeriod", "报表期", 100));
        TAXI_COLUMNS.add(col("regionCode", "所属地区", 100));
        TAXI_COLUMNS.add(col("city", "市州", 110));
        TAXI_COLUMNS.add(col("tripTotal", "载客车次总数", 120));
        TAXI_COLUMNS.add(col("tripCity", "载客车次_城市内", 130));
        TAXI_COLUMNS.add(col("passengerVolume", "客运量", 100));
        TAXI_COLUMNS.add(col("passengerCity", "城市内客运量", 120));
        TAXI_COLUMNS.add(col("turnover", "旅客周转量", 110));
        TAXI_COLUMNS.add(col("turnoverCity", "城市内周转量", 120));
        TAXI_COLUMNS.add(col("opVehicles", "运营车辆数", 110));
        TAXI_COLUMNS.add(col("avgDistance", "平均运距", 100));
        TAXI_COLUMNS.add(col("avgDistanceCity", "城市内平均运距", 130));
        TAXI_COLUMNS.add(col("passengersPerTrip", "单车次载客人数", 130));
        TAXI_COLUMNS.add(col("rateTripMom", "载客车次环比", 110));
        TAXI_COLUMNS.add(col("rateTripYoy", "载客车次同比", 110));
        TAXI_COLUMNS.add(col("ratePassengerMom", "客运量环比", 100));
        TAXI_COLUMNS.add(col("ratePassengerYoy", "客运量同比", 100));
        TAXI_COLUMNS.add(col("passengerCityRatio", "城市内客运量占比", 140));
        TAXI_COLUMNS.add(col("avgDistanceChengxiang", "城际城乡平均运距", 140));
        TAXI_COLUMNS.add(col("verifyExplanation", "核实解释", 220));
        TAXI_AUTH_COLUMNS.add(col("reportPeriod", "报表期", 100));
        TAXI_AUTH_COLUMNS.add(col("city", "市州", 110));
        TAXI_AUTH_COLUMNS.add(col("plateNo", "车牌号码", 120));
        TAXI_AUTH_COLUMNS.add(col("vehicleType", "车辆类型", 110));
        TAXI_AUTH_COLUMNS.add(col("fuelType", "燃料类型", 100));
        TAXI_AUTH_COLUMNS.add(col("opStatus", "营运状态", 100));
        TAXI_AUTH_COLUMNS.add(col("certStatus", "证件状态", 100));
        TAXI_AUTH_COLUMNS.add(col("licenseNo", "经营权号", 130));
        TAXI_AUTH_COLUMNS.add(col("archiveNo", "档案号", 130));
        TAXI_AUTH_COLUMNS.add(col("roadCertNo", "道路运输证字号", 150));
        TAXI_AUTH_COLUMNS.add(col("operatorName", "业户名称", 240));
        TAXI_AUTH_COLUMNS.add(col("operatorAddr", "业户地址", 280));
        PAUTH_COLUMNS.add(col("reportPeriod", "报表期", 100));
        PAUTH_COLUMNS.add(col("enterpriseCode", "企业代码", 130));
        PAUTH_COLUMNS.add(col("enterpriseName", "企业名称", 240));
        PAUTH_COLUMNS.add(col("vehicleCount", "车辆数", 100));
        PAUTH_COLUMNS.add(col("seatCount", "载客位数", 100));
        INVEST_MONTHLY_COLUMNS.add(col("reportPeriod", "报表期", 100));
        INVEST_MONTHLY_COLUMNS.add(col("projectId", "项目ID", 80));
        INVEST_MONTHLY_COLUMNS.add(col("yearPlan", "本年计划投资(万元)", 140));
        INVEST_MONTHLY_COLUMNS.add(col("yearCum", "自年初累计完成(万元)", 160));
        INVEST_MONTHLY_COLUMNS.add(col("monthDone", "本月完成投资(万元)", 150));
        INVEST_MONTHLY_COLUMNS.add(col("startCum", "自开始建设累计完成(万元)", 180));
        INVEST_MONTHLY_COLUMNS.add(col("progressStage", "建设阶段", 120));
        INVEST_MONTHLY_COLUMNS.add(col("progressDesc", "形象进度", 320));
        INVEST_MONTHLY_COLUMNS.add(col("buildingArea", "建筑面积", 110));
        INVEST_PROJECT_COLUMNS.add(col("projectName", "项目名称", 260));
        INVEST_PROJECT_COLUMNS.add(col("category", "类别", 100));
        INVEST_PROJECT_COLUMNS.add(col("city", "市州", 90));
        INVEST_PROJECT_COLUMNS.add(col("county", "县（市、区）", 120));
        INVEST_PROJECT_COLUMNS.add(col("builderName", "建设单位", 200));
        INVEST_PROJECT_COLUMNS.add(col("constructNature", "建设性质", 100));
        INVEST_PROJECT_COLUMNS.add(col("startTime", "开工年", 90));
        INVEST_PROJECT_COLUMNS.add(col("endTime", "完工年", 90));
        INVEST_PROJECT_COLUMNS.add(col("totalInvestment", "总投资(万元)", 130));
        INVEST_PROJECT_COLUMNS.add(col("buildingArea", "建筑面积", 110));
        INVEST_PROJECT_COLUMNS.add(col("approvalGk", "工可或核准批复文号", 200));
        INVEST_PROJECT_COLUMNS.add(col("approvalCs", "初设或施工图批复文号", 200));
        INVEST_PROJECT_COLUMNS.add(col("source", "来源", 100));
        INVEST_SYSTEM_COLUMNS.add(col("reportPeriod", "报表期", 100));
        INVEST_SYSTEM_COLUMNS.add(col("projectName", "项目名称", 260));
        INVEST_SYSTEM_COLUMNS.add(col("totalInvestment", "总投资(万元)", 130));
        INVEST_SYSTEM_COLUMNS.add(col("startCum", "自开始建设累计完成(万元)", 180));
        INVEST_SYSTEM_COLUMNS.add(col("yearPlan", "本年计划投资(万元)", 140));
        INVEST_SYSTEM_COLUMNS.add(col("yearCum", "自年初累计完成(万元)", 160));
        INVEST_SYSTEM_COLUMNS.add(col("monthDone", "本月完成投资(万元)", 150));
        ENERGY_VEHICLE_COLUMNS.add(col("reportPeriod", "报表期", 100));
        ENERGY_VEHICLE_COLUMNS.add(col("regionCode", "所属地区", 100));
        ENERGY_VEHICLE_COLUMNS.add(col("enterpriseName", "企业名称", 220));
        ENERGY_VEHICLE_COLUMNS.add(col("plateNo", "车牌号", 110));
        ENERGY_VEHICLE_COLUMNS.add(col("vehicleType", "车辆类型", 130));
        ENERGY_VEHICLE_COLUMNS.add(col("fuelType", "燃料类型", 110));
        ENERGY_VEHICLE_COLUMNS.add(col("manufactureYear", "出厂年份", 100));
        ENERGY_VEHICLE_COLUMNS.add(col("markedTonnage", "标记吨位", 100));
        ENERGY_VEHICLE_COLUMNS.add(col("totalMileage", "总行驶里程(公里)", 150));
        ENERGY_VEHICLE_COLUMNS.add(col("loadedMileage", "重载里程(公里)", 140));
        ENERGY_VEHICLE_COLUMNS.add(col("emptyMileage", "空载里程(公里)", 140));
        ENERGY_VEHICLE_COLUMNS.add(col("freight", "货运量(吨)", 120));
        ENERGY_VEHICLE_COLUMNS.add(col("turnover", "周转量(吨公里)", 140));
        ENERGY_VEHICLE_COLUMNS.add(col("tripCount", "车次", 90));
        ENERGY_VEHICLE_COLUMNS.add(col("fuelUnit", "燃料单位", 100));
        ENERGY_VEHICLE_COLUMNS.add(col("fuelConsumption", "燃料消耗量", 120));
        ENERGY_VEHICLE_COLUMNS.add(col("avgDistance", "平均运距", 110));
        ENERGY_VEHICLE_COLUMNS.add(col("avgLoadedTonnage", "平均载重吨位", 130));
        ENERGY_VEHICLE_COLUMNS.add(col("avgTripMileage", "平均车次里程", 130));
        ENERGY_VEHICLE_COLUMNS.add(col("fuelPer100km", "百公里油耗", 120));
        ENERGY_VEHICLE_COLUMNS.add(col("turnoverFuel", "周转量油耗", 120));
        ENERGY_AUTH_COLUMNS.add(col("reportPeriod", "报表期", 100));
        ENERGY_AUTH_COLUMNS.add(col("plateNo", "车牌号", 110));
        ENERGY_AUTH_COLUMNS.add(col("vehicleType", "车辆类型", 130));
        ENERGY_AUTH_COLUMNS.add(col("fuelType", "燃料类型", 110));
        ENERGY_AUTH_COLUMNS.add(col("markedTonnage", "标记吨位", 100));
        ENERGY_AUTH_COLUMNS.add(col("tractionQuality", "牵引质量", 110));

        PAX_INDIVIDUAL_COLUMNS.add(col("reportPeriod", "报表期", 100));
        PAX_INDIVIDUAL_COLUMNS.add(col("regionCode", "所属地区", 110));
        PAX_INDIVIDUAL_COLUMNS.add(col("city", "市州", 110));
        PAX_INDIVIDUAL_COLUMNS.add(col("enterpriseCode", "企业代码", 130));
        PAX_INDIVIDUAL_COLUMNS.add(col("enterpriseName", "企业名称", 220));
        PAX_INDIVIDUAL_COLUMNS.add(col("passengerCount", "个体客运量", 130));
        PAX_INDIVIDUAL_COLUMNS.add(col("turnover", "个体旅客周转量", 150));

        WYC_TOTAL_COLUMNS.add(col("reportPeriod", "报表期", 100));
        WYC_TOTAL_COLUMNS.add(col("pinK", "全省网约车客运量(万人次)", 210));
        WYC_TOTAL_COLUMNS.add(col("pinCK", "其中城市内客运量(万人次)", 210));
        WYC_TOTAL_COLUMNS.add(col("pinZ", "全省网约车周转量(万人公里)", 220));
        WYC_TOTAL_COLUMNS.add(col("pinCZ", "其中城市内周转量(万人公里)", 220));

        WYC_ORDER_COLUMNS.add(col("reportPeriod", "报表期", 100));
        WYC_ORDER_COLUMNS.add(col("pinK", "全省客运量(万人次)", 170));
        WYC_ORDER_COLUMNS.add(col("pinCK", "其中城市内客运量", 170));
        WYC_ORDER_COLUMNS.add(col("pinZ", "全省周转量(万人公里)", 180));
        WYC_ORDER_COLUMNS.add(col("pinCZ", "其中城市内周转量", 170));
        WYC_ORDER_COLUMNS.add(col("orderSum", "订单合计(单)", 130));
        String[] wycOrderCityProps = { "orderWuhan", "orderHuangshi", "orderShiyan", "orderYichang", "orderXiangyang",
                "orderEzhou", "orderJingmen", "orderXiaogan", "orderJingzhou", "orderHuanggang", "orderXianning",
                "orderSuizhou", "orderEnshi", "orderXiantao", "orderQianjiang", "orderTianmen", "orderShennong" };
        String[] wycOrderCityNames = { "武汉", "黄石", "十堰", "宜昌", "襄阳", "鄂州", "荆门", "孝感", "荆州", "黄冈",
                "咸宁", "随州", "恩施", "仙桃", "潜江", "天门", "神农架" };
        for (int i = 0; i < wycOrderCityProps.length; i++) {
            WYC_ORDER_COLUMNS.add(col(wycOrderCityProps[i], wycOrderCityNames[i] + "订单(单)", 120));
        }

    }
}