逻辑修正 (1edf7882) | Commits | 潘钊 / control_service_data_Interface

Browse Code »

Commit 1edf78821e14c6f1e954c1fff33b9b54a5467dc1

Authored by Hill 2018-12-10 09:24:53 +0800

1 parent c2d036f4

build: skipped

逻辑修正

Inline Side-by-side

Showing 1 changed file with 1059 additions and 1036 deletions

src/main/java/com/bsth/server_ws/util/WSDataConver.java

View file @1edf788

1		-package com.bsth.server_ws.util;
2		-
3		-import java.lang.reflect.Field;
4		-import java.text.ParseException;
5		-import java.text.SimpleDateFormat;
6		-import java.util.ArrayList;
7		-import java.util.Calendar;
8		-import java.util.Collections;
9		-import java.util.Comparator;
10		-import java.util.Date;
11		-import java.util.HashMap;
12		-import java.util.List;
13		-import java.util.Map;
14		-import java.util.Set;
15		-
16		-import org.apache.commons.lang3.StringUtils;
17		-import org.slf4j.Logger;
18		-import org.slf4j.LoggerFactory;
19		-
20		-import com.bsth.entity.DutyEmployee;
21		-import com.bsth.entity.ElecInfo;
22		-import com.bsth.entity.OilInfo;
23		-import com.bsth.entity.SchedulePlanInfo;
24		-import com.bsth.entity.ScheduleRealInfo;
25		-import com.bsth.server_ws.attendance.entity.Jsy_attendance;
26		-import com.bsth.server_ws.park_station.dto.LsLcPb;
27		-import com.bsth.server_ws.waybill.entity.NH_waybill;
28		-import com.bsth.server_ws.waybill.entity.NH_waybillItem;
29		-import com.bsth.server_ws.waybill.entity.SN_lossMileage;
30		-import com.bsth.server_ws.waybill.entity.SN_waybill;
31		-import com.bsth.server_ws.waybill.entity.SN_waybillItem;
32		-import com.bsth.util.Arith;
33		-import com.bsth.util.ConvertUtil;
34		-import com.google.common.collect.ArrayListMultimap;
35		-
36		-/**
37		- * Created by panzhao on 2017/3/15.
38		- */
39		-public class WSDataConver {
40		-
41		- /**
42		- * 格式编码和名称映射，与老系统保持一致
43		- */
44		- private static Map<String, String> gsMap;
45		-
46		- static Logger logger = LoggerFactory.getLogger(WSDataConver.class);
47		-
48		- static {
49		- gsMap = new HashMap<>();
50		- gsMap.put("55", "上南公司");
51		- gsMap.put("55_4", "上南一分公司");
52		- gsMap.put("55_3", "上南六分公司");
53		- gsMap.put("55_1", "上南二分公司");
54		- gsMap.put("55_2", "上南三分公司");
55		- gsMap.put("22", "金高公司");
56		- gsMap.put("22_2", "二分公司");
57		- gsMap.put("22_1", "四分公司");
58		- gsMap.put("22_3", "三分公司");
59		- gsMap.put("22_5", "一分公司");
60		- gsMap.put("05", "杨高公司");
61		- gsMap.put("05_5", "杨高分公司");
62		- gsMap.put("05_6", "周浦分公司");
63		- gsMap.put("05_3", "芦潮港分公司");
64		- gsMap.put("05_1", "川沙分公司");
65		- gsMap.put("26", "南汇公司");
66		- gsMap.put("26_3", "南汇三分");
67		- gsMap.put("26_2", "南汇二分");
68		- gsMap.put("26_1", "南汇一分");
69		- gsMap.put("26_4", "南汇维修公司");
70		- }
71		-
72		- /**
73		- * 将班次list 转换成 getCurrentDayPlan 函数需要的格式
74		- *
75		- * @param list
76		- * @return [0：日期，1：线路名称，2：路牌名称，3：车辆自编号，4：，5：，6：起点时间，7：终点时间，8：起点站名称，9：终点站名称，10：班次类型]
77		- */
78		- public static String[] to_getCurrentDayPlan(List<ScheduleRealInfo> list) {
79		- if (list == null \|\| list.size() == 0)
80		- return new String[0];
81		-
82		- Map<String, String> bcTypeMap = new HashMap<>();
83		- bcTypeMap.put("out", "出场");
84		- bcTypeMap.put("in", "进场");
85		-
86		- String[] array = new String[list.size()];
87		- StringBuilder sb;
88		- ScheduleRealInfo sch;
89		- int len = list.size();
90		- for(int i = 0; i < len; i ++){
91		- sb = new StringBuilder();
92		- sch = list.get(i);
93		- sb.append(sch.getScheduleDateStr() + ",");
94		- sb.append(sch.getXlName() + ",");
95		- sb.append(sch.getLpName() + ",");
96		- sb.append(sch.getClZbh() + ",");
97		- sb.append(",");
98		- sb.append(",");
99		- sb.append(sch.getDfsj() + ",");
100		- sb.append(sch.getZdsj() + ",");
101		- sb.append(sch.getQdzName() + ",");
102		- sb.append(sch.getZdzName() + ",");
103		- sb.append(bcTypeMap.containsKey(sch.getBcType())?bcTypeMap.get(sch.getBcType()):"");
104		-
105		- array[i] = sb.toString();
106		- }
107		- return array;
108		- }
109		-
110		- /**
111		- * 将班次list 转换成 returnCCInfo 和 returnJCInfo 函数需要的格式
112		- *
113		- * @param list
114		- * @return [0: 日期, 1: 线路编码, 2: 线路名称, 3: 公司名称, 4: 分公司名称, 5: 路牌, 6: 起点站, 7: 起点计划时间,
115		- * 8: 起点实际时间, 9: 终点站, 10: 终点计划时间, 11: 终点实际时间, 12: 计划里程, 13: 实际里程,
116		- * 14: 驾驶员, 15: 售票员, 16: 车辆内部编码, 17: 状态（1 为出场。2为进场）, 18: 驾驶员名称, 19: 进场顺序号]
117		- */
118		- public static String[] to_returnJCCInfo(List<ScheduleRealInfo> list) {
119		- if(list == null)
120		- return new String[0];
121		-
122		- int size = list.size();
123		- String[] array = new String[size];
124		-
125		- ScheduleRealInfo sch;
126		- StringBuffer sb;
127		- for (int i = 0; i < size; i++) {
128		- sb = new StringBuffer(",");
129		-
130		- sch = list.get(i);
131		- sb.append(sch.getScheduleDateStr() + ",");
132		- sb.append(sch.getXlBm() + ",");
133		- sb.append(sch.getXlName() + ",");
134		- sb.append(gsMap.get(sch.getGsBm()) + ",");
135		- sb.append(gsMap.get(sch.getGsBm() + "_" + sch.getFgsBm()) + ",");
136		- sb.append(sch.getLpName() + ",");
137		- sb.append(sch.getQdzCode() + ",");
138		- sb.append(sch.getDfsj() + ",");
139		- sb.append(nvlGetVal(sch.getFcsjActual()) + ",");
140		- sb.append(sch.getZdzCode() + ",");
141		- sb.append(sch.getZdsj() + ",");
142		- sb.append(nvlGetVal(sch.getZdsjActual()) + ",");
143		- sb.append(nvlGetVal(sch.getJhlc()) + ",");
144		- sb.append(nvlGetVal(sch.getJhlc()) + ",");
145		- sb.append(sch.getjGh() + ",");
146		- sb.append(nvlGetVal(sch.getsGh()) + ",");
147		- sb.append(sch.getClZbh() + ",");
148		- sb.append((sch.getBcType().equals("out") ? 1 : 2) + ",");
149		- sb.append(sch.getjName() + ",");
150		- //用ID替代老系统的出场顺序号
151		- sb.append(sch.getId() + ",");
152		-
153		- array[i] = sb.substring(1).toString();
154		- }
155		- return array;
156		- }
157		-
158		- public static String nvlGetVal(Object val) {
159		- return val == null ? "" : val.toString();
160		- }
161		-
162		- /**
163		- * 将实际排班和油耗数据转换成南汇路单需要的数据格式
164		- *
165		- * @param listMap
166		- * @param oilInfoMap
167		- * @return
168		- */
169		- public static NH_waybill[] to_waybill_NH(ArrayListMultimap<String, ScheduleRealInfo> listMap, Map<String, OilInfo> oilInfoMap, List<DutyEmployee> des) throws NoSuchFieldException {
170		- List<String> nbbmArray = new ArrayList<>(listMap.keySet());
171		-
172		- NH_waybill[] rs = new NH_waybill[nbbmArray.size()];
173		- Field jGhField = ScheduleRealInfo.class.getDeclaredField("jGh");
174		- //Field lpField = ScheduleRealInfo.class.getDeclaredField("lpName");
175		-
176		- List<ScheduleRealInfo> list;
177		- ArrayListMultimap<String, ScheduleRealInfo> jGhListMap;
178		- ScheduleRealInfo sch;
179		- NH_waybill nh_waybill;
180		- NH_waybillItem nh_waybillItem;
181		- OilInfo oilInfo;
182		- for (int i = 0; i < nbbmArray.size(); i++) {
183		- list = listMap.get(nbbmArray.get(i));
184		- if (list.size() == 0)
185		- continue;
186		- //班次信息
187		- nh_waybill = new NH_waybill();
188		- sch = list.get(0);
189		- //日期
190		- nh_waybill.setM_strYYRQ(sch.getScheduleDateStr());
191		- //车辆自编号
192		- nh_waybill.setM_strNBBM(sch.getClZbh());
193		- //线路编码
194		- nh_waybill.setM_strXLBM(sch.getXlBm());
195		- nh_waybill.setM_SubInfos(new ArrayList<NH_waybillItem>());
196		-
197		- //按驾驶员分组班次，构造路单子项
198		- jGhListMap = new ConvertUtil<ScheduleRealInfo>().groupMultiList(list, "_", jGhField);
199		- for (String jGh : jGhListMap.keySet()) {
200		- list = jGhListMap.get(jGh);
201		- nh_waybillItem = new NH_waybillItem();
202		- //计划里程
203		- nh_waybillItem.setM_dblJHLC(ScheduleCalculator.calcJHLC(list));
204		- //实际计划公里
205		- nh_waybillItem.setM_dblSJJHLC(ScheduleCalculator.calcSJLC(list));
206		- //实际出场里程
207		- nh_waybillItem.setM_dblCCLC(ScheduleCalculator.calcCCLC(list));
208		- //实际进场里程
209		- nh_waybillItem.setM_dblJCLC(ScheduleCalculator.calcJCLC(list));
210		- //营业公里
211		- nh_waybillItem.setM_dblYYLC(ScheduleCalculator.calcYYLC(list));
212		- //空驶公里
213		- nh_waybillItem.setM_dblKSLC(ScheduleCalculator.calcKSLC(list));
214		- //抽减公里
215		- nh_waybillItem.setM_dblCJLC(ScheduleCalculator.calcCJLC(list));
216		- //烂班公里
217		- nh_waybillItem.setM_dblLBLC(ScheduleCalculator.calcLBLC(list));
218		- //增加公里
219		- nh_waybillItem.setM_dblZJLC(ScheduleCalculator.calcZJLC(list));
220		- //总公里
221		- nh_waybillItem.setM_dblZLC(ScheduleCalculator.calcZLC(list));
222		- //烂班公里原因
223		- nh_waybillItem.setM_strLBYY(ScheduleCalculator.joinLBYY(list));
224		- //抽减公里原因
225		- nh_waybillItem.setM_strCJYY(ScheduleCalculator.joinCJYY(list));
226		- //计划班次
227		- nh_waybillItem.setM_intJHBC(ScheduleCalculator.countJHBC(list));
228		- //实际计划班次
229		- nh_waybillItem.setM_intSJJHBC(ScheduleCalculator.countSJJHBC(list));
230		- //实际班次 ————> 暂时和实际计划班次相同
231		- nh_waybillItem.setM_intSJBC(ScheduleCalculator.countSJJHBC(list));
232		- //增加班次
233		- nh_waybillItem.setM_intZJBC(ScheduleCalculator.countZJBC(list));
234		- //抽减班次
235		- nh_waybillItem.setM_intCJBC(ScheduleCalculator.countCJBC(list));
236		- //烂班工时
237		- nh_waybillItem.setM_dblLBGS(ScheduleCalculator.calcLBGS(list));
238		- //路牌
239		- nh_waybillItem.setM_strLP(list.get(0).getLpName());
240		- //驾驶员工号
241		- nh_waybillItem.setM_strJSY(list.get(0).getjGh());
242		- //售票员工号
243		- nh_waybillItem.setM_strSPY("");
244		- for (ScheduleRealInfo sri : list) {
245		- if (StringUtils.isNotEmpty(sri.getsGh())) {
246		- nh_waybillItem.setM_strSPY(sri.getsGh());
247		- break;
248		- }
249		- }
250		- //驾驶员考勤
251		- nh_waybillItem.setM_strJSYKQ("");
252		- //售票员考勤
253		- nh_waybillItem.setM_strSPYKQ("");
254		- //当班调度员
255		- nh_waybillItem.setM_strDDY(ScheduleCalculator.calcDDY(list, des));
256		- //营运状态
257		- nh_waybillItem.setM_strYYZT("");
258		- //备注
259		- nh_waybillItem.setM_strBZ("");
260		-
261		- oilInfo = oilInfoMap.get(list.get(0).getClZbh() + "_" + list.get(0).getjGh());
262		- if (oilInfo != null) {
263		- //出场存油
264		- nh_waybillItem.setM_dblCCCY(oilInfo.getCzyl());
265		- //进场存油
266		- nh_waybillItem.setM_dblJCCY(oilInfo.getJzyl());
267		- //加注量1
268		- nh_waybillItem.setM_dblJZL1(oilInfo.getJzl());
269		- //加注量2
270		- nh_waybillItem.setM_dblJZL2(0.0);
271		- //尿素
272		- nh_waybillItem.setM_dblNS(oilInfo.getNs());
273		- //消耗量
274		- nh_waybillItem.setM_dblYH(oilInfo.getYh());
275		- //加油地点1
276		- nh_waybillItem.setM_strJYD1("");
277		- //加油地点2
278		- nh_waybillItem.setM_strJYD2("");
279		- //加油工工号1
280		- nh_waybillItem.setM_strJYG1("");
281		- //加油工工号1
282		- nh_waybillItem.setM_strJYG2("");
283		- //油耗类型1
284		- nh_waybillItem.setM_strYHLX1(oilInfo.getRylx());
285		- //油耗类型2
286		- nh_waybillItem.setM_strYHLX1("");
287		- }
288		-
289		- nh_waybill.getM_SubInfos().add(nh_waybillItem);
290		- }
291		-
292		- rs[i] = nh_waybill;
293		- }
294		- return rs;
295		- }
296		-
297		- /**
298		- * 将实际排班、油耗数据、电量数据转换成南汇路单需要的数据格式
299		- *
300		- * @param listMap
301		- * @param oilInfoMap
302		- * @return
303		- */
304		- public static NH_waybill[] to_waybill_NH4TH(ArrayListMultimap<String, ScheduleRealInfo> listMap, Map<String, OilInfo> oilInfoMap, Map<String, ElecInfo> elecInfoMap, List<DutyEmployee> des) throws NoSuchFieldException {
305		- List<String> nbbmArray = new ArrayList<>(listMap.keySet());
306		-
307		- NH_waybill[] rs = new NH_waybill[nbbmArray.size()];
308		- Field jGhField = ScheduleRealInfo.class.getDeclaredField("jGh");
309		- //Field lpField = ScheduleRealInfo.class.getDeclaredField("lpName");
310		-
311		- List<ScheduleRealInfo> list;
312		- ArrayListMultimap<String, ScheduleRealInfo> jGhListMap;
313		- ScheduleRealInfo sch;
314		- NH_waybill nh_waybill;
315		- NH_waybillItem nh_waybillItem;
316		- OilInfo oilInfo;
317		- ElecInfo elecInfo;
318		- for (int i = 0; i < nbbmArray.size(); i++) {
319		- list = listMap.get(nbbmArray.get(i));
320		- if (list.size() == 0)
321		- continue;
322		- //班次信息
323		- nh_waybill = new NH_waybill();
324		- sch = list.get(0);
325		- //日期
326		- nh_waybill.setM_strYYRQ(sch.getScheduleDateStr());
327		- //车辆自编号
328		- nh_waybill.setM_strNBBM(sch.getClZbh());
329		- //线路编码
330		- nh_waybill.setM_strXLBM(sch.getXlBm());
331		- nh_waybill.setM_SubInfos(new ArrayList<NH_waybillItem>());
332		-
333		- //按驾驶员分组班次，构造路单子项
334		- jGhListMap = new ConvertUtil<ScheduleRealInfo>().groupMultiList(list, "_", jGhField);
335		- for (String jGh : jGhListMap.keySet()) {
336		- list = jGhListMap.get(jGh);
337		- nh_waybillItem = new NH_waybillItem();
338		- //计划里程
339		- nh_waybillItem.setM_dblJHLC(ScheduleCalculator.calcJHLC(list));
340		- //实际计划公里
341		- nh_waybillItem.setM_dblSJJHLC(ScheduleCalculator.calcSJLC(list));
342		- //实际出场里程
343		- nh_waybillItem.setM_dblCCLC(ScheduleCalculator.calcCCLC(list));
344		- //实际进场里程
345		- nh_waybillItem.setM_dblJCLC(ScheduleCalculator.calcJCLC(list));
346		- //营业公里
347		- nh_waybillItem.setM_dblYYLC(ScheduleCalculator.calcYYLC(list));
348		- //空驶公里
349		- nh_waybillItem.setM_dblKSLC(ScheduleCalculator.calcKSLC(list));
350		- //抽减公里
351		- nh_waybillItem.setM_dblCJLC(ScheduleCalculator.calcCJLC(list));
352		- //烂班公里
353		- nh_waybillItem.setM_dblLBLC(ScheduleCalculator.calcLBLC(list));
354		- //增加公里
355		- nh_waybillItem.setM_dblZJLC(ScheduleCalculator.calcZJLC(list));
356		- //总公里
357		- nh_waybillItem.setM_dblZLC(ScheduleCalculator.calcZLC(list));
358		- //烂班公里原因
359		- nh_waybillItem.setM_strLBYY(ScheduleCalculator.joinLBYY(list));
360		- //抽减公里原因
361		- nh_waybillItem.setM_strCJYY(ScheduleCalculator.joinCJYY(list));
362		- //计划班次
363		- nh_waybillItem.setM_intJHBC(ScheduleCalculator.countJHBC(list));
364		- //实际计划班次
365		- nh_waybillItem.setM_intSJJHBC(ScheduleCalculator.countSJJHBC(list));
366		- //实际班次 ————> 暂时和实际计划班次相同
367		- nh_waybillItem.setM_intSJBC(ScheduleCalculator.countSJJHBC(list));
368		- //增加班次
369		- nh_waybillItem.setM_intZJBC(ScheduleCalculator.countZJBC(list));
370		- //抽减班次
371		- nh_waybillItem.setM_intCJBC(ScheduleCalculator.countCJBC(list));
372		- //烂班工时
373		- nh_waybillItem.setM_dblLBGS(ScheduleCalculator.calcLBGS(list));
374		- //路牌
375		- nh_waybillItem.setM_strLP(list.get(0).getLpName());
376		- //驾驶员工号
377		- nh_waybillItem.setM_strJSY(list.get(0).getjGh());
378		- //售票员工号
379		- nh_waybillItem.setM_strSPY("");
380		- for (ScheduleRealInfo sri : list) {
381		- if (StringUtils.isNotEmpty(sri.getsGh())) {
382		- nh_waybillItem.setM_strSPY(sri.getsGh());
383		- break;
384		- }
385		- }
386		- //驾驶员考勤
387		- nh_waybillItem.setM_strJSYKQ("");
388		- //售票员考勤
389		- nh_waybillItem.setM_strSPYKQ("");
390		- //当班调度员
391		- nh_waybillItem.setM_strDDY(ScheduleCalculator.calcDDY(list, des));
392		- //营运状态
393		- nh_waybillItem.setM_strYYZT("");
394		- //备注
395		- nh_waybillItem.setM_strBZ("");
396		-
397		- oilInfo = oilInfoMap.get(list.get(0).getClZbh() + "_" + list.get(0).getjGh());
398		- if (oilInfo != null) {
399		- //出场存油
400		- nh_waybillItem.setM_dblCCCY(oilInfo.getCzyl());
401		- //进场存油
402		- nh_waybillItem.setM_dblJCCY(oilInfo.getJzyl());
403		- //加注量1
404		- nh_waybillItem.setM_dblJZL1(oilInfo.getJzl());
405		- //加注量2
406		- nh_waybillItem.setM_dblJZL2(0.0);
407		- //尿素
408		- nh_waybillItem.setM_dblNS(oilInfo.getNs());
409		- //消耗量
410		- nh_waybillItem.setM_dblYH(oilInfo.getYh());
411		- //加油地点1
412		- nh_waybillItem.setM_strJYD1("");
413		- //加油地点2
414		- nh_waybillItem.setM_strJYD2("");
415		- //加油工工号1
416		- nh_waybillItem.setM_strJYG1("");
417		- //加油工工号1
418		- nh_waybillItem.setM_strJYG2("");
419		- //油耗类型1
420		- nh_waybillItem.setM_strYHLX1(oilInfo.getRylx());
421		- //油耗类型2
422		- nh_waybillItem.setM_strYHLX1("");
423		- }
424		-
425		- elecInfo = elecInfoMap.get(list.get(0).getClZbh() + "_" + list.get(0).getjGh());
426		- if (elecInfo != null) {
427		- //出场存油
428		- nh_waybillItem.setM_dblCCCY(100.0);
429		- //进场存油
430		- nh_waybillItem.setM_dblJCCY(100.0);
431		- //加注量1
432		- nh_waybillItem.setM_dblJZL1(elecInfo.getCdl());
433		- //加注量2
434		- nh_waybillItem.setM_dblJZL2(0.0);
435		- //尿素
436		- nh_waybillItem.setM_dblNS(0.0);
437		- //消耗量
438		- nh_waybillItem.setM_dblYH(elecInfo.getHd());
439		- //加油地点1
440		- nh_waybillItem.setM_strJYD1("");
441		- //加油地点2
442		- nh_waybillItem.setM_strJYD2("");
443		- //加油工工号1
444		- nh_waybillItem.setM_strJYG1("");
445		- //加油工工号1
446		- nh_waybillItem.setM_strJYG2("");
447		- //油耗类型1
448		- nh_waybillItem.setM_strYHLX1("");
449		- //油耗类型2
450		- nh_waybillItem.setM_strYHLX1("");
451		- }
452		-
453		- nh_waybill.getM_SubInfos().add(nh_waybillItem);
454		- }
455		-
456		- rs[i] = nh_waybill;
457		- }
458		- return rs;
459		- }
460		-
461		-
462		- /**
463		- * 将实际排班和油耗数据转换成上南路单需要的数据格式
464		- *
465		- * @param listMap
466		- * @param oilInfoMap
467		- * @return
468		- */
469		- public static SN_waybill[] to_waybill_SN(ArrayListMultimap<String, ScheduleRealInfo> listMap, Map<String, OilInfo> oilInfoMap) throws NoSuchFieldException {
470		-
471		- List<String> nbbmArray = new ArrayList<>(listMap.keySet());
472		- SN_waybill[] rs = new SN_waybill[nbbmArray.size()];
473		- Field jGhField = ScheduleRealInfo.class.getDeclaredField("jGh");
474		-
475		- List<ScheduleRealInfo> list;
476		- ArrayListMultimap<String, ScheduleRealInfo> jGhListMap;
477		- ScheduleRealInfo sch;
478		- SN_waybill sn_waybill;
479		- SN_waybillItem sn_waybillItem;
480		-
481		- OilComp oilComp = new OilComp();
482		- List<OilInfo> oilArray;
483		- for (int i = 0; i < nbbmArray.size(); i++) {
484		- list = listMap.get(nbbmArray.get(i));
485		- if (list.size() == 0)
486		- continue;
487		-
488		- sch = list.get(0);
489		- sn_waybill = new SN_waybill();
490		- sn_waybill.setLine_no(sch.getXlBm());
491		- sn_waybill.setWork_date(sch.getScheduleDateStr());
492		- sn_waybill.setComp_id(sch.getFgsBm());
493		- sn_waybill.setGuidecard(sch.getLpName());
494		- sn_waybill.setCar_id(sch.getClZbh());
495		- //实际班次
496		- sn_waybill.setAct_num(ScheduleCalculator.countSJJHBC(list));
497		- //晚班实际班次
498		- sn_waybill.setL_act_num(ScheduleCalculator.countSJJHBC(ScheduleCalculator.lastArray(list)));
499		- //营业里程
500		- sn_waybill.setWork_way(ScheduleCalculator.calcYYLC(list));
501		- //空驶里程
502		- sn_waybill.setLeisure_way(ScheduleCalculator.calcKSLC(list));
503		- //总里程
504		- sn_waybill.setCount_way(ScheduleCalculator.calcZLC(list));
505		- //路单类型(0普通,1包车)
506		- sn_waybill.setLd_type("0");
507		- //油料类型(2、柴油 3、天然气 4、汽油柴油 5、液化气 6、液化气汽油 7、液化气柴油 8、天然气汽油 9、电)
508		- //暂时全部柴油车
509		- sn_waybill.setOil_type("2");
510		-
511		- //根据车辆获取油量信息
512		- oilArray = likeGet(oilInfoMap, sch.getClZbh() + "_");
513		- if (oilArray.size() > 0) {
514		- Collections.sort(oilArray, oilComp);
515		- //出厂存油
516		- sn_waybill.setOut_oil(oilArray.get(0).getCzyl());
517		- //油料加注
518		- sn_waybill.setAdd_oil(sumAddOil(oilArray));
519		- //进场存油
520		- sn_waybill.setEnd_oil(oilArray.get(oilArray.size() - 1).getJzyl());
521		- //油料消耗
522		- sn_waybill.setExpend_oil(countOilExpend(oilArray));
523		- //非营业用油类型非营业用油类型(1.常规车2.包车3.加开包车)
524		- sn_waybill.setNowork_oil_type("1");
525		- //非营业用油
526		- sn_waybill.setNowork_oil(0);
527		- //非营业用油油耗量(保养用油)
528		- sn_waybill.setNowork_oil1(0);
529		- //非营业用油油耗量(票务用油)
530		- sn_waybill.setNowork_oil2(0);
531		- //非营业用油油耗量(其他用油)
532		- sn_waybill.setNowork_oil3(0);
533		- //营业用油
534		- sn_waybill.setWork_oil(countOilExpend(oilArray));
535		- //其他营业用油
536		- sn_waybill.setQt_work_oil(0);
537		- }
538		- sn_waybill.setDriver_detail(new ArrayList<SN_waybillItem>());
539		-
540		- //按驾驶员分组班次，构造路单子项
541		- jGhListMap = new ConvertUtil<ScheduleRealInfo>().groupMultiList(list, "_", jGhField);
542		- for (String jGh : jGhListMap.keySet()) {
543		- list = jGhListMap.get(jGh);
544		- sn_waybillItem = new SN_waybillItem();
545		- sch = list.get(0);
546		- //司机编号
547		- sn_waybillItem.setDriver_no(sch.getjGh());
548		- //司机名称
549		- sn_waybillItem.setDriver_name(sch.getjName());
550		- //售票员编号
551		- sn_waybillItem.setBusman_no(sch.getsGh());
552		- //售票员名称
553		- sn_waybillItem.setBusman_name(sch.getsName());
554		- //行驶里程
555		- sn_waybillItem.setDriver_way(ScheduleCalculator.calcYYLC(list));
556		- //空驶公里
557		- sn_waybillItem.setKs_way(ScheduleCalculator.calcKSLC(list));
558		- //柴油加注量、电加注量同一字段
559		- sn_waybillItem.setDo_oil_2(countOilExpend(oilArray, sch.getjGh()));
560		-
561		- sn_waybill.getDriver_detail().add(sn_waybillItem);
562		- }
563		-
564		- rs[i] = sn_waybill;
565		- }
566		- return rs;
567		- }
568		-
569		- /**
570		- * 将实际排班转换成上南需要损失公里数据
571		- *
572		- * @param listMap
573		- * @return
574		- */
575		- public static SN_lossMileage[] to_lossMileage_SN(ArrayListMultimap<String, ScheduleRealInfo> listMap) throws NoSuchFieldException {
576		- List<String> lineArray = new ArrayList<>(listMap.keySet());
577		- SN_lossMileage[] rs = new SN_lossMileage[lineArray.size()];
578		-
579		- List<ScheduleRealInfo> list;
580		- ScheduleRealInfo sch;
581		- for (int i = 0; i < lineArray.size(); i++) {
582		- list = listMap.get(lineArray.get(i));
583		-
584		- sch = list.get(0);
585		- SN_lossMileage lossMileage = new SN_lossMileage();
586		- //线路编号
587		- lossMileage.setLine_id(sch.getXlBm());
588		- //营运日期
589		- lossMileage.setWork_date(sch.getScheduleDateStr());
590		- //分公司编号
591		- lossMileage.setComp_id(sch.getFgsBm());
592		- //少驶公里
593		- lossMileage.setLoss_way(ScheduleCalculator.calcCJLC(list));
594		- //实际公里
595		- lossMileage.setAct_way(ScheduleCalculator.calcYYLC(list));
596		- //计划公里
597		- lossMileage.setJh_way(ScheduleCalculator.calcJHLC(list));
598		-
599		- //路阻损失公里
600		- lossMileage.setLoss_lz(ScheduleCalculator.calcCJLC2(list, "路阻"));
601		- //吊慢损失公里
602		- lossMileage.setLoss_dm(ScheduleCalculator.calcCJLC2(list, "吊慢"));
603		- //故障损失公里
604		- lossMileage.setLoss_gz(ScheduleCalculator.calcCJLC2(list, "故障"));
605		- //纠纷损失公里
606		- lossMileage.setLoss_jf(ScheduleCalculator.calcCJLC2(list, "纠纷"));
607		- //肇事损失公里
608		- lossMileage.setLoss_zs(ScheduleCalculator.calcCJLC2(list, "肇事"));
609		- //缺人损失公里
610		- lossMileage.setLoss_qr(ScheduleCalculator.calcCJLC2(list, "缺人"));
611		- //缺车损失公里
612		- lossMileage.setLoss_qc(ScheduleCalculator.calcCJLC2(list, "缺车"));
613		- //客稀损失公里
614		- lossMileage.setLoss_kx(ScheduleCalculator.calcCJLC2(list, "客稀"));
615		- //其他损失公里
616		- lossMileage.setLoss_qt(ScheduleCalculator.calcCJLC2(list, "其他"));
617		- //配车损失公里
618		- lossMileage.setLoss_pc(ScheduleCalculator.calcCJLC2(list, "配车"));
619		- //保养损失公里
620		- lossMileage.setLoss_by(ScheduleCalculator.calcCJLC2(list, "保养"));
621		- //气候损失公里
622		- lossMileage.setLoss_qh(ScheduleCalculator.calcCJLC2(list, "气候"));
623		- //援外损失公里
624		- lossMileage.setLoss_yw(ScheduleCalculator.calcCJLC2(list, "援外"));
625		- //抽减损失公里
626		- lossMileage.setLoss_cj(ScheduleCalculator.calcCJLC2(list, "抽减"));
627		-
628		- //实际班次
629		- lossMileage.setAct_num(ScheduleCalculator.countSJJHBC(list));
630		- //早班班次
631		- lossMileage.setEarly_num(ScheduleCalculator.countSJJHBC(ScheduleCalculator.earlyArray(list)));
632		- //晚班班次
633		- lossMileage.setLate_num(ScheduleCalculator.countSJJHBC(ScheduleCalculator.lastArray(list)));
634		- //另加班次
635		- lossMileage.setL_act_num(ScheduleCalculator.countZJBC(list));
636		- //早班另加班次
637		- lossMileage.setL_early_num(ScheduleCalculator.countZJBC(ScheduleCalculator.earlyArray(list)));
638		- //晚班另加班次
639		- lossMileage.setL_late_num(ScheduleCalculator.countZJBC(ScheduleCalculator.lastArray(list)));
640		- //计划班次
641		- lossMileage.setJ_act_num(ScheduleCalculator.countJHBC(list));
642		- //早班计划班次
643		- lossMileage.setJ_early_num(ScheduleCalculator.countJHBC(ScheduleCalculator.earlyArray(list)));
644		- //晚班计划班次
645		- lossMileage.setJ_late_num(ScheduleCalculator.countJHBC(ScheduleCalculator.lastArray(list)));
646		- //放站班次
647		- lossMileage.setF_act_bc(ScheduleCalculator.countEmpty(list));
648		- //早班放站班次
649		- lossMileage.setF_early_bc(ScheduleCalculator.countEmpty(ScheduleCalculator.earlyArray(list)));
650		- //晚班放站班次
651		- lossMileage.setF_late_bc(ScheduleCalculator.countEmpty(ScheduleCalculator.lastArray(list)));
652		- //调头班次
653		- lossMileage.setDt_act_bc(0);
654		- //早班调头班次
655		- lossMileage.setDt_early_bc(0);
656		- //晚班调头班次
657		- lossMileage.setDt_late_bc(0);
658		- //大间隔班次
659		- lossMileage.setD_act_num(ScheduleCalculator.countSpaceLg(list));
660		- //早班大间隔班次
661		- lossMileage.setD_early_num(ScheduleCalculator.countSpaceLg(ScheduleCalculator.earlyArray(list)));
662		- //晚班大间隔班次
663		- lossMileage.setD_late_num(ScheduleCalculator.countSpaceLg(ScheduleCalculator.lastArray(list)));
664		- //最大间隔时间
665		- lossMileage.setD_act_max(ScheduleCalculator.calcMaxSpace(list));
666		- //故障分
667		- lossMileage.setLoss_gzf(0);
668		- //故障次数
669		- lossMileage.setLoss_gzcs(0);
670		-
671		-
672		- rs[i] = lossMileage;
673		- }
674		- return rs;
675		- }
676		-
677		- private static double countOilExpend(List<OilInfo> oilArray) {
678		- double sum = 0;
679		- for (OilInfo oilInfo : oilArray) {
680		- sum = Arith.add(sum, oilInfo.getYh());
681		- }
682		- return sum;
683		- }
684		-
685		- private static double sumAddOil(List<OilInfo> oilArray) {
686		- double sum = 0;
687		- for (OilInfo oilInfo : oilArray) {
688		- sum = Arith.add(sum, oilInfo.getJzl());
689		- }
690		- return sum;
691		- }
692		-
693		- private static double countOilExpend(List<OilInfo> oilArray, String jGh) {
694		- double sum = 0;
695		- for (OilInfo oilInfo : oilArray) {
696		- if (oilInfo.getJsy().equals(jGh))
697		- sum = Arith.add(sum, oilInfo.getYh());
698		- }
699		- return sum;
700		- }
701		-
702		- public static <T> List<T> likeGet(Map<String, T> map, String key) {
703		- Set<String> ks = map.keySet();
704		- List<T> list = new ArrayList<>();
705		-
706		- if (StringUtils.isEmpty(key))
707		- return list;
708		-
709		- for (String k : ks) {
710		- if (k.indexOf(key) != -1) {
711		- list.add(map.get(k));
712		- }
713		- }
714		- return list;
715		- }
716		-
717		- /**
718		- * 将数据转换成南汇工资系统需要的驾驶员考勤数据
719		- *
720		- * @param plans
721		- * @param reals
722		- * @param types
723		- * @return
724		- */
725		- public static Jsy_attendance[] to_jsyAttendanceNH(List<SchedulePlanInfo> plans, List<ScheduleRealInfo> reals, Set<String> jsySet, Map<String, String> types, String rq) {
726		- //List<String> ghArray = new ArrayList<>(types.keySet());
727		- Jsy_attendance[] rs = new Jsy_attendance[jsySet.size()];
728		-
729		- Jsy_attendance attendance;
730		- SchedulePlanInfo plan;
731		- ScheduleRealInfo real;
732		- //String jGh;
733		-
734		- int i = 0;
735		- for(String jGh : jsySet){
736		- attendance = new Jsy_attendance();
737		- attendance.setRq(rq);
738		- //计划
739		- plan = searchByJsy(plans, jGh);
740		- //实际
741		- real = searchRealByJsy(reals, jGh);
742		- //考勤
743		- attendance.setStatus((plan==null?"0":"1") + "," + (real==null?"0":"1"));
744		- //班型
745		- attendance.setPlanType(types.get(jGh)==null?"1":types.get(jGh));
746		- //驾驶员工号
747		- attendance.setjGh(jGh);
748		- //早晚班类型
749		- attendance.calcZybType(reals);
750		-
751		- //实际计划
752		- if(real != null){
753		- attendance.setXlBm(real.getXlBm());
754		- attendance.setXlName(real.getXlName());
755		- attendance.setjName(real.getjName());
756		- attendance.setsGh(real.getsGh());
757		- attendance.setsName(real.getsName());
758		- attendance.setCompany(real.getGsBm());
759		- attendance.setFgsCompany(real.getFgsBm());
760		- attendance.addLpName(real.getLpName());
761		- attendance.addCl(real.getClZbh());
762		- }
763		- //计划
764		- else if(plan != null){
765		- attendance.setXlBm(plan.getXlBm());
766		- attendance.setXlName(plan.getXlName());
767		- attendance.setjName(plan.getjName());
768		- attendance.setsGh(plan.getsGh());
769		- attendance.setsName(plan.getsName());
770		- attendance.setCompany(plan.getGsBm());
771		- attendance.setFgsCompany(plan.getFgsBm());
772		- attendance.addLpName(plan.getLpName());
773		- attendance.addCl(plan.getClZbh());
774		- }
775		-
776		- rs[i] = attendance;
777		- i++;
778		- }
779		- return rs;
780		- }
781		-
782		- public static SchedulePlanInfo searchByJsy(List<SchedulePlanInfo> plans, String jGh){
783		-
784		- for(SchedulePlanInfo plan : plans){
785		- if(plan.getjGh().equals(jGh))
786		- return plan;
787		- }
788		- return null;
789		- }
790		-
791		- public static ScheduleRealInfo searchRealByJsy(List<ScheduleRealInfo> reals, String jGh){
792		-
793		- for(ScheduleRealInfo sch : reals){
794		- if(sch.getjGh().equals(jGh))
795		- return sch;
796		- }
797		- return null;
798		- }
799		-
800		- /**
801		- * 将排班和油耗转换成综合查询需要的数据
802		- * @param schList
803		- * @param oilList
804		- * @return
805		- */
806		- public static String[] to_getLSLC_PB(String fdate, List<ScheduleRealInfo> schList, List<OilInfo> oilList, List<SchedulePlanInfo> planList) {
807		- String[] array = new String[0];
808		- try {
809		- //按日期分组数据
810		- ArrayListMultimap<String, ScheduleRealInfo> schMultimap =
811		- new ConvertUtil().groupMultiList(schList, "_", ScheduleRealInfo.class.getDeclaredField("scheduleDateStr"));
812		-
813		- ArrayListMultimap<String, OilInfo> oilMultimap =
814		- new ConvertUtil().groupMultiList(oilList, "_", OilInfo.class.getDeclaredField("rq"));
815		-
816		- ArrayListMultimap<String, SchedulePlanInfo> planMultimap =
817		- new ConvertUtil().groupMultiList(planList, "_", SchedulePlanInfo.class.getDeclaredField("scheduleDate"));
818		-
819		-
820		- //月份有多少天
821		- int year = Integer.parseInt(fdate.substring(0, 4));
822		- int month = Integer.parseInt(fdate.substring(5, 7));
823		- Calendar cal = Calendar.getInstance();
824		- cal.set(Calendar.YEAR,year);
825		- cal.set(Calendar.MONTH,month - 1);//从0开始
826		- int maxDate = cal.getActualMaximum(Calendar.DATE);
827		-
828		- List<LsLcPb> rs = new ArrayList<>();
829		- LsLcPb lcPb;
830		- List<ScheduleRealInfo> pbList;
831		- List<SchedulePlanInfo> jhList;
832		- List<OilInfo> yhList;
833		- String rq,rq2;
834		- SchedulePlanInfo outPlan;
835		- int currentDay = cal.get(Calendar.DAY_OF_MONTH);
836		- for(int i = 1; i <= maxDate; i++){
837		- lcPb = new LsLcPb();
838		- lcPb.setDay(i);
839		-
840		- rq = fdate + "-" + (i < 10?"0":"") + i;
841		- rq2 = rq.replaceAll("-", "");
842		-
843		- pbList = schMultimap.get(rq);
844		- yhList = oilMultimap.get(rq2);
845		- jhList = planMultimap.get(rq2);
846		-
847		- if(i < currentDay){
848		- if(pbList == null \|\| pbList.size() == 0)
849		- lcPb.setType(4);//休息
850		- else{
851		- lcPb.setType(1);
852		- lcPb.setLckq("");
853		- if(yhList != null && yhList.size() > 0){
854		- lcPb.setLcyh(yhList.get(0).getYh());
855		- }
856		- lcPb.setLcyylc(ScheduleCalculator.calcYYLC(pbList));
857		- lcPb.setLcfyylc(ScheduleCalculator.calcKSLC(pbList));
858		- }
859		- }
860		- else if (i == currentDay)
861		- lcPb.setType(3);//今天
862		- else {
863		- if(jhList == null \|\| jhList.size() == 0)
864		- lcPb.setType(4);//休息
865		- else{
866		- lcPb.setType(2);
867		- outPlan = getOutSch(jhList);
868		- if(null != outPlan){
869		- lcPb.setPbxl(outPlan.getXlName());
870		- lcPb.setPblp(outPlan.getLpName());
871		- lcPb.setPbbd(minusMinute(outPlan.getFcsj(), 15));
872		- lcPb.setPbyc(outPlan.getClZbh());
873		- }
874		- else
875		- lcPb.setType(4);//休息
876		- }
877		- }
878		-
879		- rs.add(lcPb);
880		- }
881		-
882		- //拼接成字符串数组
883		- array = new String[rs.size()];
884		- StringBuilder sb;
885		- for(int i = 0,len=rs.size(); i < len; i++){
886		- lcPb = rs.get(i);
887		- sb = new StringBuilder();
888		-
889		- sb.append(lcPb.getType());
890		-
891		- switch (lcPb.getType()){
892		- case 1:
893		- sb.append("," + lcPb.getLckq());
894		- sb.append("," + lcPb.getLcyh());
895		- sb.append("," + lcPb.getLcyylc());
896		- sb.append("," + lcPb.getLcfyylc());
897		- break;
898		- case 2:
899		- sb.append("," + lcPb.getPbxl());
900		- sb.append("," + lcPb.getPblp());
901		- sb.append("," + lcPb.getPbbd());
902		- sb.append("," + lcPb.getPbyc());
903		- break;
904		- }
905		- sb.append("," + lcPb.getDay());
906		- array[i] = sb.toString();
907		- }
908		- } catch (NoSuchFieldException e) {
909		- logger.error("", e);
910		- }
911		- return array;
912		- }
913		-
914		- /**
915		- * 将排班和油耗转换成综合查询需要的数据
916		- * @param schList
917		- * @param oilList
918		- * @return
919		- */
920		- public static List<LsLcPb> to_getLSLC_PB_list(String fdate, List<ScheduleRealInfo> schList, List<OilInfo> oilList, List<SchedulePlanInfo> planList) {
921		- List<LsLcPb> rs = new ArrayList<>();
922		- try {
923		- //按日期分组数据
924		- ArrayListMultimap<String, ScheduleRealInfo> schMultimap =
925		- new ConvertUtil().groupMultiList(schList, "_", ScheduleRealInfo.class.getDeclaredField("scheduleDateStr"));
926		-
927		- ArrayListMultimap<String, OilInfo> oilMultimap =
928		- new ConvertUtil().groupMultiList(oilList, "_", OilInfo.class.getDeclaredField("rq"));
929		-
930		- ArrayListMultimap<String, SchedulePlanInfo> planMultimap =
931		- new ConvertUtil().groupMultiList(planList, "_", SchedulePlanInfo.class.getDeclaredField("scheduleDate"));
932		-
933		-
934		- //月份有多少天
935		- int year = Integer.parseInt(fdate.substring(0, 4));
936		- int month = Integer.parseInt(fdate.substring(5, 7));
937		- Calendar cal = Calendar.getInstance();
938		- cal.set(Calendar.YEAR,year);
939		- cal.set(Calendar.MONTH,month - 1);//从0开始
940		- int maxDate = cal.getActualMaximum(Calendar.DATE);
941		-
942		- LsLcPb lcPb;
943		- List<ScheduleRealInfo> pbList;
944		- List<SchedulePlanInfo> jhList;
945		- List<OilInfo> yhList;
946		- String rq,rq2;
947		- SchedulePlanInfo outPlan;
948		- int currentDay = cal.get(Calendar.DAY_OF_MONTH);
949		- for(int i = 1; i <= maxDate; i++){
950		- lcPb = new LsLcPb();
951		- lcPb.setDay(i);
952		-
953		- rq = fdate + "-" + (i < 10?"0":"") + i;
954		- rq2 = rq.replaceAll("-", "");
955		-
956		- pbList = schMultimap.get(rq);
957		- yhList = oilMultimap.get(rq2);
958		- jhList = planMultimap.get(rq2);
959		-
960		- if(i < currentDay){
961		- if(pbList == null \|\| pbList.size() == 0)
962		- lcPb.setType(4);//休息
963		- else{
964		- lcPb.setType(1);
965		- lcPb.setLckq("");
966		- if(yhList != null && yhList.size() > 0){
967		- lcPb.setLcyh(yhList.get(0).getYh());
968		- }
969		- lcPb.setLcyylc(ScheduleCalculator.calcYYLC(pbList));
970		- lcPb.setLcfyylc(ScheduleCalculator.calcKSLC(pbList));
971		- }
972		- }
973		- else if (i == currentDay)
974		- lcPb.setType(3);//今天
975		- else {
976		- if(jhList == null \|\| jhList.size() == 0)
977		- lcPb.setType(4);//休息
978		- else{
979		- lcPb.setType(2);
980		- outPlan = getOutSch(jhList);
981		- if(null != outPlan){
982		- lcPb.setPbxl(outPlan.getXlName());
983		- lcPb.setPblp(outPlan.getLpName());
984		- lcPb.setPbbd(minusMinute(outPlan.getFcsj(), 15));
985		- lcPb.setPbyc(outPlan.getClZbh());
986		- }
987		- else
988		- lcPb.setType(4);//休息
989		- }
990		- }
991		-
992		- rs.add(lcPb);
993		- }
994		- } catch (NoSuchFieldException e) {
995		- logger.error("", e);
996		- }
997		- return rs;
998		- }
999		-
1000		- /**
1001		- * HH:mm 格式时间减分钟
1002		- * @param dfsj
1003		- * @param i
1004		- * @return
1005		- */
1006		- private static String minusMinute(String hhmm, int i) {
1007		- try {
1008		- SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
1009		- long t = sdf.parse(hhmm).getTime();
1010		-
1011		- return sdf.format(new Date(t - (i * 60 * 1000)));
1012		- } catch (ParseException e) {
1013		- logger.error("", e);
1014		- }
1015		- return null;
1016		- }
1017		-
1018		- private static SchedulePlanInfo getOutSch(List<SchedulePlanInfo> pbList) {
1019		-
1020		- for(SchedulePlanInfo sch : pbList){
1021		- if(sch.getBcType().equals("out"))
1022		- return sch;
1023		- }
1024		- return null;
1025		- }
1026		-
1027		- public static class OilComp implements Comparator<OilInfo> {
1028		-
1029		- @Override
1030		- public int compare(OilInfo o1, OilInfo o2) {
1031		- return o1.getJcsx() - o2.getJcsx();
1032		- }
1033		- }
1034		-
1035		-
1036		-}
	1	+package com.bsth.server_ws.util;
	2	+
	3	+import java.lang.reflect.Field;
	4	+import java.text.ParseException;
	5	+import java.text.SimpleDateFormat;
	6	+import java.util.ArrayList;
	7	+import java.util.Calendar;
	8	+import java.util.Collections;
	9	+import java.util.Comparator;
	10	+import java.util.Date;
	11	+import java.util.HashMap;
	12	+import java.util.HashSet;
	13	+import java.util.List;
	14	+import java.util.Map;
	15	+import java.util.Set;
	16	+
	17	+import org.apache.commons.lang3.StringUtils;
	18	+import org.slf4j.Logger;
	19	+import org.slf4j.LoggerFactory;
	20	+
	21	+import com.bsth.entity.DutyEmployee;
	22	+import com.bsth.entity.ElecInfo;
	23	+import com.bsth.entity.OilInfo;
	24	+import com.bsth.entity.SchedulePlanInfo;
	25	+import com.bsth.entity.ScheduleRealInfo;
	26	+import com.bsth.server_ws.attendance.entity.Jsy_attendance;
	27	+import com.bsth.server_ws.park_station.dto.LsLcPb;
	28	+import com.bsth.server_ws.waybill.entity.NH_waybill;
	29	+import com.bsth.server_ws.waybill.entity.NH_waybillItem;
	30	+import com.bsth.server_ws.waybill.entity.SN_lossMileage;
	31	+import com.bsth.server_ws.waybill.entity.SN_waybill;
	32	+import com.bsth.server_ws.waybill.entity.SN_waybillItem;
	33	+import com.bsth.util.Arith;
	34	+import com.bsth.util.ConvertUtil;
	35	+import com.google.common.collect.ArrayListMultimap;
	36	+
	37	+/**
	38	+ * Created by panzhao on 2017/3/15.
	39	+ */
	40	+public class WSDataConver {
	41	+
	42	+ /**
	43	+ * 格式编码和名称映射，与老系统保持一致
	44	+ */
	45	+ private static Map<String, String> gsMap;
	46	+
	47	+ static Logger logger = LoggerFactory.getLogger(WSDataConver.class);
	48	+
	49	+ static {
	50	+ gsMap = new HashMap<>();
	51	+ gsMap.put("55", "上南公司");
	52	+ gsMap.put("55_4", "上南一分公司");
	53	+ gsMap.put("55_3", "上南六分公司");
	54	+ gsMap.put("55_1", "上南二分公司");
	55	+ gsMap.put("55_2", "上南三分公司");
	56	+ gsMap.put("22", "金高公司");
	57	+ gsMap.put("22_2", "二分公司");
	58	+ gsMap.put("22_1", "四分公司");
	59	+ gsMap.put("22_3", "三分公司");
	60	+ gsMap.put("22_5", "一分公司");
	61	+ gsMap.put("05", "杨高公司");
	62	+ gsMap.put("05_5", "杨高分公司");
	63	+ gsMap.put("05_6", "周浦分公司");
	64	+ gsMap.put("05_3", "芦潮港分公司");
	65	+ gsMap.put("05_1", "川沙分公司");
	66	+ gsMap.put("26", "南汇公司");
	67	+ gsMap.put("26_3", "南汇三分");
	68	+ gsMap.put("26_2", "南汇二分");
	69	+ gsMap.put("26_1", "南汇一分");
	70	+ gsMap.put("26_4", "南汇维修公司");
	71	+ }
	72	+
	73	+ /**
	74	+ * 将班次list 转换成 getCurrentDayPlan 函数需要的格式
	75	+ *
	76	+ * @param list
	77	+ * @return [0：日期，1：线路名称，2：路牌名称，3：车辆自编号，4：，5：，6：起点时间，7：终点时间，8：起点站名称，9：终点站名称，10：班次类型]
	78	+ */
	79	+ public static String[] to_getCurrentDayPlan(List<ScheduleRealInfo> list) {
	80	+ if (list == null \|\| list.size() == 0)
	81	+ return new String[0];
	82	+
	83	+ Map<String, String> bcTypeMap = new HashMap<>();
	84	+ bcTypeMap.put("out", "出场");
	85	+ bcTypeMap.put("in", "进场");
	86	+
	87	+ String[] array = new String[list.size()];
	88	+ StringBuilder sb;
	89	+ ScheduleRealInfo sch;
	90	+ int len = list.size();
	91	+ for(int i = 0; i < len; i ++){
	92	+ sb = new StringBuilder();
	93	+ sch = list.get(i);
	94	+ sb.append(sch.getScheduleDateStr() + ",");
	95	+ sb.append(sch.getXlName() + ",");
	96	+ sb.append(sch.getLpName() + ",");
	97	+ sb.append(sch.getClZbh() + ",");
	98	+ sb.append(",");
	99	+ sb.append(",");
	100	+ sb.append(sch.getDfsj() + ",");
	101	+ sb.append(sch.getZdsj() + ",");
	102	+ sb.append(sch.getQdzName() + ",");
	103	+ sb.append(sch.getZdzName() + ",");
	104	+ sb.append(bcTypeMap.containsKey(sch.getBcType())?bcTypeMap.get(sch.getBcType()):"");
	105	+
	106	+ array[i] = sb.toString();
	107	+ }
	108	+ return array;
	109	+ }
	110	+
	111	+ /**
	112	+ * 将班次list 转换成 returnCCInfo 和 returnJCInfo 函数需要的格式
	113	+ *
	114	+ * @param list
	115	+ * @return [0: 日期, 1: 线路编码, 2: 线路名称, 3: 公司名称, 4: 分公司名称, 5: 路牌, 6: 起点站, 7: 起点计划时间,
	116	+ * 8: 起点实际时间, 9: 终点站, 10: 终点计划时间, 11: 终点实际时间, 12: 计划里程, 13: 实际里程,
	117	+ * 14: 驾驶员, 15: 售票员, 16: 车辆内部编码, 17: 状态（1 为出场。2为进场）, 18: 驾驶员名称, 19: 进场顺序号]
	118	+ */
	119	+ public static String[] to_returnJCCInfo(List<ScheduleRealInfo> list) {
	120	+ if(list == null)
	121	+ return new String[0];
	122	+
	123	+ int size = list.size();
	124	+ String[] array = new String[size];
	125	+
	126	+ ScheduleRealInfo sch;
	127	+ StringBuffer sb;
	128	+ for (int i = 0; i < size; i++) {
	129	+ sb = new StringBuffer(",");
	130	+
	131	+ sch = list.get(i);
	132	+ sb.append(sch.getScheduleDateStr() + ",");
	133	+ sb.append(sch.getXlBm() + ",");
	134	+ sb.append(sch.getXlName() + ",");
	135	+ sb.append(gsMap.get(sch.getGsBm()) + ",");
	136	+ sb.append(gsMap.get(sch.getGsBm() + "_" + sch.getFgsBm()) + ",");
	137	+ sb.append(sch.getLpName() + ",");
	138	+ sb.append(sch.getQdzCode() + ",");
	139	+ sb.append(sch.getDfsj() + ",");
	140	+ sb.append(nvlGetVal(sch.getFcsjActual()) + ",");
	141	+ sb.append(sch.getZdzCode() + ",");
	142	+ sb.append(sch.getZdsj() + ",");
	143	+ sb.append(nvlGetVal(sch.getZdsjActual()) + ",");
	144	+ sb.append(nvlGetVal(sch.getJhlc()) + ",");
	145	+ sb.append(nvlGetVal(sch.getJhlc()) + ",");
	146	+ sb.append(sch.getjGh() + ",");
	147	+ sb.append(nvlGetVal(sch.getsGh()) + ",");
	148	+ sb.append(sch.getClZbh() + ",");
	149	+ sb.append((sch.getBcType().equals("out") ? 1 : 2) + ",");
	150	+ sb.append(sch.getjName() + ",");
	151	+ //用ID替代老系统的出场顺序号
	152	+ sb.append(sch.getId() + ",");
	153	+
	154	+ array[i] = sb.substring(1).toString();
	155	+ }
	156	+ return array;
	157	+ }
	158	+
	159	+ public static String nvlGetVal(Object val) {
	160	+ return val == null ? "" : val.toString();
	161	+ }
	162	+
	163	+ /**
	164	+ * 将实际排班和油耗数据转换成南汇路单需要的数据格式
	165	+ *
	166	+ * @param listMap
	167	+ * @param oilInfoMap
	168	+ * @return
	169	+ */
	170	+ public static NH_waybill[] to_waybill_NH(ArrayListMultimap<String, ScheduleRealInfo> listMap, Map<String, OilInfo> oilInfoMap, List<DutyEmployee> des) throws NoSuchFieldException {
	171	+ List<String> nbbmArray = new ArrayList<>(listMap.keySet());
	172	+
	173	+ NH_waybill[] rs = new NH_waybill[nbbmArray.size()];
	174	+ Field jGhField = ScheduleRealInfo.class.getDeclaredField("jGh");
	175	+ //Field lpField = ScheduleRealInfo.class.getDeclaredField("lpName");
	176	+
	177	+ List<ScheduleRealInfo> list;
	178	+ ArrayListMultimap<String, ScheduleRealInfo> jGhListMap;
	179	+ ScheduleRealInfo sch;
	180	+ NH_waybill nh_waybill;
	181	+ NH_waybillItem nh_waybillItem;
	182	+ OilInfo oilInfo;
	183	+ for (int i = 0; i < nbbmArray.size(); i++) {
	184	+ list = listMap.get(nbbmArray.get(i));
	185	+ if (list.size() == 0)
	186	+ continue;
	187	+ //班次信息
	188	+ nh_waybill = new NH_waybill();
	189	+ sch = list.get(0);
	190	+ //日期
	191	+ nh_waybill.setM_strYYRQ(sch.getScheduleDateStr());
	192	+ //车辆自编号
	193	+ nh_waybill.setM_strNBBM(sch.getClZbh());
	194	+ //线路编码
	195	+ nh_waybill.setM_strXLBM(sch.getXlBm());
	196	+ nh_waybill.setM_SubInfos(new ArrayList<NH_waybillItem>());
	197	+
	198	+ //按驾驶员分组班次，构造路单子项
	199	+ jGhListMap = new ConvertUtil<ScheduleRealInfo>().groupMultiList(list, "_", jGhField);
	200	+ for (String jGh : jGhListMap.keySet()) {
	201	+ list = jGhListMap.get(jGh);
	202	+ nh_waybillItem = new NH_waybillItem();
	203	+ //计划里程
	204	+ nh_waybillItem.setM_dblJHLC(ScheduleCalculator.calcJHLC(list));
	205	+ //实际计划公里
	206	+ nh_waybillItem.setM_dblSJJHLC(ScheduleCalculator.calcSJLC(list));
	207	+ //实际出场里程
	208	+ nh_waybillItem.setM_dblCCLC(ScheduleCalculator.calcCCLC(list));
	209	+ //实际进场里程
	210	+ nh_waybillItem.setM_dblJCLC(ScheduleCalculator.calcJCLC(list));
	211	+ //营业公里
	212	+ nh_waybillItem.setM_dblYYLC(ScheduleCalculator.calcYYLC(list));
	213	+ //空驶公里
	214	+ nh_waybillItem.setM_dblKSLC(ScheduleCalculator.calcKSLC(list));
	215	+ //抽减公里
	216	+ nh_waybillItem.setM_dblCJLC(ScheduleCalculator.calcCJLC(list));
	217	+ //烂班公里
	218	+ nh_waybillItem.setM_dblLBLC(ScheduleCalculator.calcLBLC(list));
	219	+ //增加公里
	220	+ nh_waybillItem.setM_dblZJLC(ScheduleCalculator.calcZJLC(list));
	221	+ //总公里
	222	+ nh_waybillItem.setM_dblZLC(ScheduleCalculator.calcZLC(list));
	223	+ //烂班公里原因
	224	+ nh_waybillItem.setM_strLBYY(ScheduleCalculator.joinLBYY(list));
	225	+ //抽减公里原因
	226	+ nh_waybillItem.setM_strCJYY(ScheduleCalculator.joinCJYY(list));
	227	+ //计划班次
	228	+ nh_waybillItem.setM_intJHBC(ScheduleCalculator.countJHBC(list));
	229	+ //实际计划班次
	230	+ nh_waybillItem.setM_intSJJHBC(ScheduleCalculator.countSJJHBC(list));
	231	+ //实际班次 ————> 暂时和实际计划班次相同
	232	+ nh_waybillItem.setM_intSJBC(ScheduleCalculator.countSJJHBC(list));
	233	+ //增加班次
	234	+ nh_waybillItem.setM_intZJBC(ScheduleCalculator.countZJBC(list));
	235	+ //抽减班次
	236	+ nh_waybillItem.setM_intCJBC(ScheduleCalculator.countCJBC(list));
	237	+ //烂班工时
	238	+ nh_waybillItem.setM_dblLBGS(ScheduleCalculator.calcLBGS(list));
	239	+ //路牌
	240	+ nh_waybillItem.setM_strLP(list.get(0).getLpName());
	241	+ //驾驶员工号
	242	+ nh_waybillItem.setM_strJSY(list.get(0).getjGh());
	243	+ //售票员工号
	244	+ nh_waybillItem.setM_strSPY("");
	245	+ for (ScheduleRealInfo sri : list) {
	246	+ if (StringUtils.isNotEmpty(sri.getsGh())) {
	247	+ nh_waybillItem.setM_strSPY(sri.getsGh());
	248	+ break;
	249	+ }
	250	+ }
	251	+ //驾驶员考勤
	252	+ nh_waybillItem.setM_strJSYKQ("");
	253	+ //售票员考勤
	254	+ nh_waybillItem.setM_strSPYKQ("");
	255	+ //当班调度员
	256	+ nh_waybillItem.setM_strDDY(ScheduleCalculator.calcDDY(list, des));
	257	+ //营运状态
	258	+ nh_waybillItem.setM_strYYZT("");
	259	+ //备注
	260	+ nh_waybillItem.setM_strBZ("");
	261	+
	262	+ oilInfo = oilInfoMap.get(list.get(0).getClZbh() + "_" + list.get(0).getjGh());
	263	+ if (oilInfo != null) {
	264	+ //出场存油
	265	+ nh_waybillItem.setM_dblCCCY(oilInfo.getCzyl());
	266	+ //进场存油
	267	+ nh_waybillItem.setM_dblJCCY(oilInfo.getJzyl());
	268	+ //加注量1
	269	+ nh_waybillItem.setM_dblJZL1(oilInfo.getJzl());
	270	+ //加注量2
	271	+ nh_waybillItem.setM_dblJZL2(0.0);
	272	+ //尿素
	273	+ nh_waybillItem.setM_dblNS(oilInfo.getNs());
	274	+ //消耗量
	275	+ nh_waybillItem.setM_dblYH(oilInfo.getYh());
	276	+ //加油地点1
	277	+ nh_waybillItem.setM_strJYD1("");
	278	+ //加油地点2
	279	+ nh_waybillItem.setM_strJYD2("");
	280	+ //加油工工号1
	281	+ nh_waybillItem.setM_strJYG1("");
	282	+ //加油工工号1
	283	+ nh_waybillItem.setM_strJYG2("");
	284	+ //油耗类型1
	285	+ nh_waybillItem.setM_strYHLX1(oilInfo.getRylx());
	286	+ //油耗类型2
	287	+ nh_waybillItem.setM_strYHLX1("");
	288	+ }
	289	+
	290	+ nh_waybill.getM_SubInfos().add(nh_waybillItem);
	291	+ }
	292	+
	293	+ rs[i] = nh_waybill;
	294	+ }
	295	+ return rs;
	296	+ }
	297	+
	298	+ /**
	299	+ * 将实际排班、油耗数据、电量数据转换成南汇路单需要的数据格式
	300	+ *
	301	+ * @param listMap
	302	+ * @param oilInfoMap
	303	+ * @return
	304	+ */
	305	+ public static NH_waybill[] to_waybill_NH4TH(ArrayListMultimap<String, ScheduleRealInfo> listMap, Map<String, OilInfo> oilInfoMap, Map<String, ElecInfo> elecInfoMap, List<DutyEmployee> des) throws NoSuchFieldException {
	306	+ List<String> nbbmArray = new ArrayList<>(listMap.keySet());
	307	+
	308	+ NH_waybill[] rs = new NH_waybill[nbbmArray.size()];
	309	+ Field jGhField = ScheduleRealInfo.class.getDeclaredField("jGh");
	310	+ //Field lpField = ScheduleRealInfo.class.getDeclaredField("lpName");
	311	+
	312	+ List<ScheduleRealInfo> list;
	313	+ ArrayListMultimap<String, ScheduleRealInfo> jGhListMap;
	314	+ ScheduleRealInfo sch;
	315	+ NH_waybill nh_waybill;
	316	+ NH_waybillItem nh_waybillItem;
	317	+ OilInfo oilInfo;
	318	+ ElecInfo elecInfo;
	319	+ for (int i = 0; i < nbbmArray.size(); i++) {
	320	+ list = listMap.get(nbbmArray.get(i));
	321	+ if (list.size() == 0)
	322	+ continue;
	323	+ //班次信息
	324	+ nh_waybill = new NH_waybill();
	325	+ sch = list.get(0);
	326	+ //日期
	327	+ nh_waybill.setM_strYYRQ(sch.getScheduleDateStr());
	328	+ //车辆自编号
	329	+ nh_waybill.setM_strNBBM(sch.getClZbh());
	330	+ //线路编码
	331	+ nh_waybill.setM_strXLBM(sch.getXlBm());
	332	+ nh_waybill.setM_SubInfos(new ArrayList<NH_waybillItem>());
	333	+
	334	+ //按驾驶员分组班次，构造路单子项
	335	+ jGhListMap = new ConvertUtil<ScheduleRealInfo>().groupMultiList(list, "_", jGhField);
	336	+ for (String jGh : jGhListMap.keySet()) {
	337	+ list = jGhListMap.get(jGh);
	338	+ nh_waybillItem = new NH_waybillItem();
	339	+ //计划里程
	340	+ nh_waybillItem.setM_dblJHLC(ScheduleCalculator.calcJHLC(list));
	341	+ //实际计划公里
	342	+ nh_waybillItem.setM_dblSJJHLC(ScheduleCalculator.calcSJLC(list));
	343	+ //实际出场里程
	344	+ nh_waybillItem.setM_dblCCLC(ScheduleCalculator.calcCCLC(list));
	345	+ //实际进场里程
	346	+ nh_waybillItem.setM_dblJCLC(ScheduleCalculator.calcJCLC(list));
	347	+ //营业公里
	348	+ nh_waybillItem.setM_dblYYLC(ScheduleCalculator.calcYYLC(list));
	349	+ //空驶公里
	350	+ nh_waybillItem.setM_dblKSLC(ScheduleCalculator.calcKSLC(list));
	351	+ //抽减公里
	352	+ nh_waybillItem.setM_dblCJLC(ScheduleCalculator.calcCJLC(list));
	353	+ //烂班公里
	354	+ nh_waybillItem.setM_dblLBLC(ScheduleCalculator.calcLBLC(list));
	355	+ //增加公里
	356	+ nh_waybillItem.setM_dblZJLC(ScheduleCalculator.calcZJLC(list));
	357	+ //总公里
	358	+ nh_waybillItem.setM_dblZLC(ScheduleCalculator.calcZLC(list));
	359	+ //烂班公里原因
	360	+ nh_waybillItem.setM_strLBYY(ScheduleCalculator.joinLBYY(list));
	361	+ //抽减公里原因
	362	+ nh_waybillItem.setM_strCJYY(ScheduleCalculator.joinCJYY(list));
	363	+ //计划班次
	364	+ nh_waybillItem.setM_intJHBC(ScheduleCalculator.countJHBC(list));
	365	+ //实际计划班次
	366	+ nh_waybillItem.setM_intSJJHBC(ScheduleCalculator.countSJJHBC(list));
	367	+ //实际班次 ————> 暂时和实际计划班次相同
	368	+ nh_waybillItem.setM_intSJBC(ScheduleCalculator.countSJJHBC(list));
	369	+ //增加班次
	370	+ nh_waybillItem.setM_intZJBC(ScheduleCalculator.countZJBC(list));
	371	+ //抽减班次
	372	+ nh_waybillItem.setM_intCJBC(ScheduleCalculator.countCJBC(list));
	373	+ //烂班工时
	374	+ nh_waybillItem.setM_dblLBGS(ScheduleCalculator.calcLBGS(list));
	375	+ //路牌
	376	+ nh_waybillItem.setM_strLP(list.get(0).getLpName());
	377	+ //驾驶员工号
	378	+ nh_waybillItem.setM_strJSY(list.get(0).getjGh());
	379	+ //售票员工号
	380	+ nh_waybillItem.setM_strSPY("");
	381	+ for (ScheduleRealInfo sri : list) {
	382	+ if (StringUtils.isNotEmpty(sri.getsGh())) {
	383	+ nh_waybillItem.setM_strSPY(sri.getsGh());
	384	+ break;
	385	+ }
	386	+ }
	387	+ //驾驶员考勤
	388	+ nh_waybillItem.setM_strJSYKQ("");
	389	+ //售票员考勤
	390	+ nh_waybillItem.setM_strSPYKQ("");
	391	+ //当班调度员
	392	+ nh_waybillItem.setM_strDDY(ScheduleCalculator.calcDDY(list, des));
	393	+ //营运状态
	394	+ nh_waybillItem.setM_strYYZT("");
	395	+ //备注
	396	+ nh_waybillItem.setM_strBZ("");
	397	+
	398	+ oilInfo = oilInfoMap.get(list.get(0).getClZbh() + "_" + list.get(0).getjGh());
	399	+ if (oilInfo != null) {
	400	+ //出场存油
	401	+ nh_waybillItem.setM_dblCCCY(oilInfo.getCzyl());
	402	+ //进场存油
	403	+ nh_waybillItem.setM_dblJCCY(oilInfo.getJzyl());
	404	+ //加注量1
	405	+ nh_waybillItem.setM_dblJZL1(oilInfo.getJzl());
	406	+ //加注量2
	407	+ nh_waybillItem.setM_dblJZL2(0.0);
	408	+ //尿素
	409	+ nh_waybillItem.setM_dblNS(oilInfo.getNs());
	410	+ //消耗量
	411	+ nh_waybillItem.setM_dblYH(oilInfo.getYh());
	412	+ //加油地点1
	413	+ nh_waybillItem.setM_strJYD1("");
	414	+ //加油地点2
	415	+ nh_waybillItem.setM_strJYD2("");
	416	+ //加油工工号1
	417	+ nh_waybillItem.setM_strJYG1("");
	418	+ //加油工工号1
	419	+ nh_waybillItem.setM_strJYG2("");
	420	+ //油耗类型1
	421	+ nh_waybillItem.setM_strYHLX1(oilInfo.getRylx());
	422	+ //油耗类型2
	423	+ nh_waybillItem.setM_strYHLX1("");
	424	+ }
	425	+
	426	+ elecInfo = elecInfoMap.get(list.get(0).getClZbh() + "_" + list.get(0).getjGh());
	427	+ if (elecInfo != null) {
	428	+ //出场存油
	429	+ nh_waybillItem.setM_dblCCCY(100.0);
	430	+ //进场存油
	431	+ nh_waybillItem.setM_dblJCCY(100.0);
	432	+ //加注量1
	433	+ nh_waybillItem.setM_dblJZL1(elecInfo.getCdl());
	434	+ //加注量2
	435	+ nh_waybillItem.setM_dblJZL2(0.0);
	436	+ //尿素
	437	+ nh_waybillItem.setM_dblNS(0.0);
	438	+ //消耗量
	439	+ nh_waybillItem.setM_dblYH(elecInfo.getHd());
	440	+ //加油地点1
	441	+ nh_waybillItem.setM_strJYD1("");
	442	+ //加油地点2
	443	+ nh_waybillItem.setM_strJYD2("");
	444	+ //加油工工号1
	445	+ nh_waybillItem.setM_strJYG1("");
	446	+ //加油工工号1
	447	+ nh_waybillItem.setM_strJYG2("");
	448	+ //油耗类型1
	449	+ nh_waybillItem.setM_strYHLX1("");
	450	+ //油耗类型2
	451	+ nh_waybillItem.setM_strYHLX1("");
	452	+ }
	453	+
	454	+ nh_waybill.getM_SubInfos().add(nh_waybillItem);
	455	+ }
	456	+
	457	+ rs[i] = nh_waybill;
	458	+ }
	459	+ return rs;
	460	+ }
	461	+
	462	+
	463	+ /**
	464	+ * 将实际排班和油耗数据转换成上南路单需要的数据格式
	465	+ *
	466	+ * @param listMap
	467	+ * @param oilInfoMap
	468	+ * @return
	469	+ */
	470	+ public static SN_waybill[] to_waybill_SN(ArrayListMultimap<String, ScheduleRealInfo> listMap, Map<String, OilInfo> oilInfoMap) throws NoSuchFieldException {
	471	+
	472	+ List<String> nbbmArray = new ArrayList<>(listMap.keySet());
	473	+ SN_waybill[] rs = new SN_waybill[nbbmArray.size()];
	474	+ Field jGhField = ScheduleRealInfo.class.getDeclaredField("jGh");
	475	+
	476	+ List<ScheduleRealInfo> list;
	477	+ ArrayListMultimap<String, ScheduleRealInfo> jGhListMap;
	478	+ ScheduleRealInfo sch;
	479	+ SN_waybill sn_waybill;
	480	+ SN_waybillItem sn_waybillItem;
	481	+
	482	+ OilComp oilComp = new OilComp();
	483	+ List<OilInfo> oilArray;
	484	+ for (int i = 0; i < nbbmArray.size(); i++) {
	485	+ list = listMap.get(nbbmArray.get(i));
	486	+ if (list.size() == 0)
	487	+ continue;
	488	+
	489	+ sch = list.get(0);
	490	+ sn_waybill = new SN_waybill();
	491	+ sn_waybill.setLine_no(sch.getXlBm());
	492	+ sn_waybill.setWork_date(sch.getScheduleDateStr());
	493	+ sn_waybill.setComp_id(sch.getFgsBm());
	494	+ sn_waybill.setGuidecard(sch.getLpName());
	495	+ sn_waybill.setCar_id(sch.getClZbh());
	496	+ //实际班次
	497	+ sn_waybill.setAct_num(ScheduleCalculator.countSJJHBC(list));
	498	+ //晚班实际班次
	499	+ sn_waybill.setL_act_num(ScheduleCalculator.countSJJHBC(ScheduleCalculator.lastArray(list)));
	500	+ //营业里程
	501	+ sn_waybill.setWork_way(ScheduleCalculator.calcYYLC(list));
	502	+ //空驶里程
	503	+ sn_waybill.setLeisure_way(ScheduleCalculator.calcKSLC(list));
	504	+ //总里程
	505	+ sn_waybill.setCount_way(ScheduleCalculator.calcZLC(list));
	506	+ //路单类型(0普通,1包车)
	507	+ sn_waybill.setLd_type("0");
	508	+ //油料类型(2、柴油 3、天然气 4、汽油柴油 5、液化气 6、液化气汽油 7、液化气柴油 8、天然气汽油 9、电)
	509	+ //暂时全部柴油车
	510	+ sn_waybill.setOil_type("2");
	511	+
	512	+ //根据车辆获取油量信息
	513	+ oilArray = likeGet(oilInfoMap, sch.getClZbh() + "_");
	514	+ if (oilArray.size() > 0) {
	515	+ Collections.sort(oilArray, oilComp);
	516	+ //出厂存油
	517	+ sn_waybill.setOut_oil(oilArray.get(0).getCzyl());
	518	+ //油料加注
	519	+ sn_waybill.setAdd_oil(sumAddOil(oilArray));
	520	+ //进场存油
	521	+ sn_waybill.setEnd_oil(oilArray.get(oilArray.size() - 1).getJzyl());
	522	+ //油料消耗
	523	+ sn_waybill.setExpend_oil(countOilExpend(oilArray));
	524	+ //非营业用油类型非营业用油类型(1.常规车2.包车3.加开包车)
	525	+ sn_waybill.setNowork_oil_type("1");
	526	+ //非营业用油
	527	+ sn_waybill.setNowork_oil(0);
	528	+ //非营业用油油耗量(保养用油)
	529	+ sn_waybill.setNowork_oil1(0);
	530	+ //非营业用油油耗量(票务用油)
	531	+ sn_waybill.setNowork_oil2(0);
	532	+ //非营业用油油耗量(其他用油)
	533	+ sn_waybill.setNowork_oil3(0);
	534	+ //营业用油
	535	+ sn_waybill.setWork_oil(countOilExpend(oilArray));
	536	+ //其他营业用油
	537	+ sn_waybill.setQt_work_oil(0);
	538	+ }
	539	+ sn_waybill.setDriver_detail(new ArrayList<SN_waybillItem>());
	540	+
	541	+ //按驾驶员分组班次，构造路单子项
	542	+ jGhListMap = new ConvertUtil<ScheduleRealInfo>().groupMultiList(list, "_", jGhField);
	543	+ for (String jGh : jGhListMap.keySet()) {
	544	+ list = jGhListMap.get(jGh);
	545	+ sn_waybillItem = new SN_waybillItem();
	546	+ sch = list.get(0);
	547	+ //司机编号
	548	+ sn_waybillItem.setDriver_no(sch.getjGh());
	549	+ //司机名称
	550	+ sn_waybillItem.setDriver_name(sch.getjName());
	551	+ //售票员编号
	552	+ sn_waybillItem.setBusman_no(sch.getsGh());
	553	+ //售票员名称
	554	+ sn_waybillItem.setBusman_name(sch.getsName());
	555	+ //行驶里程
	556	+ sn_waybillItem.setDriver_way(ScheduleCalculator.calcYYLC(list));
	557	+ //空驶公里
	558	+ sn_waybillItem.setKs_way(ScheduleCalculator.calcKSLC(list));
	559	+ //柴油加注量、电加注量同一字段
	560	+ sn_waybillItem.setDo_oil_2(countOilExpend(oilArray, sch.getjGh()));
	561	+
	562	+ sn_waybill.getDriver_detail().add(sn_waybillItem);
	563	+ }
	564	+
	565	+ rs[i] = sn_waybill;
	566	+ }
	567	+ return rs;
	568	+ }
	569	+
	570	+ /**
	571	+ * 将实际排班转换成上南需要损失公里数据
	572	+ *
	573	+ * @param listMap
	574	+ * @return
	575	+ */
	576	+ public static SN_lossMileage[] to_lossMileage_SN(ArrayListMultimap<String, ScheduleRealInfo> listMap) throws NoSuchFieldException {
	577	+ List<String> lineArray = new ArrayList<>(listMap.keySet());
	578	+ SN_lossMileage[] rs = new SN_lossMileage[lineArray.size()];
	579	+
	580	+ List<ScheduleRealInfo> list;
	581	+ ScheduleRealInfo sch;
	582	+ for (int i = 0; i < lineArray.size(); i++) {
	583	+ list = listMap.get(lineArray.get(i));
	584	+
	585	+ sch = list.get(0);
	586	+ SN_lossMileage lossMileage = new SN_lossMileage();
	587	+ //线路编号
	588	+ lossMileage.setLine_id(sch.getXlBm());
	589	+ //营运日期
	590	+ lossMileage.setWork_date(sch.getScheduleDateStr());
	591	+ //分公司编号
	592	+ lossMileage.setComp_id(sch.getFgsBm());
	593	+ //少驶公里
	594	+ lossMileage.setLoss_way(ScheduleCalculator.calcCJLC(list));
	595	+ //实际公里
	596	+ lossMileage.setAct_way(ScheduleCalculator.calcYYLC(list));
	597	+ //计划公里
	598	+ lossMileage.setJh_way(ScheduleCalculator.calcJHLC(list));
	599	+
	600	+ //路阻损失公里
	601	+ lossMileage.setLoss_lz(ScheduleCalculator.calcCJLC2(list, "路阻"));
	602	+ //吊慢损失公里
	603	+ lossMileage.setLoss_dm(ScheduleCalculator.calcCJLC2(list, "吊慢"));
	604	+ //故障损失公里
	605	+ lossMileage.setLoss_gz(ScheduleCalculator.calcCJLC2(list, "故障"));
	606	+ //纠纷损失公里
	607	+ lossMileage.setLoss_jf(ScheduleCalculator.calcCJLC2(list, "纠纷"));
	608	+ //肇事损失公里
	609	+ lossMileage.setLoss_zs(ScheduleCalculator.calcCJLC2(list, "肇事"));
	610	+ //缺人损失公里
	611	+ lossMileage.setLoss_qr(ScheduleCalculator.calcCJLC2(list, "缺人"));
	612	+ //缺车损失公里
	613	+ lossMileage.setLoss_qc(ScheduleCalculator.calcCJLC2(list, "缺车"));
	614	+ //客稀损失公里
	615	+ lossMileage.setLoss_kx(ScheduleCalculator.calcCJLC2(list, "客稀"));
	616	+ //其他损失公里
	617	+ lossMileage.setLoss_qt(ScheduleCalculator.calcCJLC2(list, "其他"));
	618	+ //配车损失公里
	619	+ lossMileage.setLoss_pc(ScheduleCalculator.calcCJLC2(list, "配车"));
	620	+ //保养损失公里
	621	+ lossMileage.setLoss_by(ScheduleCalculator.calcCJLC2(list, "保养"));
	622	+ //气候损失公里
	623	+ lossMileage.setLoss_qh(ScheduleCalculator.calcCJLC2(list, "气候"));
	624	+ //援外损失公里
	625	+ lossMileage.setLoss_yw(ScheduleCalculator.calcCJLC2(list, "援外"));
	626	+ //抽减损失公里
	627	+ lossMileage.setLoss_cj(ScheduleCalculator.calcCJLC2(list, "抽减"));
	628	+
	629	+ //实际班次
	630	+ lossMileage.setAct_num(ScheduleCalculator.countSJJHBC(list));
	631	+ //早班班次
	632	+ lossMileage.setEarly_num(ScheduleCalculator.countSJJHBC(ScheduleCalculator.earlyArray(list)));
	633	+ //晚班班次
	634	+ lossMileage.setLate_num(ScheduleCalculator.countSJJHBC(ScheduleCalculator.lastArray(list)));
	635	+ //另加班次
	636	+ lossMileage.setL_act_num(ScheduleCalculator.countZJBC(list));
	637	+ //早班另加班次
	638	+ lossMileage.setL_early_num(ScheduleCalculator.countZJBC(ScheduleCalculator.earlyArray(list)));
	639	+ //晚班另加班次
	640	+ lossMileage.setL_late_num(ScheduleCalculator.countZJBC(ScheduleCalculator.lastArray(list)));
	641	+ //计划班次
	642	+ lossMileage.setJ_act_num(ScheduleCalculator.countJHBC(list));
	643	+ //早班计划班次
	644	+ lossMileage.setJ_early_num(ScheduleCalculator.countJHBC(ScheduleCalculator.earlyArray(list)));
	645	+ //晚班计划班次
	646	+ lossMileage.setJ_late_num(ScheduleCalculator.countJHBC(ScheduleCalculator.lastArray(list)));
	647	+ //放站班次
	648	+ lossMileage.setF_act_bc(ScheduleCalculator.countEmpty(list));
	649	+ //早班放站班次
	650	+ lossMileage.setF_early_bc(ScheduleCalculator.countEmpty(ScheduleCalculator.earlyArray(list)));
	651	+ //晚班放站班次
	652	+ lossMileage.setF_late_bc(ScheduleCalculator.countEmpty(ScheduleCalculator.lastArray(list)));
	653	+ //调头班次
	654	+ lossMileage.setDt_act_bc(0);
	655	+ //早班调头班次
	656	+ lossMileage.setDt_early_bc(0);
	657	+ //晚班调头班次
	658	+ lossMileage.setDt_late_bc(0);
	659	+ //大间隔班次
	660	+ lossMileage.setD_act_num(ScheduleCalculator.countSpaceLg(list));
	661	+ //早班大间隔班次
	662	+ lossMileage.setD_early_num(ScheduleCalculator.countSpaceLg(ScheduleCalculator.earlyArray(list)));
	663	+ //晚班大间隔班次
	664	+ lossMileage.setD_late_num(ScheduleCalculator.countSpaceLg(ScheduleCalculator.lastArray(list)));
	665	+ //最大间隔时间
	666	+ lossMileage.setD_act_max(ScheduleCalculator.calcMaxSpace(list));
	667	+ //故障分
	668	+ lossMileage.setLoss_gzf(0);
	669	+ //故障次数
	670	+ lossMileage.setLoss_gzcs(0);
	671	+
	672	+
	673	+ rs[i] = lossMileage;
	674	+ }
	675	+ return rs;
	676	+ }
	677	+
	678	+ private static double countOilExpend(List<OilInfo> oilArray) {
	679	+ double sum = 0;
	680	+ for (OilInfo oilInfo : oilArray) {
	681	+ sum = Arith.add(sum, oilInfo.getYh());
	682	+ }
	683	+ return sum;
	684	+ }
	685	+
	686	+ private static double sumAddOil(List<OilInfo> oilArray) {
	687	+ double sum = 0;
	688	+ for (OilInfo oilInfo : oilArray) {
	689	+ sum = Arith.add(sum, oilInfo.getJzl());
	690	+ }
	691	+ return sum;
	692	+ }
	693	+
	694	+ private static double countOilExpend(List<OilInfo> oilArray, String jGh) {
	695	+ double sum = 0;
	696	+ for (OilInfo oilInfo : oilArray) {
	697	+ if (oilInfo.getJsy().equals(jGh))
	698	+ sum = Arith.add(sum, oilInfo.getYh());
	699	+ }
	700	+ return sum;
	701	+ }
	702	+
	703	+ public static <T> List<T> likeGet(Map<String, T> map, String key) {
	704	+ Set<String> ks = map.keySet();
	705	+ List<T> list = new ArrayList<>();
	706	+
	707	+ if (StringUtils.isEmpty(key))
	708	+ return list;
	709	+
	710	+ for (String k : ks) {
	711	+ if (k.indexOf(key) != -1) {
	712	+ list.add(map.get(k));
	713	+ }
	714	+ }
	715	+ return list;
	716	+ }
	717	+
	718	+ /**
	719	+ * 将数据转换成南汇工资系统需要的驾驶员考勤数据
	720	+ *
	721	+ * @param plans
	722	+ * @param reals
	723	+ * @param types
	724	+ * @return
	725	+ */
	726	+ public static Jsy_attendance[] to_jsyAttendanceNH(List<SchedulePlanInfo> plans, List<ScheduleRealInfo> reals, Set<String> jsySet, Map<String, String> types, String rq) {
	727	+ //List<String> ghArray = new ArrayList<>(types.keySet());
	728	+ List<Jsy_attendance> rs = new ArrayList<Jsy_attendance>();
	729	+ for (String jGh : jsySet) {
	730	+ List<SchedulePlanInfo> _plans = searchByJsy(plans, jGh);
	731	+ List<ScheduleRealInfo> _reals = searchRealByJsy(reals, jGh);
	732	+ Set<String> _lines = new HashSet<String>();
	733	+ for (SchedulePlanInfo _plan : _plans) {
	734	+ _lines.add(_plan.getXlBm());
	735	+ }
	736	+ for (ScheduleRealInfo _real : _reals) {
	737	+ _lines.add(_real.getXlBm());
	738	+ }
	739	+ for (String _line : _lines) {
	740	+ Jsy_attendance attendance = new Jsy_attendance();
	741	+ SchedulePlanInfo plan = null;
	742	+ ScheduleRealInfo real = null;
	743	+ for (SchedulePlanInfo _plan : _plans) {
	744	+ if (_line.equals(_plan.getXlBm())) {
	745	+ plan = _plan;
	746	+ break;
	747	+ }
	748	+ }
	749	+ for (ScheduleRealInfo _real : _reals) {
	750	+ if (_line.equals(_real.getXlBm())) {
	751	+ real = _real;
	752	+ break;
	753	+ }
	754	+ }
	755	+ attendance.setRq(rq);
	756	+ //考勤
	757	+ attendance.setStatus((plan==null?"0":"1") + "," + (real==null?"0":"1"));
	758	+ //班型
	759	+ attendance.setPlanType(types.get(jGh)==null?"1":types.get(jGh));
	760	+ //驾驶员工号
	761	+ attendance.setjGh(jGh);
	762	+ //早晚班类型
	763	+ attendance.calcZybType(reals);
	764	+
	765	+ //实际计划
	766	+ if(real != null){
	767	+ attendance.setXlBm(real.getXlBm());
	768	+ attendance.setXlName(real.getXlName());
	769	+ attendance.setjName(real.getjName());
	770	+ attendance.setsGh(real.getsGh());
	771	+ attendance.setsName(real.getsName());
	772	+ attendance.setCompany(real.getGsBm());
	773	+ attendance.setFgsCompany(real.getFgsBm());
	774	+ attendance.addLpName(real.getLpName());
	775	+ attendance.addCl(real.getClZbh());
	776	+ }
	777	+ //计划
	778	+ else if(plan != null){
	779	+ attendance.setXlBm(plan.getXlBm());
	780	+ attendance.setXlName(plan.getXlName());
	781	+ attendance.setjName(plan.getjName());
	782	+ attendance.setsGh(plan.getsGh());
	783	+ attendance.setsName(plan.getsName());
	784	+ attendance.setCompany(plan.getGsBm());
	785	+ attendance.setFgsCompany(plan.getFgsBm());
	786	+ attendance.addLpName(plan.getLpName());
	787	+ attendance.addCl(plan.getClZbh());
	788	+ }
	789	+
	790	+ rs.add(attendance);
	791	+ }
	792	+ }
	793	+
	794	+ return rs.toArray(new Jsy_attendance[rs.size()]);
	795	+ }
	796	+
	797	+ public static List<SchedulePlanInfo> searchByJsy(List<SchedulePlanInfo> plans, String jGh){
	798	+ List<SchedulePlanInfo> rs = new ArrayList<SchedulePlanInfo>();
	799	+ String oldLineId = "0";
	800	+ for(SchedulePlanInfo plan : plans){
	801	+ if (plan.getjGh().equals(jGh) && !oldLineId.equals(plan.getXlBm())) {
	802	+ rs.add(plan);
	803	+ oldLineId = plan.getXlBm();
	804	+ }
	805	+ }
	806	+
	807	+ return rs;
	808	+ }
	809	+
	810	+ public static List<ScheduleRealInfo> searchRealByJsy(List<ScheduleRealInfo> reals, String jGh){
	811	+ List<ScheduleRealInfo> rs = new ArrayList<ScheduleRealInfo>();
	812	+ String oldLineId = "0";
	813	+ for(ScheduleRealInfo sch : reals){
	814	+ if (sch.getjGh().equals(jGh) && !oldLineId.equals(sch.getXlBm())) {
	815	+ rs.add(sch);
	816	+ oldLineId = sch.getXlBm();
	817	+ }
	818	+ }
	819	+
	820	+ return rs;
	821	+ }
	822	+
	823	+ /**
	824	+ * 将排班和油耗转换成综合查询需要的数据
	825	+ * @param schList
	826	+ * @param oilList
	827	+ * @return
	828	+ */
	829	+ public static String[] to_getLSLC_PB(String fdate, List<ScheduleRealInfo> schList, List<OilInfo> oilList, List<SchedulePlanInfo> planList) {
	830	+ String[] array = new String[0];
	831	+ try {
	832	+ //按日期分组数据
	833	+ ArrayListMultimap<String, ScheduleRealInfo> schMultimap =
	834	+ new ConvertUtil().groupMultiList(schList, "_", ScheduleRealInfo.class.getDeclaredField("scheduleDateStr"));
	835	+
	836	+ ArrayListMultimap<String, OilInfo> oilMultimap =
	837	+ new ConvertUtil().groupMultiList(oilList, "_", OilInfo.class.getDeclaredField("rq"));
	838	+
	839	+ ArrayListMultimap<String, SchedulePlanInfo> planMultimap =
	840	+ new ConvertUtil().groupMultiList(planList, "_", SchedulePlanInfo.class.getDeclaredField("scheduleDate"));
	841	+
	842	+
	843	+ //月份有多少天
	844	+ int year = Integer.parseInt(fdate.substring(0, 4));
	845	+ int month = Integer.parseInt(fdate.substring(5, 7));
	846	+ Calendar cal = Calendar.getInstance();
	847	+ cal.set(Calendar.YEAR,year);
	848	+ cal.set(Calendar.MONTH,month - 1);//从0开始
	849	+ int maxDate = cal.getActualMaximum(Calendar.DATE);
	850	+
	851	+ List<LsLcPb> rs = new ArrayList<>();
	852	+ LsLcPb lcPb;
	853	+ List<ScheduleRealInfo> pbList;
	854	+ List<SchedulePlanInfo> jhList;
	855	+ List<OilInfo> yhList;
	856	+ String rq,rq2;
	857	+ SchedulePlanInfo outPlan;
	858	+ int currentDay = cal.get(Calendar.DAY_OF_MONTH);
	859	+ for(int i = 1; i <= maxDate; i++){
	860	+ lcPb = new LsLcPb();
	861	+ lcPb.setDay(i);
	862	+
	863	+ rq = fdate + "-" + (i < 10?"0":"") + i;
	864	+ rq2 = rq.replaceAll("-", "");
	865	+
	866	+ pbList = schMultimap.get(rq);
	867	+ yhList = oilMultimap.get(rq2);
	868	+ jhList = planMultimap.get(rq2);
	869	+
	870	+ if(i < currentDay){
	871	+ if(pbList == null \|\| pbList.size() == 0)
	872	+ lcPb.setType(4);//休息
	873	+ else{
	874	+ lcPb.setType(1);
	875	+ lcPb.setLckq("");
	876	+ if(yhList != null && yhList.size() > 0){
	877	+ lcPb.setLcyh(yhList.get(0).getYh());
	878	+ }
	879	+ lcPb.setLcyylc(ScheduleCalculator.calcYYLC(pbList));
	880	+ lcPb.setLcfyylc(ScheduleCalculator.calcKSLC(pbList));
	881	+ }
	882	+ }
	883	+ else if (i == currentDay)
	884	+ lcPb.setType(3);//今天
	885	+ else {
	886	+ if(jhList == null \|\| jhList.size() == 0)
	887	+ lcPb.setType(4);//休息
	888	+ else{
	889	+ lcPb.setType(2);
	890	+ outPlan = getOutSch(jhList);
	891	+ if(null != outPlan){
	892	+ lcPb.setPbxl(outPlan.getXlName());
	893	+ lcPb.setPblp(outPlan.getLpName());
	894	+ lcPb.setPbbd(minusMinute(outPlan.getFcsj(), 15));
	895	+ lcPb.setPbyc(outPlan.getClZbh());
	896	+ }
	897	+ else
	898	+ lcPb.setType(4);//休息
	899	+ }
	900	+ }
	901	+
	902	+ rs.add(lcPb);
	903	+ }
	904	+
	905	+ //拼接成字符串数组
	906	+ array = new String[rs.size()];
	907	+ StringBuilder sb;
	908	+ for(int i = 0,len=rs.size(); i < len; i++){
	909	+ lcPb = rs.get(i);
	910	+ sb = new StringBuilder();
	911	+
	912	+ sb.append(lcPb.getType());
	913	+
	914	+ switch (lcPb.getType()){
	915	+ case 1:
	916	+ sb.append("," + lcPb.getLckq());
	917	+ sb.append("," + lcPb.getLcyh());
	918	+ sb.append("," + lcPb.getLcyylc());
	919	+ sb.append("," + lcPb.getLcfyylc());
	920	+ break;
	921	+ case 2:
	922	+ sb.append("," + lcPb.getPbxl());
	923	+ sb.append("," + lcPb.getPblp());
	924	+ sb.append("," + lcPb.getPbbd());
	925	+ sb.append("," + lcPb.getPbyc());
	926	+ break;
	927	+ }
	928	+ sb.append("," + lcPb.getDay());
	929	+ array[i] = sb.toString();
	930	+ }
	931	+ } catch (NoSuchFieldException e) {
	932	+ logger.error("", e);
	933	+ }
	934	+ return array;
	935	+ }
	936	+
	937	+ /**
	938	+ * 将排班和油耗转换成综合查询需要的数据
	939	+ * @param schList
	940	+ * @param oilList
	941	+ * @return
	942	+ */
	943	+ public static List<LsLcPb> to_getLSLC_PB_list(String fdate, List<ScheduleRealInfo> schList, List<OilInfo> oilList, List<SchedulePlanInfo> planList) {
	944	+ List<LsLcPb> rs = new ArrayList<>();
	945	+ try {
	946	+ //按日期分组数据
	947	+ ArrayListMultimap<String, ScheduleRealInfo> schMultimap =
	948	+ new ConvertUtil().groupMultiList(schList, "_", ScheduleRealInfo.class.getDeclaredField("scheduleDateStr"));
	949	+
	950	+ ArrayListMultimap<String, OilInfo> oilMultimap =
	951	+ new ConvertUtil().groupMultiList(oilList, "_", OilInfo.class.getDeclaredField("rq"));
	952	+
	953	+ ArrayListMultimap<String, SchedulePlanInfo> planMultimap =
	954	+ new ConvertUtil().groupMultiList(planList, "_", SchedulePlanInfo.class.getDeclaredField("scheduleDate"));
	955	+
	956	+
	957	+ //月份有多少天
	958	+ int year = Integer.parseInt(fdate.substring(0, 4));
	959	+ int month = Integer.parseInt(fdate.substring(5, 7));
	960	+ Calendar cal = Calendar.getInstance();
	961	+ cal.set(Calendar.YEAR,year);
	962	+ cal.set(Calendar.MONTH,month - 1);//从0开始
	963	+ int maxDate = cal.getActualMaximum(Calendar.DATE);
	964	+
	965	+ LsLcPb lcPb;
	966	+ List<ScheduleRealInfo> pbList;
	967	+ List<SchedulePlanInfo> jhList;
	968	+ List<OilInfo> yhList;
	969	+ String rq,rq2;
	970	+ SchedulePlanInfo outPlan;
	971	+ int currentDay = cal.get(Calendar.DAY_OF_MONTH);
	972	+ for(int i = 1; i <= maxDate; i++){
	973	+ lcPb = new LsLcPb();
	974	+ lcPb.setDay(i);
	975	+
	976	+ rq = fdate + "-" + (i < 10?"0":"") + i;
	977	+ rq2 = rq.replaceAll("-", "");
	978	+
	979	+ pbList = schMultimap.get(rq);
	980	+ yhList = oilMultimap.get(rq2);
	981	+ jhList = planMultimap.get(rq2);
	982	+
	983	+ if(i < currentDay){
	984	+ if(pbList == null \|\| pbList.size() == 0)
	985	+ lcPb.setType(4);//休息
	986	+ else{
	987	+ lcPb.setType(1);
	988	+ lcPb.setLckq("");
	989	+ if(yhList != null && yhList.size() > 0){
	990	+ lcPb.setLcyh(yhList.get(0).getYh());
	991	+ }
	992	+ lcPb.setLcyylc(ScheduleCalculator.calcYYLC(pbList));
	993	+ lcPb.setLcfyylc(ScheduleCalculator.calcKSLC(pbList));
	994	+ }
	995	+ }
	996	+ else if (i == currentDay)
	997	+ lcPb.setType(3);//今天
	998	+ else {
	999	+ if(jhList == null \|\| jhList.size() == 0)
	1000	+ lcPb.setType(4);//休息
	1001	+ else{
	1002	+ lcPb.setType(2);
	1003	+ outPlan = getOutSch(jhList);
	1004	+ if(null != outPlan){
	1005	+ lcPb.setPbxl(outPlan.getXlName());
	1006	+ lcPb.setPblp(outPlan.getLpName());
	1007	+ lcPb.setPbbd(minusMinute(outPlan.getFcsj(), 15));
	1008	+ lcPb.setPbyc(outPlan.getClZbh());
	1009	+ }
	1010	+ else
	1011	+ lcPb.setType(4);//休息
	1012	+ }
	1013	+ }
	1014	+
	1015	+ rs.add(lcPb);
	1016	+ }
	1017	+ } catch (NoSuchFieldException e) {
	1018	+ logger.error("", e);
	1019	+ }
	1020	+ return rs;
	1021	+ }
	1022	+
	1023	+ /**
	1024	+ * HH:mm 格式时间减分钟
	1025	+ * @param dfsj
	1026	+ * @param i
	1027	+ * @return
	1028	+ */
	1029	+ private static String minusMinute(String hhmm, int i) {
	1030	+ try {
	1031	+ SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
	1032	+ long t = sdf.parse(hhmm).getTime();
	1033	+
	1034	+ return sdf.format(new Date(t - (i * 60 * 1000)));
	1035	+ } catch (ParseException e) {
	1036	+ logger.error("", e);
	1037	+ }
	1038	+ return null;
	1039	+ }
	1040	+
	1041	+ private static SchedulePlanInfo getOutSch(List<SchedulePlanInfo> pbList) {
	1042	+
	1043	+ for(SchedulePlanInfo sch : pbList){
	1044	+ if(sch.getBcType().equals("out"))
	1045	+ return sch;
	1046	+ }
	1047	+ return null;
	1048	+ }
	1049	+
	1050	+ public static class OilComp implements Comparator<OilInfo> {
	1051	+
	1052	+ @Override
	1053	+ public int compare(OilInfo o1, OilInfo o2) {
	1054	+ return o1.getJcsx() - o2.getJcsx();
	1055	+ }
	1056	+ }
	1057	+
	1058	+
	1059	+}
...	...

潘钊 / control_service_data_Interface · Commits

GitLab

逻辑修正