1.加入油电信息的合计 (2573197a) | Commits | 潘钊 / control_service_data_Interface

Browse Code »

Commit 2573197a7d97610d7734e3089a23a432b094da00

Authored by 王通 2020-01-06 17:28:09 +0800

1 parent 521fe945

build: skipped

1.加入油电信息的合计

Inline Side-by-side

Showing 4 changed files with 1797 additions and 1743 deletions

src/main/java/com/bsth/redis/ElecRedisService.java

View file @2573197

1	-package com.bsth.redis;
2	-
3	-import com.bsth.Application;
4	-import com.bsth.entity.ElecInfo;
5	-import com.bsth.redis.util.RedisUtils;
6	-import com.bsth.repository.ElecInfoRepository;
7	-import com.bsth.util.ConfigUtil;
8	-import com.bsth.util.ConvertUtil;
9	-import com.google.common.collect.ArrayListMultimap;
10	-import org.joda.time.DateTime;
11	-import org.slf4j.Logger;
12	-import org.slf4j.LoggerFactory;
13	-import org.springframework.beans.factory.annotation.Autowired;
14	-import org.springframework.boot.CommandLineRunner;
15	-import org.springframework.core.annotation.Order;
16	-import org.springframework.data.redis.core.RedisTemplate;
17	-import org.springframework.data.redis.serializer.StringRedisSerializer;
18	-import org.springframework.stereotype.Component;
19	-import org.springframework.stereotype.Service;
20	-
21	-import java.util.*;
22	-import java.util.concurrent.TimeUnit;
23	-
24	-/**
25	- * 油量数据Redis缓存
26	- * Created by panzhao on 2017/3/19.
27	- */
28	-@Service
29	-@Order(3)
30	-public class ElecRedisService implements CommandLineRunner {
31	-
32	- @Autowired
33	- private RedisTemplate redisTemplate;
34	-
35	- @Autowired
36	- ElecInfoRepository elecInfoRepository;
37	-
38	- @Autowired
39	- RedisUtils redisUtils;
40	-
41	- static Logger logger = LoggerFactory.getLogger(ElecRedisService.class);
42	-
43	- private final static String REDIS_KEY_PREFIX = "elec:";
44	-
45	- /**
46	- * 将油量数据写入redis
47	- *
48	- * @param list
49	- */
50	- public void wirte(List<ElecInfo> list) {
51	- ArrayListMultimap<String, ElecInfo> multimap;
52	- try {
53	- if (list.size() == 0)
54	- return;
55	- //按日期和线路分组数据
56	- Class clazz = ElecInfo.class;
57	- multimap = new ConvertUtil().groupMultiList(list, ":", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("rq"));
58	-
59	- //写入redis
60	- Iterator<String> iterator = multimap.keySet().iterator();
61	- String key;
62	- while (iterator.hasNext()) {
63	- key = iterator.next();
64	- mergeData(key, multimap.get(key));
65	- }
66	- } catch (Exception e) {
67	- logger.error("", e);
68	- }
69	- }
70	-
71	- /**
72	- * 根据车辆和日期获取油耗数据，以车辆_驾驶员为key
73	- *
74	- * @param nbbmArray
75	- * @param rq
76	- * @return
77	- */
78	- public Map<String, ElecInfo> findByNbbmGroup(Iterable<String> nbbmArray, String rq) {
79	- Map<String, ElecInfo> rs = new HashMap<>();
80	-
81	- rq = rq.replaceAll("-", "");
82	- try {
83	- List<ElecInfo> list = new ArrayList<>();
84	- for (String nbbm : nbbmArray) {
85	- nbbm = nbbm.split("_")[1];
86	- list.addAll(read(nbbm, rq));
87	- }
88	- Class clazz = ElecInfo.class;
89	- rs = new ConvertUtil().groupList(list, "_", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("jsy"));
90	- } catch (Exception e) {
91	- logger.error("", e);
92	- }
93	- return rs;
94	- }
95	-
96	- public List<ElecInfo> read(String nbbm, String rq) {
97	- return redisTemplate.opsForList().range(REDIS_KEY_PREFIX + nbbm + ":" + rq, 0, -1);
98	- }
99	-
100	- /**
101	- * 将 list 与redis里的数据合并
102	- *
103	- * @param key
104	- * @param list
105	- */
106	- public void mergeData(String key, List<ElecInfo> list) {
107	- key = REDIS_KEY_PREFIX + key;
108	-
109	- //更新直接覆盖更新
110	- redisTemplate.execute(redisUtils.getUpdateCallback(key, list));
111	- }
112	-
113	- @Autowired
114	- ElecRefreshThread elecRefreshThread;
115	-
116	- @Override
117	- public void run(String... strings) throws Exception {
118	- Application.mainServices.schedule(new Runnable() {
119	- @Override
120	- public void run() {
121	- //启动加载油耗缓存
122	- synchData(null);
123	- }
124	- }, 30, TimeUnit.SECONDS);
125	-
126	-
127	- //定时刷新油耗信息
128	- Application.mainServices.scheduleWithFixedDelay(elecRefreshThread, 60 * 40, 60 * 40, TimeUnit.SECONDS);
129	- }
130	-
131	- /**
132	- * 和数据库同步数据
133	- */
134	- public void synchData(Integer days) {
135	- int cacheDays = Integer.parseInt(ConfigUtil.get("cache.days"));
136	- if (null != days && days < cacheDays)
137	- cacheDays = days;
138	- //设置key 序列化器
139	- redisTemplate.setKeySerializer(new StringRedisSerializer());
140	-
141	- DateTime dt = new DateTime();
142	- dt = dt.withHourOfDay(0).withMinuteOfHour(0).withSecondOfMinute(0).minusDays(cacheDays);
143	- List<ElecInfo> list = elecInfoRepository.findByDateLT(dt.toDate());
144	- //写入redis
145	- wirte(list);
146	- logger.info("刷新电耗数据, days: " + cacheDays + " -size: " + list.size() + " -LT: " + dt.toString("yyyy-MM-dd"));
147	- }
148	-
149	- @Component
150	- public static class ElecRefreshThread extends Thread {
151	-
152	- @Autowired
153	- ElecRedisService elecRedisService;
154	-
155	- @Override
156	- public void run() {
157	- try {
158	- elecRedisService.synchData(5);
159	- } catch (Exception e) {
160	- logger.error("", e);
161	- }
162	- }
163	- }
164	-}	1	+package com.bsth.redis;
		2	+
		3	+import com.bsth.Application;
		4	+import com.bsth.entity.ElecInfo;
		5	+import com.bsth.redis.util.RedisUtils;
		6	+import com.bsth.repository.ElecInfoRepository;
		7	+import com.bsth.util.ConfigUtil;
		8	+import com.bsth.util.ConvertUtil;
		9	+import com.google.common.collect.ArrayListMultimap;
		10	+import org.joda.time.DateTime;
		11	+import org.slf4j.Logger;
		12	+import org.slf4j.LoggerFactory;
		13	+import org.springframework.beans.factory.annotation.Autowired;
		14	+import org.springframework.boot.CommandLineRunner;
		15	+import org.springframework.core.annotation.Order;
		16	+import org.springframework.data.redis.core.RedisTemplate;
		17	+import org.springframework.data.redis.serializer.StringRedisSerializer;
		18	+import org.springframework.stereotype.Component;
		19	+import org.springframework.stereotype.Service;
		20	+
		21	+import java.util.*;
		22	+import java.util.concurrent.TimeUnit;
		23	+
		24	+/**
		25	+ * 油量数据Redis缓存
		26	+ * Created by panzhao on 2017/3/19.
		27	+ */
		28	+@Service
		29	+@Order(3)
		30	+public class ElecRedisService implements CommandLineRunner {
		31	+
		32	+ @Autowired
		33	+ private RedisTemplate redisTemplate;
		34	+
		35	+ @Autowired
		36	+ ElecInfoRepository elecInfoRepository;
		37	+
		38	+ @Autowired
		39	+ RedisUtils redisUtils;
		40	+
		41	+ static Logger logger = LoggerFactory.getLogger(ElecRedisService.class);
		42	+
		43	+ private final static String REDIS_KEY_PREFIX = "elec:";
		44	+
		45	+ /**
		46	+ * 将油量数据写入redis
		47	+ *
		48	+ * @param list
		49	+ */
		50	+ public void wirte(List<ElecInfo> list) {
		51	+ ArrayListMultimap<String, ElecInfo> multimap;
		52	+ try {
		53	+ if (list.size() == 0)
		54	+ return;
		55	+ //按日期和线路分组数据
		56	+ Class clazz = ElecInfo.class;
		57	+ multimap = new ConvertUtil().groupMultiList(list, ":", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("rq"));
		58	+
		59	+ //写入redis
		60	+ Iterator<String> iterator = multimap.keySet().iterator();
		61	+ String key;
		62	+ while (iterator.hasNext()) {
		63	+ key = iterator.next();
		64	+ mergeData(key, multimap.get(key));
		65	+ }
		66	+ } catch (Exception e) {
		67	+ logger.error("", e);
		68	+ }
		69	+ }
		70	+
		71	+ /**
		72	+ * 根据车辆和日期获取油耗数据，以车辆_驾驶员为key
		73	+ *
		74	+ * @param nbbmArray
		75	+ * @param rq
		76	+ * @return
		77	+ */
		78	+ public ArrayListMultimap findByNbbmGroup(Iterable<String> nbbmArray, String rq) {
		79	+ ArrayListMultimap rs = ArrayListMultimap.create();
		80	+
		81	+ rq = rq.replaceAll("-", "");
		82	+ try {
		83	+ List<ElecInfo> list = new ArrayList<>();
		84	+ for (String nbbm : nbbmArray) {
		85	+ nbbm = nbbm.split("_")[1];
		86	+ list.addAll(read(nbbm, rq));
		87	+ }
		88	+ Class clazz = ElecInfo.class;
		89	+ rs = new ConvertUtil().groupMultiList(list, "_", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("jsy"));
		90	+ } catch (Exception e) {
		91	+ logger.error("", e);
		92	+ }
		93	+ return rs;
		94	+ }
		95	+
		96	+ public List<ElecInfo> read(String nbbm, String rq) {
		97	+ return redisTemplate.opsForList().range(REDIS_KEY_PREFIX + nbbm + ":" + rq, 0, -1);
		98	+ }
		99	+
		100	+ /**
		101	+ * 将 list 与redis里的数据合并
		102	+ *
		103	+ * @param key
		104	+ * @param list
		105	+ */
		106	+ public void mergeData(String key, List<ElecInfo> list) {
		107	+ key = REDIS_KEY_PREFIX + key;
		108	+
		109	+ //更新直接覆盖更新
		110	+ redisTemplate.execute(redisUtils.getUpdateCallback(key, list));
		111	+ }
		112	+
		113	+ @Autowired
		114	+ ElecRefreshThread elecRefreshThread;
		115	+
		116	+ @Override
		117	+ public void run(String... strings) throws Exception {
		118	+ Application.mainServices.schedule(new Runnable() {
		119	+ @Override
		120	+ public void run() {
		121	+ //启动加载油耗缓存
		122	+ synchData(null);
		123	+ }
		124	+ }, 30, TimeUnit.SECONDS);
		125	+
		126	+
		127	+ //定时刷新油耗信息
		128	+ Application.mainServices.scheduleWithFixedDelay(elecRefreshThread, 60 * 40, 60 * 40, TimeUnit.SECONDS);
		129	+ }
		130	+
		131	+ /**
		132	+ * 和数据库同步数据
		133	+ */
		134	+ public void synchData(Integer days) {
		135	+ int cacheDays = Integer.parseInt(ConfigUtil.get("cache.days"));
		136	+ if (null != days && days < cacheDays)
		137	+ cacheDays = days;
		138	+ //设置key 序列化器
		139	+ redisTemplate.setKeySerializer(new StringRedisSerializer());
		140	+
		141	+ DateTime dt = new DateTime();
		142	+ dt = dt.withHourOfDay(0).withMinuteOfHour(0).withSecondOfMinute(0).minusDays(cacheDays);
		143	+ List<ElecInfo> list = elecInfoRepository.findByDateLT(dt.toDate());
		144	+ //写入redis
		145	+ wirte(list);
		146	+ logger.info("刷新电耗数据, days: " + cacheDays + " -size: " + list.size() + " -LT: " + dt.toString("yyyy-MM-dd"));
		147	+ }
		148	+
		149	+ @Component
		150	+ public static class ElecRefreshThread extends Thread {
		151	+
		152	+ @Autowired
		153	+ ElecRedisService elecRedisService;
		154	+
		155	+ @Override
		156	+ public void run() {
		157	+ try {
		158	+ elecRedisService.synchData(5);
		159	+ } catch (Exception e) {
		160	+ logger.error("", e);
		161	+ }
		162	+ }
		163	+ }
		164	+}

src/main/java/com/bsth/redis/OilRedisService.java

View file @2573197

1	-package com.bsth.redis;
2	-
3	-import com.bsth.Application;
4	-import com.bsth.entity.OilInfo;
5	-import com.bsth.redis.util.RedisUtils;
6	-import com.bsth.repository.OilInfoRepository;
7	-import com.bsth.util.ConfigUtil;
8	-import com.bsth.util.ConvertUtil;
9	-import com.google.common.collect.ArrayListMultimap;
10	-import org.joda.time.DateTime;
11	-import org.slf4j.Logger;
12	-import org.slf4j.LoggerFactory;
13	-import org.springframework.beans.factory.annotation.Autowired;
14	-import org.springframework.boot.CommandLineRunner;
15	-import org.springframework.core.annotation.Order;
16	-import org.springframework.data.redis.core.RedisTemplate;
17	-import org.springframework.data.redis.serializer.StringRedisSerializer;
18	-import org.springframework.stereotype.Component;
19	-import org.springframework.stereotype.Service;
20	-
21	-import java.util.*;
22	-import java.util.concurrent.TimeUnit;
23	-
24	-/**
25	- * 油量数据Redis缓存
26	- * Created by panzhao on 2017/3/19.
27	- */
28	-@Service
29	-@Order(3)
30	-public class OilRedisService implements CommandLineRunner {
31	-
32	- @Autowired
33	- private RedisTemplate redisTemplate;
34	-
35	- @Autowired
36	- OilInfoRepository oilInfoRepository;
37	-
38	- @Autowired
39	- RedisUtils redisUtils;
40	-
41	- static Logger logger = LoggerFactory.getLogger(OilRedisService.class);
42	-
43	- private final static String REDIS_KEY_PREFIX = "oil:";
44	-
45	- /**
46	- * 将油量数据写入redis
47	- *
48	- * @param list
49	- */
50	- public void wirte(List<OilInfo> list) {
51	- ArrayListMultimap<String, OilInfo> multimap;
52	- try {
53	- if (list.size() == 0)
54	- return;
55	- //按日期和线路分组数据
56	- Class clazz = OilInfo.class;
57	- multimap = new ConvertUtil().groupMultiList(list, ":", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("rq"));
58	-
59	- //写入redis
60	- Iterator<String> iterator = multimap.keySet().iterator();
61	- String key;
62	- while (iterator.hasNext()) {
63	- key = iterator.next();
64	- mergeData(key, multimap.get(key));
65	- }
66	- } catch (Exception e) {
67	- logger.error("", e);
68	- }
69	- }
70	-
71	- /**
72	- * 根据车辆和日期获取油耗数据，以车辆_驾驶员为key
73	- *
74	- * @param nbbmArray
75	- * @param rq
76	- * @return
77	- */
78	- public Map<String, OilInfo> findByNbbmGroup(Iterable<String> nbbmArray, String rq) {
79	- Map<String, OilInfo> rs = new HashMap<>();
80	-
81	- rq = rq.replaceAll("-", "");
82	- try {
83	- List<OilInfo> list = new ArrayList<>();
84	- for (String nbbm : nbbmArray) {
85	- nbbm = nbbm.split("_")[1];
86	- list.addAll(read(nbbm, rq));
87	- }
88	- Class clazz = OilInfo.class;
89	- rs = new ConvertUtil().groupList(list, "_", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("jsy"));
90	- } catch (Exception e) {
91	- logger.error("", e);
92	- }
93	- return rs;
94	- }
95	-
96	- public List<OilInfo> read(String nbbm, String rq) {
97	- return redisTemplate.opsForList().range(REDIS_KEY_PREFIX + nbbm + ":" + rq, 0, -1);
98	- }
99	-
100	- /**
101	- * 将 list 与redis里的数据合并
102	- *
103	- * @param key
104	- * @param list
105	- */
106	- public void mergeData(String key, List<OilInfo> list) {
107	- key = REDIS_KEY_PREFIX + key;
108	-
109	- //更新直接覆盖更新
110	- redisTemplate.execute(redisUtils.getUpdateCallback(key, list));
111	- }
112	-
113	- @Autowired
114	- OilRefreshThread oilRefreshThread;
115	-
116	- @Override
117	- public void run(String... strings) throws Exception {
118	- Application.mainServices.schedule(new Runnable() {
119	- @Override
120	- public void run() {
121	- //启动加载油耗缓存
122	- synchData(null);
123	- }
124	- }, 30, TimeUnit.SECONDS);
125	-
126	-
127	- //定时刷新油耗信息
128	- Application.mainServices.scheduleWithFixedDelay(oilRefreshThread, 60 * 40, 60 * 40, TimeUnit.SECONDS);
129	- }
130	-
131	- /**
132	- * 和数据库同步数据
133	- */
134	- public void synchData(Integer days) {
135	- int cacheDays = Integer.parseInt(ConfigUtil.get("cache.days"));
136	- if (null != days && days < cacheDays)
137	- cacheDays = days;
138	- //设置key 序列化器
139	- redisTemplate.setKeySerializer(new StringRedisSerializer());
140	-
141	- DateTime dt = new DateTime();
142	- dt = dt.withHourOfDay(0).withMinuteOfHour(0).withSecondOfMinute(0).minusDays(cacheDays);
143	- List<OilInfo> list = oilInfoRepository.findByDateLT(dt.toDate());
144	- //写入redis
145	- wirte(list);
146	- logger.info("刷新油耗数据, days: " + cacheDays + " -size: " + list.size() + " -LT: " + dt.toString("yyyy-MM-dd"));
147	- }
148	-
149	- @Component
150	- public static class OilRefreshThread extends Thread {
151	-
152	- @Autowired
153	- OilRedisService oilRedisService;
154	-
155	- @Override
156	- public void run() {
157	- try {
158	- oilRedisService.synchData(5);
159	- } catch (Exception e) {
160	- logger.error("", e);
161	- }
162	- }
163	- }
164	-}	1	+package com.bsth.redis;
		2	+
		3	+import com.bsth.Application;
		4	+import com.bsth.entity.OilInfo;
		5	+import com.bsth.redis.util.RedisUtils;
		6	+import com.bsth.repository.OilInfoRepository;
		7	+import com.bsth.util.ConfigUtil;
		8	+import com.bsth.util.ConvertUtil;
		9	+import com.google.common.collect.ArrayListMultimap;
		10	+import org.joda.time.DateTime;
		11	+import org.slf4j.Logger;
		12	+import org.slf4j.LoggerFactory;
		13	+import org.springframework.beans.factory.annotation.Autowired;
		14	+import org.springframework.boot.CommandLineRunner;
		15	+import org.springframework.core.annotation.Order;
		16	+import org.springframework.data.redis.core.RedisTemplate;
		17	+import org.springframework.data.redis.serializer.StringRedisSerializer;
		18	+import org.springframework.stereotype.Component;
		19	+import org.springframework.stereotype.Service;
		20	+
		21	+import java.util.ArrayList;
		22	+import java.util.Map;
		23	+import java.util.HashMap;
		24	+import java.util.Iterator;
		25	+import java.util.List;
		26	+import java.util.concurrent.TimeUnit;
		27	+
		28	+/**
		29	+ * 油量数据Redis缓存
		30	+ * Created by panzhao on 2017/3/19.
		31	+ */
		32	+@Service
		33	+@Order(3)
		34	+public class OilRedisService implements CommandLineRunner {
		35	+
		36	+ @Autowired
		37	+ private RedisTemplate redisTemplate;
		38	+
		39	+ @Autowired
		40	+ OilInfoRepository oilInfoRepository;
		41	+
		42	+ @Autowired
		43	+ RedisUtils redisUtils;
		44	+
		45	+ static Logger logger = LoggerFactory.getLogger(OilRedisService.class);
		46	+
		47	+ private final static String REDIS_KEY_PREFIX = "oil:";
		48	+
		49	+ /**
		50	+ * 将油量数据写入redis
		51	+ *
		52	+ * @param list
		53	+ */
		54	+ public void wirte(List<OilInfo> list) {
		55	+ ArrayListMultimap<String, OilInfo> multimap;
		56	+ try {
		57	+ if (list.size() == 0)
		58	+ return;
		59	+ //按日期和线路分组数据
		60	+ Class clazz = OilInfo.class;
		61	+ multimap = new ConvertUtil().groupMultiList(list, ":", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("rq"));
		62	+
		63	+ //写入redis
		64	+ Iterator<String> iterator = multimap.keySet().iterator();
		65	+ String key;
		66	+ while (iterator.hasNext()) {
		67	+ key = iterator.next();
		68	+ mergeData(key, multimap.get(key));
		69	+ }
		70	+ } catch (Exception e) {
		71	+ logger.error("", e);
		72	+ }
		73	+ }
		74	+
		75	+ /**
		76	+ * 根据车辆和日期获取油耗数据，以车辆_驾驶员为key
		77	+ *
		78	+ * @param nbbmArray
		79	+ * @param rq
		80	+ * @return
		81	+ */
		82	+ public ArrayListMultimap<String, OilInfo> findByNbbmGroup(Iterable<String> nbbmArray, String rq) {
		83	+ ArrayListMultimap<String, OilInfo> rs = ArrayListMultimap.create();
		84	+
		85	+ rq = rq.replaceAll("-", "");
		86	+ try {
		87	+ List<OilInfo> list = new ArrayList<>();
		88	+ for (String nbbm : nbbmArray) {
		89	+ nbbm = nbbm.split("_")[1];
		90	+ list.addAll(read(nbbm, rq));
		91	+ }
		92	+ Class clazz = OilInfo.class;
		93	+ rs = new ConvertUtil().groupMultiList(list, "_", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("jsy"));
		94	+ } catch (Exception e) {
		95	+ logger.error("", e);
		96	+ }
		97	+ return rs;
		98	+ }
		99	+
		100	+ /**
		101	+ * 根据车辆和日期获取油耗数据，以车辆_驾驶员为key
		102	+ *
		103	+ * @param nbbmArray
		104	+ * @param rq
		105	+ * @return
		106	+ */
		107	+ public Map<String, OilInfo> findByNbbmGroupRaw(Iterable<String> nbbmArray, String rq) {
		108	+ Map<String, OilInfo> rs = new HashMap<>();
		109	+
		110	+ rq = rq.replaceAll("-", "");
		111	+ try {
		112	+ List<OilInfo> list = new ArrayList<>();
		113	+ for (String nbbm : nbbmArray) {
		114	+ nbbm = nbbm.split("_")[1];
		115	+ list.addAll(read(nbbm, rq));
		116	+ }
		117	+ Class clazz = OilInfo.class;
		118	+ rs = new ConvertUtil().groupList(list, "_", clazz.getDeclaredField("nbbm"), clazz.getDeclaredField("jsy"));
		119	+ } catch (Exception e) {
		120	+ logger.error("", e);
		121	+ }
		122	+ return rs;
		123	+ }
		124	+
		125	+ public List<OilInfo> read(String nbbm, String rq) {
		126	+ return redisTemplate.opsForList().range(REDIS_KEY_PREFIX + nbbm + ":" + rq, 0, -1);
		127	+ }
		128	+
		129	+ /**
		130	+ * 将 list 与redis里的数据合并
		131	+ *
		132	+ * @param key
		133	+ * @param list
		134	+ */
		135	+ public void mergeData(String key, List<OilInfo> list) {
		136	+ key = REDIS_KEY_PREFIX + key;
		137	+
		138	+ //更新直接覆盖更新
		139	+ redisTemplate.execute(redisUtils.getUpdateCallback(key, list));
		140	+ }
		141	+
		142	+ @Autowired
		143	+ OilRefreshThread oilRefreshThread;
		144	+
		145	+ @Override
		146	+ public void run(String... strings) throws Exception {
		147	+ Application.mainServices.schedule(new Runnable() {
		148	+ @Override
		149	+ public void run() {
		150	+ //启动加载油耗缓存
		151	+ synchData(null);
		152	+ }
		153	+ }, 30, TimeUnit.SECONDS);
		154	+
		155	+
		156	+ //定时刷新油耗信息
		157	+ Application.mainServices.scheduleWithFixedDelay(oilRefreshThread, 60 * 40, 60 * 40, TimeUnit.SECONDS);
		158	+ }
		159	+
		160	+ /**
		161	+ * 和数据库同步数据
		162	+ */
		163	+ public void synchData(Integer days) {
		164	+ int cacheDays = Integer.parseInt(ConfigUtil.get("cache.days"));
		165	+ if (null != days && days < cacheDays)
		166	+ cacheDays = days;
		167	+ //设置key 序列化器
		168	+ redisTemplate.setKeySerializer(new StringRedisSerializer());
		169	+
		170	+ DateTime dt = new DateTime();
		171	+ dt = dt.withHourOfDay(0).withMinuteOfHour(0).withSecondOfMinute(0).minusDays(cacheDays);
		172	+ List<OilInfo> list = oilInfoRepository.findByDateLT(dt.toDate());
		173	+ //写入redis
		174	+ wirte(list);
		175	+ logger.info("刷新油耗数据, days: " + cacheDays + " -size: " + list.size() + " -LT: " + dt.toString("yyyy-MM-dd"));
		176	+ }
		177	+
		178	+ @Component
		179	+ public static class OilRefreshThread extends Thread {
		180	+
		181	+ @Autowired
		182	+ OilRedisService oilRedisService;
		183	+
		184	+ @Override
		185	+ public void run() {
		186	+ try {
		187	+ oilRedisService.synchData(5);
		188	+ } catch (Exception e) {
		189	+ logger.error("", e);
		190	+ }
		191	+ }
		192	+ }
		193	+}

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

View file @2573197

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

src/main/java/com/bsth/server_ws/waybill/LD_ServiceSoap.java

View file @2573197

1	-package com.bsth.server_ws.waybill;
2	-
3	-import java.util.List;
4	-import java.util.Map;
5	-
6	-import javax.jws.WebService;
7	-import javax.xml.ws.Holder;
8	-
9	-import org.joda.time.format.DateTimeFormat;
10	-import org.joda.time.format.DateTimeFormatter;
11	-import org.slf4j.Logger;
12	-import org.slf4j.LoggerFactory;
13	-import org.springframework.beans.BeansException;
14	-import org.springframework.context.ApplicationContext;
15	-import org.springframework.context.ApplicationContextAware;
16	-import org.springframework.stereotype.Component;
17	-
18	-import com.bsth.entity.DutyEmployee;
19	-import com.bsth.entity.ElecInfo;
20	-import com.bsth.entity.OilInfo;
21	-import com.bsth.entity.ScheduleRealInfo;
22	-import com.bsth.redis.ElecRedisService;
23	-import com.bsth.redis.OilRedisService;
24	-import com.bsth.redis.ScheduleRedisService;
25	-import com.bsth.repository.DutyEmployeeRepository;
26	-import com.bsth.server_ws.util.WSDataConver;
27	-import com.bsth.server_ws.waybill.entity.NH_waybill;
28	-import com.bsth.server_ws.waybill.entity.SN_lossMileage;
29	-import com.bsth.server_ws.waybill.entity.SN_waybill;
30	-import com.bsth.service.UserService;
31	-import com.google.common.collect.ArrayListMultimap;
32	-
33	-/**
34	- * Created by panzhao on 2017/3/17.
35	- */
36	-@Component
37	-@WebService(
38	- name = "LD_ServiceSoap",
39	- portName = "LD_ServiceSoap",
40	- serviceName = "LD_Service",
41	- targetNamespace = "http://control.bsth.com/",
42	- endpointInterface = "com.bsth.server_ws.waybill.LD_Service")
43	-public class LD_ServiceSoap implements LD_Service, ApplicationContextAware {
44	-
45	- static OilRedisService oilRedisService;
46	- static ElecRedisService elecRedisService;
47	- static ScheduleRedisService scheduleRedisService;
48	- static DutyEmployeeRepository dutyEmployeeRepository;
49	-
50	- static UserService userService;
51	-
52	- Logger logger = LoggerFactory.getLogger(this.getClass());
53	-
54	- private static DateTimeFormatter fmtyyyyMMddHHmm = DateTimeFormat.forPattern("yyyy-MM-ddHH:mm"),
55	- fmtyyyyMMdd = DateTimeFormat.forPattern("yyyy-MM-dd");
56	-
57	- @Override
58	- public boolean waybill_NH(String password, String rq, String companyId, Holder<NH_waybill[]> result, Holder<String> fError) {
59	- try {
60	- if(userService.get(password) == null){
61	- fError.value = "无效的密码！";
62	- return false;
63	- }
64	- //日期减一天，老接口是这样的
65	- //rq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
66	- String prveRq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
67	-
68	- //实际排班
69	- ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByNbbm(prveRq, companyId);
70	- //油耗信息
71	- Map<String, OilInfo> oilInfoMap = oilRedisService.findByNbbmGroup(listMap.keySet(), prveRq);
72	- //当班调派
73	- long st = fmtyyyyMMddHHmm.parseMillis(prveRq + "00:00"), et = fmtyyyyMMddHHmm.parseMillis(prveRq + "23:59");
74	- List<DutyEmployee> des = dutyEmployeeRepository.findByTime(st, et);
75	- //转换成南汇路单需要的格式
76	- NH_waybill[] array = WSDataConver.to_waybill_NH(listMap, oilInfoMap, des);
77	- result.value = array;
78	-
79	- //不再代理老接口数据
80	- /*if(companyId.equals("26") && !WebServiceProxy.isAllNew(companyId)){
81	- ClsLDInfo[] oldArray = OldWSClient.getNH_LD(companyId, rq);
82	- //合并新老系统的数据
83	- result.value = WebServiceProxy.mergerData(result.value, oldArray, companyId);
84	- }*/
85	- } catch (Exception e) {
86	- logger.error("", e);
87	- fError.value = "服务器出现异常！";
88	- return false;
89	- }
90	- return true;
91	- }
92	-
93	- @Override
94	- public boolean waybill_NH4TH(String password, String rq, String companyId, Holder<NH_waybill[]> result, Holder<String> fError) {
95	- try {
96	- if(userService.get(password) == null){
97	- fError.value = "无效的密码！";
98	- return false;
99	- }
100	- //日期减一天，老接口是这样的
101	- //rq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
102	- String prveRq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
103	-
104	- //实际排班
105	- ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByNbbm(prveRq, companyId);
106	- //油耗信息
107	- Map<String, OilInfo> oilInfoMap = oilRedisService.findByNbbmGroup(listMap.keySet(), prveRq);
108	- //电耗信息
109	- Map<String, ElecInfo> elecInfoMap = elecRedisService.findByNbbmGroup(listMap.keySet(), prveRq);
110	- //当班调派
111	- long st = fmtyyyyMMddHHmm.parseMillis(prveRq + "00:00"), et = fmtyyyyMMddHHmm.parseMillis(prveRq + "23:59");
112	- List<DutyEmployee> des = dutyEmployeeRepository.findByTime(st, et);
113	- //转换成南汇路单需要的格式
114	- NH_waybill[] array = WSDataConver.to_waybill_NH4TH(listMap, oilInfoMap, elecInfoMap, des);
115	- result.value = array;
116	-
117	- //不再代理老接口数据
118	- /*if(companyId.equals("26") && !WebServiceProxy.isAllNew(companyId)){
119	- ClsLDInfo[] oldArray = OldWSClient.getNH_LD(companyId, rq);
120	- //合并新老系统的数据
121	- result.value = WebServiceProxy.mergerData(result.value, oldArray, companyId);
122	- }*/
123	- } catch (Exception e) {
124	- logger.error("", e);
125	- fError.value = "服务器出现异常！";
126	- return false;
127	- }
128	- return true;
129	- }
130	-
131	- @Override
132	- public boolean waybill_SN(String password, String rq, String companyId, Holder<SN_waybill[]> result, Holder<String> fError) {
133	- try {
134	- if(userService.get(password) == null){
135	- fError.value = "无效的密码！";
136	- return false;
137	- }
138	-
139	- //实际排班
140	- ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByNbbm(rq, companyId);
141	- //油耗信息
142	- Map<String, OilInfo> oilInfoMap = oilRedisService.findByNbbmGroup(listMap.keySet(), rq);
143	- //转换成上南路单需要的格式
144	- SN_waybill[] array = WSDataConver.to_waybill_SN(listMap, oilInfoMap);
145	- result.value = array;
146	- } catch (Exception e) {
147	- logger.error("", e);
148	- fError.value = "服务器出现异常！";
149	- return false;
150	- }
151	- return true;
152	- }
153	-
154	- @Override
155	- public boolean lossMileage(String password, String rq, String companyId, Holder<SN_lossMileage[]> result, Holder<String> fError) {
156	- try {
157	- if(userService.get(password) == null){
158	- fError.value = "无效的密码！";
159	- return false;
160	- }
161	-
162	- //按线路分组的实际排班
163	- ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByLine(rq, companyId);
164	- //转换成上南需要的损失公里数据
165	- SN_lossMileage[] array = WSDataConver.to_lossMileage_SN(listMap);
166	- result.value = array;
167	- } catch (Exception e) {
168	- logger.error("", e);
169	- fError.value = "服务器出现异常！";
170	- return false;
171	- }
172	- return false;
173	- }
174	-
175	-
176	- @Override
177	- public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
178	- oilRedisService = applicationContext.getBean(OilRedisService.class);
179	- elecRedisService = applicationContext.getBean(ElecRedisService.class);
180	- scheduleRedisService = applicationContext.getBean(ScheduleRedisService.class);
181	- dutyEmployeeRepository = applicationContext.getBean(DutyEmployeeRepository.class);
182	- userService = applicationContext.getBean(UserService.class);
183	- }
184	-}	1	+package com.bsth.server_ws.waybill;
		2	+
		3	+import java.util.List;
		4	+import java.util.Map;
		5	+
		6	+import javax.jws.WebService;
		7	+import javax.xml.ws.Holder;
		8	+
		9	+import org.joda.time.format.DateTimeFormat;
		10	+import org.joda.time.format.DateTimeFormatter;
		11	+import org.slf4j.Logger;
		12	+import org.slf4j.LoggerFactory;
		13	+import org.springframework.beans.BeansException;
		14	+import org.springframework.context.ApplicationContext;
		15	+import org.springframework.context.ApplicationContextAware;
		16	+import org.springframework.stereotype.Component;
		17	+
		18	+import com.bsth.entity.DutyEmployee;
		19	+import com.bsth.entity.ElecInfo;
		20	+import com.bsth.entity.OilInfo;
		21	+import com.bsth.entity.ScheduleRealInfo;
		22	+import com.bsth.redis.ElecRedisService;
		23	+import com.bsth.redis.OilRedisService;
		24	+import com.bsth.redis.ScheduleRedisService;
		25	+import com.bsth.repository.DutyEmployeeRepository;
		26	+import com.bsth.server_ws.util.WSDataConver;
		27	+import com.bsth.server_ws.waybill.entity.NH_waybill;
		28	+import com.bsth.server_ws.waybill.entity.SN_lossMileage;
		29	+import com.bsth.server_ws.waybill.entity.SN_waybill;
		30	+import com.bsth.service.UserService;
		31	+import com.google.common.collect.ArrayListMultimap;
		32	+
		33	+/**
		34	+ * Created by panzhao on 2017/3/17.
		35	+ */
		36	+@Component
		37	+@WebService(
		38	+ name = "LD_ServiceSoap",
		39	+ portName = "LD_ServiceSoap",
		40	+ serviceName = "LD_Service",
		41	+ targetNamespace = "http://control.bsth.com/",
		42	+ endpointInterface = "com.bsth.server_ws.waybill.LD_Service")
		43	+public class LD_ServiceSoap implements LD_Service, ApplicationContextAware {
		44	+
		45	+ static OilRedisService oilRedisService;
		46	+ static ElecRedisService elecRedisService;
		47	+ static ScheduleRedisService scheduleRedisService;
		48	+ static DutyEmployeeRepository dutyEmployeeRepository;
		49	+
		50	+ static UserService userService;
		51	+
		52	+ Logger logger = LoggerFactory.getLogger(this.getClass());
		53	+
		54	+ private static DateTimeFormatter fmtyyyyMMddHHmm = DateTimeFormat.forPattern("yyyy-MM-ddHH:mm"),
		55	+ fmtyyyyMMdd = DateTimeFormat.forPattern("yyyy-MM-dd");
		56	+
		57	+ @Override
		58	+ public boolean waybill_NH(String password, String rq, String companyId, Holder<NH_waybill[]> result, Holder<String> fError) {
		59	+ try {
		60	+ if(userService.get(password) == null){
		61	+ fError.value = "无效的密码！";
		62	+ return false;
		63	+ }
		64	+ //日期减一天，老接口是这样的
		65	+ //rq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
		66	+ String prveRq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
		67	+
		68	+ //实际排班
		69	+ ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByNbbm(prveRq, companyId);
		70	+ //油耗信息
		71	+ ArrayListMultimap<String, OilInfo> oilInfoMap = oilRedisService.findByNbbmGroup(listMap.keySet(), prveRq);
		72	+ //当班调派
		73	+ long st = fmtyyyyMMddHHmm.parseMillis(prveRq + "00:00"), et = fmtyyyyMMddHHmm.parseMillis(prveRq + "23:59");
		74	+ List<DutyEmployee> des = dutyEmployeeRepository.findByTime(st, et);
		75	+ //转换成南汇路单需要的格式
		76	+ NH_waybill[] array = WSDataConver.to_waybill_NH(listMap, oilInfoMap, des);
		77	+ result.value = array;
		78	+
		79	+ //不再代理老接口数据
		80	+ /*if(companyId.equals("26") && !WebServiceProxy.isAllNew(companyId)){
		81	+ ClsLDInfo[] oldArray = OldWSClient.getNH_LD(companyId, rq);
		82	+ //合并新老系统的数据
		83	+ result.value = WebServiceProxy.mergerData(result.value, oldArray, companyId);
		84	+ }*/
		85	+ } catch (Exception e) {
		86	+ logger.error("", e);
		87	+ fError.value = "服务器出现异常！";
		88	+ return false;
		89	+ }
		90	+ return true;
		91	+ }
		92	+
		93	+ @Override
		94	+ public boolean waybill_NH4TH(String password, String rq, String companyId, Holder<NH_waybill[]> result, Holder<String> fError) {
		95	+ try {
		96	+ if(userService.get(password) == null){
		97	+ fError.value = "无效的密码！";
		98	+ return false;
		99	+ }
		100	+ //日期减一天，老接口是这样的
		101	+ //rq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
		102	+ String prveRq = fmtyyyyMMdd.print(fmtyyyyMMdd.parseDateTime(rq).minusDays(1));
		103	+
		104	+ //实际排班
		105	+ ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByNbbm(prveRq, companyId);
		106	+ //油耗信息
		107	+ ArrayListMultimap<String, OilInfo> oilInfoMap = oilRedisService.findByNbbmGroup(listMap.keySet(), prveRq);
		108	+ //电耗信息
		109	+ ArrayListMultimap<String, ElecInfo> elecInfoMap = elecRedisService.findByNbbmGroup(listMap.keySet(), prveRq);
		110	+ //当班调派
		111	+ long st = fmtyyyyMMddHHmm.parseMillis(prveRq + "00:00"), et = fmtyyyyMMddHHmm.parseMillis(prveRq + "23:59");
		112	+ List<DutyEmployee> des = dutyEmployeeRepository.findByTime(st, et);
		113	+ //转换成南汇路单需要的格式
		114	+ NH_waybill[] array = WSDataConver.to_waybill_NH4TH(listMap, oilInfoMap, elecInfoMap, des);
		115	+ result.value = array;
		116	+
		117	+ //不再代理老接口数据
		118	+ /*if(companyId.equals("26") && !WebServiceProxy.isAllNew(companyId)){
		119	+ ClsLDInfo[] oldArray = OldWSClient.getNH_LD(companyId, rq);
		120	+ //合并新老系统的数据
		121	+ result.value = WebServiceProxy.mergerData(result.value, oldArray, companyId);
		122	+ }*/
		123	+ } catch (Exception e) {
		124	+ logger.error("", e);
		125	+ fError.value = "服务器出现异常！";
		126	+ return false;
		127	+ }
		128	+ return true;
		129	+ }
		130	+
		131	+ @Override
		132	+ public boolean waybill_SN(String password, String rq, String companyId, Holder<SN_waybill[]> result, Holder<String> fError) {
		133	+ try {
		134	+ if(userService.get(password) == null){
		135	+ fError.value = "无效的密码！";
		136	+ return false;
		137	+ }
		138	+
		139	+ //实际排班
		140	+ ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByNbbm(rq, companyId);
		141	+ //油耗信息
		142	+ Map<String, OilInfo> oilInfoMap = oilRedisService.findByNbbmGroupRaw(listMap.keySet(), rq);
		143	+ //转换成上南路单需要的格式
		144	+ SN_waybill[] array = WSDataConver.to_waybill_SN(listMap, oilInfoMap);
		145	+ result.value = array;
		146	+ } catch (Exception e) {
		147	+ logger.error("", e);
		148	+ fError.value = "服务器出现异常！";
		149	+ return false;
		150	+ }
		151	+ return true;
		152	+ }
		153	+
		154	+ @Override
		155	+ public boolean lossMileage(String password, String rq, String companyId, Holder<SN_lossMileage[]> result, Holder<String> fError) {
		156	+ try {
		157	+ if(userService.get(password) == null){
		158	+ fError.value = "无效的密码！";
		159	+ return false;
		160	+ }
		161	+
		162	+ //按线路分组的实际排班
		163	+ ArrayListMultimap<String, ScheduleRealInfo> listMap = scheduleRedisService.findByDateAndGroupByLine(rq, companyId);
		164	+ //转换成上南需要的损失公里数据
		165	+ SN_lossMileage[] array = WSDataConver.to_lossMileage_SN(listMap);
		166	+ result.value = array;
		167	+ } catch (Exception e) {
		168	+ logger.error("", e);
		169	+ fError.value = "服务器出现异常！";
		170	+ return false;
		171	+ }
		172	+ return false;
		173	+ }
		174	+
		175	+
		176	+ @Override
		177	+ public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		178	+ oilRedisService = applicationContext.getBean(OilRedisService.class);
		179	+ elecRedisService = applicationContext.getBean(ElecRedisService.class);
		180	+ scheduleRedisService = applicationContext.getBean(ScheduleRedisService.class);
		181	+ dutyEmployeeRepository = applicationContext.getBean(DutyEmployeeRepository.class);
		182	+ userService = applicationContext.getBean(UserService.class);
		183	+ }
		184	+}

潘钊 / control_service_data_Interface · Commits

GitLab

1.加入油电信息的合计