thoerup/traininfoservice/StationDAO.java

package dk.thoerup.traininfoservice;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.jdo.Extent;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;

import net.sf.jsr107cache.Cache;
import net.sf.jsr107cache.CacheException;
import net.sf.jsr107cache.CacheManager;

import com.google.appengine.api.memcache.jsr107cache.GCacheFactory;

import dk.thoerup.android.traininfo.common.StationBean;
import dk.thoerup.android.traininfo.common.StationBean.StationEntry;
import dk.thoerup.traininfoservice.geo.Geo;
import dk.thoerup.traininfoservice.jdo.JdoStationBean;
import dk.thoerup.traininfoservice.jdo.PMF;

public class StationDAO {
        final static int LOCATION_LIMIT = 8;
        static final Logger logger = Logger.getLogger(StationDAO.class.getName());
        
        final int TIMEOUT_SECONDS = 30*60;
        
        Cache cache;
        
        public StationDAO() {
        Map props = new HashMap();
        props.put(GCacheFactory.EXPIRATION_DELTA, TIMEOUT_SECONDS);        
                
                try {
            cache = CacheManager.getInstance().getCacheFactory().createCache(props);            
        } catch (CacheException e) {
                logger.log(Level.WARNING, "error creating cache", e);
        }
        
        }


        public StationEntry getById(int id)  {

                PersistenceManager pm = null;
                
                try {
                        pm = PMF.get().getPersistenceManager();
                        JdoStationBean bean =pm.getObjectById(JdoStationBean.class, new Integer(id) );
                        return bean.toStationEntry();
                } finally {
                        pm.close();
                }
        }

        /* damn that JDO sucks so we to the filtering in java-code */
        public StationBean getByName(String searchname) {
                PersistenceManager pm = null;
                
                try {
                        /*pm = PMF.get().getPersistenceManager();
                        
                        
                        Query q = pm.newQuery(JdoStationBean.class);
                        q.setOrdering("name");                  
                        List<JdoStationBean> beanList = (List<JdoStationBean>) q.execute();*/
                        
                        List<JdoStationBean> beanList = getAllStations();
                        
                        
                        StationBean stationBean = new StationBean();
                        
                        searchname = searchname.toLowerCase();
                        for(JdoStationBean bean : beanList) { 
                                if (bean.getName().toLowerCase().startsWith(searchname)) {
                                        stationBean.entries.add( bean.toStationEntry() );
                                } else {
                                        for (String alias : bean.aliases ) {
                                                if (alias.toLowerCase().startsWith(searchname)) {
                                                        stationBean.entries.add( bean.toStationEntry() );
                                                }
                                        }
                                }
                        }

                        return stationBean;                     
                } finally {
                //      pm.close();
                }
        }
        
        public List<JdoStationBean> getAllStations() {
                final String key = "allstations"; 
                List<JdoStationBean> result = (List<JdoStationBean>) cache.get(key);
                
                if (result == null) {
                        logger.info("getAllStations Cache miss");
                        
                        PersistenceManager pm = null;
                        final double LAT = 0.4;
                        final double LNG = 0.75;
                        
                        try {
                                pm = PMF.get().getPersistenceManager();
                                Extent<JdoStationBean> all = pm.getExtent(JdoStationBean.class, false);
                                
                                result = new ArrayList<JdoStationBean>();
                                for (JdoStationBean station : all) {
                                        result.add(station);
                                }
                                
                                cache.put(key, result);
                                
                        } finally {
                                pm.close();
                        }
                } else {
                        logger.info("getAllStations Cache hit");
                }
                
                
                return result;
                
        }
        

        //String limitExpression = (geolimit == true) ? "AND abs(latitude-?)<0.4 AND abs(longitude-?)<0.75 " : "";
        /*
        public List<JdoStationBean> getByLocationList(double latitude, double longitude, boolean geolimit)  {
        
                PersistenceManager pm = null;
                final double LAT = 0.4;
                final double LNG = 0.75;
                
                try {
                        pm = PMF.get().getPersistenceManager();
                        Query q = pm.newQuery(JdoStationBean.class);
                        
                        
                        if (geolimit == true) {
                                double minLat = latitude - LAT;
                                double maxLat = latitude + LAT;
                                
                                //DAMN JDO implementation only allows us to compare on one parameter

                                String filter = String.format("latitude > %f && latitude < %f", minLat, maxLat);
                                
                                q.setFilter( filter );
                        }
                        
                        List<JdoStationBean> beanList = (List<JdoStationBean>) q.execute();                     
                        
                        logger.info("beanList size " + beanList.size());
                        
                        return beanList;
                } finally {
                        pm.close();
                }
        }*/


        public StationBean getByLocation(double latitude, double longitude)  {
                /*
                List<JdoStationBean> beanList = getByLocationList(latitude,longitude,true);
                
                if (beanList.size() < LOCATION_LIMIT ) {
                        logger.info("getByLocation failover: " +latitude + "," + longitude);
                        beanList = getByLocationList(latitude,longitude, false);
                }*/
                
                List<JdoStationBean> beanList = getAllStations();

                StationBean stationBean = new StationBean();                    


                Geo location = new Geo(latitude,longitude);
                for(JdoStationBean bean : beanList) {
                        double meter = Geo.distanceKM( location, new Geo(bean.getLatitude(), bean.getLongitude() )) * 1000.0;

                        bean.distance = (int) meter;
                }


                Collections.sort(beanList, new Comparator<JdoStationBean>() {
                        @Override
                        public int compare(JdoStationBean o1, JdoStationBean o2) {
                                if (o1.distance < o2.distance) {
                                        return -1;
                                } else if (o1.distance > o2.distance) {
                                        return 1;
                                } else {
                                        return 0;
                                }
                        }
                });

                for (int i=0; i<LOCATION_LIMIT && i<beanList.size(); i++) {
                        stationBean.entries.add( beanList.get(i).toStationEntry() );
                }

                return stationBean;                     
        }
        

        public StationBean getByList(String list)  {
                PersistenceManager pm = null;
                
                try {
                        String parts[] = list.split(",");
                        
                        StringBuilder filter = new StringBuilder();
                        
                        for(String part : parts)  {
                                if (filter.length() > 0) {
                                        filter.append( " || " );
                                }
                                filter.append("id == ").append(part);
                        }                       
                        
                        //String filter = "id == 10 || id == 82"; //TODO: build filter
                        
                        pm = PMF.get().getPersistenceManager();
                        Query q = pm.newQuery(JdoStationBean.class);
                        q.setFilter( filter.toString() );
                        q.setOrdering("name");
                        
                        List<JdoStationBean> beanList = (List<JdoStationBean>) q.execute();
                        
                        StationBean stationBean = new StationBean();
                        
                        for(JdoStationBean bean : beanList) {
                                stationBean.entries.add( bean.toStationEntry() );
                        }

                        return stationBean;                     
                } finally {
                        pm.close();
                }

        }


        public int getIdByName(String name)  {
                
                List<JdoStationBean> beanList = null;
                
                PersistenceManager pm = null;
                
                try {
                        
                        String filter = " name == '" + name + "'";
                        
                        pm = PMF.get().getPersistenceManager();
                        Query q = pm.newQuery(JdoStationBean.class);
                        q.setFilter(filter);
                        
                        beanList = (List<JdoStationBean>) q.execute();
                        
                        StationBean stationBean = new StationBean();
                        
                        for(JdoStationBean bean : beanList) {
                                stationBean.entries.add( bean.toStationEntry() );
                        }
                        
                } finally {
                        pm.close();
                }

                if ( beanList != null && beanList.size()  == 1) {
                        return (int) beanList.get(0).getId();
                } else {
                        return -1;
                }
        }
        
        @SuppressWarnings("unchecked")
        public int saveStations(StationBean stationBean) throws IOException {
                PersistenceManager pm = null;
                
                try {
                        pm = PMF.get().getPersistenceManager();
                        
                        List oldEntries = (List) pm.newQuery(JdoStationBean.class).execute();
                        pm.deletePersistentAll(oldEntries);
                        
                        List<JdoStationBean> jdoList = new ArrayList<JdoStationBean>();
                        for (StationEntry station : stationBean.entries) {
                                JdoStationBean jdoBean = JdoStationBean.fromStationEntry(station);
                                
                                jdoList.add(jdoBean);
                                
                        }
                        pm.makePersistentAll(jdoList);
                        
                        return jdoList.size();
                        
                } finally {
                        pm.close();
                }
        }
        
}
1	package dk.thoerup.traininfoservice;
2
3	import java.io.IOException;
4	import java.util.ArrayList;
5	import java.util.Collections;
6	import java.util.Comparator;
7	import java.util.HashMap;
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 javax.jdo.Extent;
14	import javax.jdo.PersistenceManager;
15	import javax.jdo.Query;
16
17	import net.sf.jsr107cache.Cache;
18	import net.sf.jsr107cache.CacheException;
19	import net.sf.jsr107cache.CacheManager;
20
21	import com.google.appengine.api.memcache.jsr107cache.GCacheFactory;
22
23	import dk.thoerup.android.traininfo.common.StationBean;
24	import dk.thoerup.android.traininfo.common.StationBean.StationEntry;
25	import dk.thoerup.traininfoservice.geo.Geo;
26	import dk.thoerup.traininfoservice.jdo.JdoStationBean;
27	import dk.thoerup.traininfoservice.jdo.PMF;
28
29	public class StationDAO {
30	final static int LOCATION_LIMIT = 8;
31	static final Logger logger = Logger.getLogger(StationDAO.class.getName());
32
33	final int TIMEOUT_SECONDS = 30*60;
34
35	Cache cache;
36
37	public StationDAO() {
38	Map props = new HashMap();
39	props.put(GCacheFactory.EXPIRATION_DELTA, TIMEOUT_SECONDS);
40
41	try {
42	cache = CacheManager.getInstance().getCacheFactory().createCache(props);
43	} catch (CacheException e) {
44	logger.log(Level.WARNING, "error creating cache", e);
45	}
46
47	}
48
49
50	public StationEntry getById(int id) {
51
52	PersistenceManager pm = null;
53
54	try {
55	pm = PMF.get().getPersistenceManager();
56	JdoStationBean bean =pm.getObjectById(JdoStationBean.class, new Integer(id) );
57	return bean.toStationEntry();
58	} finally {
59	pm.close();
60	}
61	}
62
63	/* damn that JDO sucks so we to the filtering in java-code */
64	public StationBean getByName(String searchname) {
65	PersistenceManager pm = null;
66
67	try {
68	/*pm = PMF.get().getPersistenceManager();
69
70
71
72	Query q = pm.newQuery(JdoStationBean.class);
73	q.setOrdering("name");
74	List<JdoStationBean> beanList = (List<JdoStationBean>) q.execute();*/
75
76	List<JdoStationBean> beanList = getAllStations();
77
78
79	StationBean stationBean = new StationBean();
80
81	searchname = searchname.toLowerCase();
82	for(JdoStationBean bean : beanList) {
83	if (bean.getName().toLowerCase().startsWith(searchname)) {
84	stationBean.entries.add( bean.toStationEntry() );
85	} else {
86	for (String alias : bean.aliases ) {
87	if (alias.toLowerCase().startsWith(searchname)) {
88	stationBean.entries.add( bean.toStationEntry() );
89	}
90	}
91	}
92	}
93
94	return stationBean;
95	} finally {
96	// pm.close();
97	}
98	}
99
100	public List<JdoStationBean> getAllStations() {
101	final String key = "allstations";
102	List<JdoStationBean> result = (List<JdoStationBean>) cache.get(key);
103
104	if (result == null) {
105	logger.info("getAllStations Cache miss");
106
107	PersistenceManager pm = null;
108	final double LAT = 0.4;
109	final double LNG = 0.75;
110
111	try {
112	pm = PMF.get().getPersistenceManager();
113	Extent<JdoStationBean> all = pm.getExtent(JdoStationBean.class, false);
114
115	result = new ArrayList<JdoStationBean>();
116	for (JdoStationBean station : all) {
117	result.add(station);
118	}
119
120	cache.put(key, result);
121
122	} finally {
123	pm.close();
124	}
125	} else {
126	logger.info("getAllStations Cache hit");
127	}
128
129
130
131	return result;
132
133	}
134
135
136	//String limitExpression = (geolimit == true) ? "AND abs(latitude-?)<0.4 AND abs(longitude-?)<0.75 " : "";
137	/*
138	public List<JdoStationBean> getByLocationList(double latitude, double longitude, boolean geolimit) {
139
140	PersistenceManager pm = null;
141	final double LAT = 0.4;
142	final double LNG = 0.75;
143
144	try {
145	pm = PMF.get().getPersistenceManager();
146	Query q = pm.newQuery(JdoStationBean.class);
147
148
149
150	if (geolimit == true) {
151	double minLat = latitude - LAT;
152	double maxLat = latitude + LAT;
153
154	//DAMN JDO implementation only allows us to compare on one parameter
155
156	String filter = String.format("latitude > %f && latitude < %f", minLat, maxLat);
157
158	q.setFilter( filter );
159	}
160
161	List<JdoStationBean> beanList = (List<JdoStationBean>) q.execute();
162
163	logger.info("beanList size " + beanList.size());
164
165	return beanList;
166	} finally {
167	pm.close();
168	}
169	}*/
170
171
172	public StationBean getByLocation(double latitude, double longitude) {
173	/*
174	List<JdoStationBean> beanList = getByLocationList(latitude,longitude,true);
175
176	if (beanList.size() < LOCATION_LIMIT ) {
177	logger.info("getByLocation failover: " +latitude + "," + longitude);
178	beanList = getByLocationList(latitude,longitude, false);
179	}*/
180
181	List<JdoStationBean> beanList = getAllStations();
182
183	StationBean stationBean = new StationBean();
184
185
186	Geo location = new Geo(latitude,longitude);
187	for(JdoStationBean bean : beanList) {
188	double meter = Geo.distanceKM( location, new Geo(bean.getLatitude(), bean.getLongitude() )) * 1000.0;
189
190	bean.distance = (int) meter;
191	}
192
193
194	Collections.sort(beanList, new Comparator<JdoStationBean>() {
195	@Override
196	public int compare(JdoStationBean o1, JdoStationBean o2) {
197	if (o1.distance < o2.distance) {
198	return -1;
199	} else if (o1.distance > o2.distance) {
200	return 1;
201	} else {
202	return 0;
203	}
204	}
205	});
206
207	for (int i=0; i<LOCATION_LIMIT && i<beanList.size(); i++) {
208	stationBean.entries.add( beanList.get(i).toStationEntry() );
209	}
210
211	return stationBean;
212	}
213
214
215	public StationBean getByList(String list) {
216	PersistenceManager pm = null;
217
218	try {
219	String parts[] = list.split(",");
220
221	StringBuilder filter = new StringBuilder();
222
223	for(String part : parts) {
224	if (filter.length() > 0) {
225	filter.append( " \|\| " );
226	}
227	filter.append("id == ").append(part);
228	}
229
230	//String filter = "id == 10 \|\| id == 82"; //TODO: build filter
231
232	pm = PMF.get().getPersistenceManager();
233	Query q = pm.newQuery(JdoStationBean.class);
234	q.setFilter( filter.toString() );
235	q.setOrdering("name");
236
237	List<JdoStationBean> beanList = (List<JdoStationBean>) q.execute();
238
239	StationBean stationBean = new StationBean();
240
241	for(JdoStationBean bean : beanList) {
242	stationBean.entries.add( bean.toStationEntry() );
243	}
244
245	return stationBean;
246	} finally {
247	pm.close();
248	}
249
250	}
251
252
253	public int getIdByName(String name) {
254
255	List<JdoStationBean> beanList = null;
256
257	PersistenceManager pm = null;
258
259	try {
260
261	String filter = " name == '" + name + "'";
262
263	pm = PMF.get().getPersistenceManager();
264	Query q = pm.newQuery(JdoStationBean.class);
265	q.setFilter(filter);
266
267	beanList = (List<JdoStationBean>) q.execute();
268
269	StationBean stationBean = new StationBean();
270
271	for(JdoStationBean bean : beanList) {
272	stationBean.entries.add( bean.toStationEntry() );
273	}
274
275	} finally {
276	pm.close();
277	}
278
279	if ( beanList != null && beanList.size() == 1) {
280	return (int) beanList.get(0).getId();
281	} else {
282	return -1;
283	}
284	}
285
286	@SuppressWarnings("unchecked")
287	public int saveStations(StationBean stationBean) throws IOException {
288	PersistenceManager pm = null;
289
290	try {
291	pm = PMF.get().getPersistenceManager();
292
293	List oldEntries = (List) pm.newQuery(JdoStationBean.class).execute();
294	pm.deletePersistentAll(oldEntries);
295
296	List<JdoStationBean> jdoList = new ArrayList<JdoStationBean>();
297	for (StationEntry station : stationBean.entries) {
298	JdoStationBean jdoBean = JdoStationBean.fromStationEntry(station);
299
300	jdoList.add(jdoBean);
301
302	}
303	pm.makePersistentAll(jdoList);
304
305	return jdoList.size();
306
307	} finally {
308	pm.close();
309	}
310	}
311
312	}