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.加入油电信息的合计