traininfoservice/banedk/TimetableFetcher.java

package dk.thoerup.traininfoservice.banedk;


import java.io.IOException;
import java.net.URL;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.gargoylesoftware.htmlunit.BrowserVersion;
import com.gargoylesoftware.htmlunit.Page;
import com.gargoylesoftware.htmlunit.RefreshHandler;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.DomNodeList;
import com.gargoylesoftware.htmlunit.html.HtmlElement;
import com.gargoylesoftware.htmlunit.html.HtmlPage;

import dk.thoerup.circuitbreaker.CircuitBreaker;
import dk.thoerup.circuitbreaker.CircuitBreakerManager;
import dk.thoerup.traininfoservice.StationDAO;
import dk.thoerup.traininfoservice.Statistics;

public class TimetableFetcher {
        
        class NullRefreshHandler implements RefreshHandler {
                public void handleRefresh(Page arg0, URL arg1, int arg2) throws IOException {                   
                }
                
        }
                
        Map<String, List<TimetableBean>> cache; 
        Map<String, Integer> stationCache;

        StationDAO stationDao = new StationDAO();
        
        
        Logger logger = Logger.getLogger(TimetableFetcher.class.getName());
        
        private boolean useTempSite;
        
        public TimetableFetcher(boolean tmpSite, int cacheTimeout) {
                useTempSite = tmpSite;
                
                cache = new TimeoutMap<String,List<TimetableBean>>(cacheTimeout);
                stationCache = new TimeoutMap<String,Integer>( 3*60*60*1000 );
        }
        
        
        List<TimetableBean> cachedLookupTimetable(String trainID, String type) throws Exception {
                String key = trainID+type;
                List<TimetableBean> list = cache.get(key);
                
                if (list == null) {
                        list = lookupTimetable(trainID,type);
                        cache.put(key, list);
                } else {
                        Statistics.getInstance().incrementTimetableCacheHits();
                        logger.info("Timetable: Cache hit " + trainID); 
                }
                return list;
        }
        
        List<TimetableBean> lookupTimetable(String trainID, String type) throws Exception {
                if (useTempSite == false ){
                        return lookupTimetableRealSite(trainID, type);
                } else {
                        return new ArrayList<TimetableBean>(); // no timetable data on temp site
                }
        }
        
        int getStationId(String name) {
                Integer id = stationCache.get(name);
                
                if (id == null) {
                        try {
                                id = stationDao.getIdByName(name);
                                stationCache.put(name, id);
                        } catch (SQLException e) {
                                logger.log(Level.SEVERE, "getStationId failed", e);
                                id = -1;
                        }
                } 

                return id;
        }

        List<TimetableBean> lookupTimetableRealSite(String trainID, String type) throws Exception {             
                List<TimetableBean> timetableList = new ArrayList<TimetableBean>();
                
                //String url = "http://www.bane.dk/visRute.asp?W=" + type + "&TogNr=" + trainID + "&artikelId=4276";
                String url = "http://trafikinfo.bane.dk/TrafikInformation/Ruteplan/" + trainID;                 

            final WebClient webClient = new WebClient(BrowserVersion.FIREFOX_3);
            webClient.setTimeout(2500);
            webClient.setJavaScriptEnabled(false);         
            webClient.setRefreshHandler( new NullRefreshHandler() );
            webClient.setCssEnabled(false);
            
            
            HtmlunitInvocation wrapper = new HtmlunitInvocation(webClient, url);
            CircuitBreaker breaker = CircuitBreakerManager.getManager().getCircuitBreaker("banedk");
            
            HtmlPage page = (HtmlPage) breaker.invoke(wrapper);
                    
            
            boolean currentStation = false;
            boolean currentStationSaved = false;
            
            List<HtmlElement> tables = page.getDocumentElement().getElementsByAttribute("table", "class", "Rute");
            if (tables.size() == 1) {
                HtmlElement timetable = tables.get(0);
                DomNodeList<HtmlElement> rows = timetable.getElementsByTagName("tr");
                
                for (int i=0; i<rows.size(); i++) {
                        if (i==0) //First row is column headers
                                continue;
                        
                        
                        HtmlElement row = rows.get(i);
                        DomNodeList<HtmlElement> fields = row.getElementsByTagName("td");
                        
                        if (currentStationSaved == false && fields.get(0).getAttribute("class").equalsIgnoreCase("Tidsstreg")) {
                                currentStation = true;
                                continue;
                        }
                        
                        TimetableBean bean = new TimetableBean();
                        
                        String station = fields.get(0).asText() ;
                        if (station.equals("København"))
                                station = "København H"; //correct inconsistency in naming
                        
                        bean.setStation( station );
                        bean.setArrival( fields.get(1).asText() );
                        bean.setDeparture( fields.get(2).asText() );
                        
                        boolean cancelled = fields.get(3).asText().equalsIgnoreCase("aflyst");
                        bean.setCancelled(cancelled);
                        
                        if (currentStation == true && currentStationSaved == false ) {
                                bean.setCurrent(currentStation);
                                currentStationSaved = true;
                        }
                        
                        bean.setStationId( getStationId( station ));
                        
                        timetableList.add(bean);
                }
                
                final String cancelledString = "Aflyst";
                for (int i=0;i<timetableList.size(); i++) { //handle cancelled labels
                        final int lastIdx = (timetableList.size() - 1);
                        
                        TimetableBean current = timetableList.get(i);
                        if (current.isCancelled()) {
                                if (i == 0) {
                                        current.setDeparture(cancelledString);
                                } else if (i == lastIdx) {
                                        current.setArrival(cancelledString);
                                } else if (i>0 && i<lastIdx) {
                                        TimetableBean next = timetableList.get(i+1);
                                        TimetableBean prev = timetableList.get(i-1);
                                        
                                        if (next.isCancelled())
                                                current.setDeparture(cancelledString);
                                        if (prev.isCancelled())
                                                current.setArrival(cancelledString);
                                }
                        }
                }
                
            } else {
                logger.warning("No time table found, trainID=" + trainID + " type=" + type);
            }
            webClient.closeAllWindows();
                
                return timetableList;
        }
        
}
1	package dk.thoerup.traininfoservice.banedk;
2
3
4	import java.io.IOException;
5	import java.net.URL;
6	import java.sql.SQLException;
7	import java.util.ArrayList;
8	import java.util.List;
9	import java.util.Map;
10	import java.util.logging.Level;
11	import java.util.logging.Logger;
12
13	import com.gargoylesoftware.htmlunit.BrowserVersion;
14	import com.gargoylesoftware.htmlunit.Page;
15	import com.gargoylesoftware.htmlunit.RefreshHandler;
16	import com.gargoylesoftware.htmlunit.WebClient;
17	import com.gargoylesoftware.htmlunit.html.DomNodeList;
18	import com.gargoylesoftware.htmlunit.html.HtmlElement;
19	import com.gargoylesoftware.htmlunit.html.HtmlPage;
20
21	import dk.thoerup.circuitbreaker.CircuitBreaker;
22	import dk.thoerup.circuitbreaker.CircuitBreakerManager;
23	import dk.thoerup.traininfoservice.StationDAO;
24	import dk.thoerup.traininfoservice.Statistics;
25
26	public class TimetableFetcher {
27
28	class NullRefreshHandler implements RefreshHandler {
29	public void handleRefresh(Page arg0, URL arg1, int arg2) throws IOException {
30	}
31
32	}
33
34	Map<String, List<TimetableBean>> cache;
35	Map<String, Integer> stationCache;
36
37	StationDAO stationDao = new StationDAO();
38
39
40	Logger logger = Logger.getLogger(TimetableFetcher.class.getName());
41
42	private boolean useTempSite;
43
44	public TimetableFetcher(boolean tmpSite, int cacheTimeout) {
45	useTempSite = tmpSite;
46
47	cache = new TimeoutMap<String,List<TimetableBean>>(cacheTimeout);
48	stationCache = new TimeoutMap<String,Integer>( 36060*1000 );
49	}
50
51
52	List<TimetableBean> cachedLookupTimetable(String trainID, String type) throws Exception {
53	String key = trainID+type;
54	List<TimetableBean> list = cache.get(key);
55
56	if (list == null) {
57	list = lookupTimetable(trainID,type);
58	cache.put(key, list);
59	} else {
60	Statistics.getInstance().incrementTimetableCacheHits();
61	logger.info("Timetable: Cache hit " + trainID);
62	}
63	return list;
64	}
65
66	List<TimetableBean> lookupTimetable(String trainID, String type) throws Exception {
67	if (useTempSite == false ){
68	return lookupTimetableRealSite(trainID, type);
69	} else {
70	return new ArrayList<TimetableBean>(); // no timetable data on temp site
71	}
72	}
73
74	int getStationId(String name) {
75	Integer id = stationCache.get(name);
76
77	if (id == null) {
78	try {
79	id = stationDao.getIdByName(name);
80	stationCache.put(name, id);
81	} catch (SQLException e) {
82	logger.log(Level.SEVERE, "getStationId failed", e);
83	id = -1;
84	}
85	}
86
87	return id;
88	}
89
90	List<TimetableBean> lookupTimetableRealSite(String trainID, String type) throws Exception {
91	List<TimetableBean> timetableList = new ArrayList<TimetableBean>();
92
93	//String url = "http://www.bane.dk/visRute.asp?W=" + type + "&TogNr=" + trainID + "&artikelId=4276";
94	String url = "http://trafikinfo.bane.dk/TrafikInformation/Ruteplan/" + trainID;
95
96	final WebClient webClient = new WebClient(BrowserVersion.FIREFOX_3);
97	webClient.setTimeout(2500);
98	webClient.setJavaScriptEnabled(false);
99	webClient.setRefreshHandler( new NullRefreshHandler() );
100	webClient.setCssEnabled(false);
101
102
103	HtmlunitInvocation wrapper = new HtmlunitInvocation(webClient, url);
104	CircuitBreaker breaker = CircuitBreakerManager.getManager().getCircuitBreaker("banedk");
105
106	HtmlPage page = (HtmlPage) breaker.invoke(wrapper);
107
108
109	boolean currentStation = false;
110	boolean currentStationSaved = false;
111
112	List<HtmlElement> tables = page.getDocumentElement().getElementsByAttribute("table", "class", "Rute");
113	if (tables.size() == 1) {
114	HtmlElement timetable = tables.get(0);
115	DomNodeList<HtmlElement> rows = timetable.getElementsByTagName("tr");
116
117	for (int i=0; i<rows.size(); i++) {
118	if (i==0) //First row is column headers
119	continue;
120
121
122	HtmlElement row = rows.get(i);
123	DomNodeList<HtmlElement> fields = row.getElementsByTagName("td");
124
125	if (currentStationSaved == false && fields.get(0).getAttribute("class").equalsIgnoreCase("Tidsstreg")) {
126	currentStation = true;
127	continue;
128	}
129
130	TimetableBean bean = new TimetableBean();
131
132	String station = fields.get(0).asText() ;
133	if (station.equals("København"))
134	station = "København H"; //correct inconsistency in naming
135
136	bean.setStation( station );
137	bean.setArrival( fields.get(1).asText() );
138	bean.setDeparture( fields.get(2).asText() );
139
140	boolean cancelled = fields.get(3).asText().equalsIgnoreCase("aflyst");
141	bean.setCancelled(cancelled);
142
143	if (currentStation == true && currentStationSaved == false ) {
144	bean.setCurrent(currentStation);
145	currentStationSaved = true;
146	}
147
148	bean.setStationId( getStationId( station ));
149
150	timetableList.add(bean);
151	}
152
153	final String cancelledString = "Aflyst";
154	for (int i=0;i<timetableList.size(); i++) { //handle cancelled labels
155	final int lastIdx = (timetableList.size() - 1);
156
157	TimetableBean current = timetableList.get(i);
158	if (current.isCancelled()) {
159	if (i == 0) {
160	current.setDeparture(cancelledString);
161	} else if (i == lastIdx) {
162	current.setArrival(cancelledString);
163	} else if (i>0 && i<lastIdx) {
164	TimetableBean next = timetableList.get(i+1);
165	TimetableBean prev = timetableList.get(i-1);
166
167	if (next.isCancelled())
168	current.setDeparture(cancelledString);
169	if (prev.isCancelled())
170	current.setArrival(cancelledString);
171	}
172	}
173	}
174
175	} else {
176	logger.warning("No time table found, trainID=" + trainID + " type=" + type);
177	}
178	webClient.closeAllWindows();
179
180	return timetableList;
181	}
182
183	}