逻辑修正 (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

逻辑修正