路单数据接口添加氢能源 (59239920) | Commits | 潘钊 / control_service_data_Interface

Browse Code »

Commit 59239920e9e7bf4f0f719ef99a1f42ad69333dc7

Authored by 娄高锋 2024-11-09 05:08:19 +0800

1 parent 4482eaed

build: skipped

路单数据接口添加氢能源

Inline Side-by-side

Showing 1 changed file with 1345 additions and 1309 deletions

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

View file @5923992

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

潘钊 / control_service_data_Interface · Commits

GitLab

路单数据接口添加氢能源