849 lines
24 KiB
Java
849 lines
24 KiB
Java
package org.gcube.data.spd.flora;
|
||
|
||
import java.io.BufferedReader;
|
||
import java.io.IOException;
|
||
import java.io.InputStream;
|
||
import java.io.InputStreamReader;
|
||
import java.net.ConnectException;
|
||
import java.net.HttpURLConnection;
|
||
import java.net.MalformedURLException;
|
||
import java.net.URI;
|
||
import java.net.URL;
|
||
import java.sql.Connection;
|
||
import java.sql.ResultSet;
|
||
import java.sql.SQLException;
|
||
import java.sql.Statement;
|
||
import java.text.DateFormat;
|
||
import java.text.SimpleDateFormat;
|
||
import java.util.ArrayList;
|
||
import java.util.Calendar;
|
||
import java.util.Date;
|
||
import java.util.GregorianCalendar;
|
||
import java.util.HashMap;
|
||
import java.util.Map;
|
||
|
||
import javax.xml.stream.XMLEventReader;
|
||
import javax.xml.stream.XMLInputFactory;
|
||
import javax.xml.stream.XMLStreamConstants;
|
||
import javax.xml.stream.XMLStreamException;
|
||
import javax.xml.stream.events.XMLEvent;
|
||
|
||
import org.gcube.data.spd.flora.dbconnection.ConnectionPool;
|
||
import org.gcube.data.spd.flora.dbconnection.ConnectionPoolException;
|
||
import org.slf4j.Logger;
|
||
import org.slf4j.LoggerFactory;
|
||
import org.w3c.dom.Element;
|
||
import org.w3c.dom.Node;
|
||
import org.w3c.dom.NodeList;
|
||
|
||
public class Utils {
|
||
|
||
//DERBY CONNECTION
|
||
// public static String dbURL = "jdbc:derby:classpath:FloraDB;create=true";
|
||
//public static String dbURL = "jdbc:derby:FloraDB;create=true";
|
||
|
||
static Logger logger = LoggerFactory.getLogger(Utils.class);
|
||
|
||
/**
|
||
* Return true if a url exists
|
||
*/
|
||
public static boolean urlExists(String pathUrl) {
|
||
HttpURLConnection con = null;
|
||
try {
|
||
HttpURLConnection.setFollowRedirects(false);
|
||
con = (HttpURLConnection) new URL(pathUrl).openConnection();
|
||
// Set timeouts in milliseconds
|
||
con.setConnectTimeout(30000);
|
||
con.setReadTimeout(30000);
|
||
|
||
con.setRequestMethod("HEAD");
|
||
return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
|
||
}
|
||
catch (Exception e) {
|
||
logger.error("Exception",e);
|
||
return false;
|
||
}finally{
|
||
if( con != null ){
|
||
con.disconnect();
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Metod called by CreateDBThread
|
||
*/
|
||
public static boolean createDB() throws SQLException, IOException {
|
||
BufferedReader br = null;
|
||
ConnectionPool pool = null;
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
|
||
logger.trace("Create tables...");
|
||
boolean updateQuery;
|
||
br = new BufferedReader(new InputStreamReader(FloraPlugin.class.getResourceAsStream(FloraPlugin.dumpDb)));
|
||
if (br!=null){
|
||
String line;
|
||
while ((line = br.readLine()) != null) {
|
||
updateQuery = pool.insertPreStatement(line);
|
||
if (!updateQuery)
|
||
logger.trace(line);
|
||
}
|
||
}
|
||
} catch (ConnectionPoolException e) {
|
||
// logger.error("ConnectionPoolException", e);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
|
||
}
|
||
|
||
//format date
|
||
public static String createDate() {
|
||
Calendar now = Calendar.getInstance();
|
||
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
||
String date = format.format(now.getTime());
|
||
return date;
|
||
}
|
||
|
||
public static String createCitation() {
|
||
StringBuilder cit = new StringBuilder();
|
||
cit.append(FloraPlugin.citation);
|
||
cit.append(createDate());
|
||
return cit.toString();
|
||
}
|
||
|
||
public static String createCredits() {
|
||
String cred = FloraPlugin.credits;
|
||
cred = cred.replace("XDATEX",createDate());
|
||
return cred;
|
||
}
|
||
/**
|
||
* getTagValue
|
||
*/
|
||
public static String getTagValue(String sTag, Element eElement) {
|
||
|
||
// NodeList nlList = eElement.getElementsByTagName(sTag).item(0).getChildNodes();
|
||
|
||
String a = "";
|
||
NodeList nlList = eElement.getElementsByTagName(sTag);
|
||
if (nlList!= null){
|
||
Element xmlNode = (Element)nlList.item(0);
|
||
if (xmlNode != null){
|
||
NodeList textFNList = xmlNode.getChildNodes();
|
||
if (textFNList != null){
|
||
Node nValue = (Node) textFNList.item(0);
|
||
if (nValue != null){
|
||
a = nValue.getNodeValue();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// System.out.println(a);
|
||
return a;
|
||
}
|
||
|
||
|
||
/**
|
||
* Find info about a specific id
|
||
*/
|
||
|
||
public static Map<String, String> findTags(String id) throws SQLException, ConnectException {
|
||
String pathUrl = FloraPlugin.baseurl + "/FULLRECORD/VERSION/2012/FORMAT/xml/LANG/en/ID/" + id;
|
||
// logger.trace("Find info " + tag);
|
||
// logger.trace(pathUrl);
|
||
Map<String, String> values = new HashMap<String, String>();
|
||
if (urlExists(pathUrl)){
|
||
InputStream is = null;
|
||
XMLInputFactory ifactory;
|
||
XMLEventReader eventReader = null;
|
||
try{
|
||
// logger.trace("open 1");
|
||
is = URI.create(pathUrl).toURL().openStream();
|
||
ifactory = XMLInputFactory.newInstance();
|
||
eventReader = ifactory.createXMLEventReader(is, "utf-8");
|
||
|
||
while (eventReader.hasNext()){
|
||
XMLEvent event = eventReader.nextEvent();
|
||
|
||
if (checkStartElement(event, "plain_name")){
|
||
// logger.trace(readCharacters(eventReader));
|
||
values.put("plain_name", readCharacters(eventReader));
|
||
continue;
|
||
}else if (checkStartElement(event, "author")){
|
||
// logger.trace(readCharacters(eventReader));
|
||
values.put("author", readCharacters(eventReader));
|
||
continue;
|
||
}else if (checkStartElement(event, "rank")){
|
||
// logger.trace(readCharacters(eventReader));
|
||
values.put("rank", readCharacters(eventReader));
|
||
continue;
|
||
}else if (checkStartElement(event, "status")){
|
||
// logger.trace(readCharacters(eventReader));
|
||
values.put("status", readCharacters(eventReader));
|
||
continue;
|
||
}else if (checkStartElement(event, "qualifier")){
|
||
// logger.trace(readCharacters(eventReader));
|
||
values.put("qualifier", readCharacters(eventReader));
|
||
continue;
|
||
}else if (checkEndElement(event, "record")){
|
||
break;
|
||
}
|
||
}
|
||
|
||
} catch (Exception e) {
|
||
logger.trace("Error reading " + pathUrl );
|
||
// logger.error("ExceptionPrintStackTrace",e);
|
||
}
|
||
finally{
|
||
// logger.trace("close 1");
|
||
try {
|
||
if (eventReader != null)
|
||
eventReader.close();
|
||
if (is != null)
|
||
is.close();
|
||
} catch (XMLStreamException e) {
|
||
logger.error("XMLStreamException",e);
|
||
} catch (IOException e) {
|
||
logger.error("IOException",e);
|
||
}
|
||
}
|
||
|
||
}
|
||
return values;
|
||
}
|
||
|
||
|
||
protected static String readCharacters(XMLEventReader eventReader) throws Exception{
|
||
String characters="";
|
||
XMLEvent event = eventReader.nextEvent();
|
||
while (eventReader.hasNext() && event.isCharacters() ){
|
||
characters+= event.asCharacters().getData();
|
||
event = eventReader.nextEvent();
|
||
}
|
||
return characters.trim();
|
||
}
|
||
|
||
protected static boolean checkStartElement(XMLEvent event, String value){
|
||
return event.getEventType() == XMLStreamConstants.START_ELEMENT && event.asStartElement().getName().getLocalPart().equals(value);
|
||
}
|
||
|
||
protected static boolean checkEndElement(XMLEvent event, String value){
|
||
return event.getEventType() == XMLStreamConstants.END_ELEMENT && event.asEndElement().getName().getLocalPart().equals(value);
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* Parse every path and populate db
|
||
*/
|
||
public static ArrayList<ArrayList<String>> discoverPath(String pathUrl, String id_parent, String name_parent, Integer idThread, Boolean flag) throws SQLException, MalformedURLException, IOException {
|
||
|
||
ArrayList<ArrayList<String>> listUrls = new ArrayList<ArrayList<String>>();
|
||
if (Utils.urlExists(pathUrl)){
|
||
String id = "";
|
||
String path = "";
|
||
String rank = "";
|
||
String name = "";
|
||
// String status = "";
|
||
|
||
// logger.trace(pathUrl);
|
||
InputStream is = null;
|
||
XMLInputFactory ifactory;
|
||
XMLEventReader eventReader = null;
|
||
try {
|
||
// logger.trace("open 3");
|
||
is =URI.create(pathUrl).toURL().openStream();
|
||
ifactory = XMLInputFactory.newInstance();
|
||
eventReader = ifactory.createXMLEventReader(is, "utf-8");
|
||
while (eventReader.hasNext()){
|
||
XMLEvent event = eventReader.nextEvent();
|
||
|
||
if (Utils.checkStartElement(event, "id")){
|
||
id = readCharacters(eventReader);
|
||
continue;
|
||
} else if (Utils.checkStartElement(event, "path")){
|
||
path = readCharacters(eventReader);
|
||
continue;
|
||
} else if (Utils.checkStartElement(event, "rank")){
|
||
rank = readCharacters(eventReader);
|
||
continue;
|
||
} else if (Utils.checkStartElement(event, "name")){
|
||
name = readCharacters(eventReader);
|
||
continue;
|
||
} else if (Utils.checkEndElement(event, "record")){
|
||
// logger.trace(path);
|
||
createOrUpdate(id_parent, id, name, path, rank);
|
||
// child Threads check other urls
|
||
if (flag) {
|
||
discoverPath("http://checklist.florabrasil.net/service/TREE/VERSION/2012/FORMAT/xml/LANG/en/PATH/" + path, id, name, idThread, flag);
|
||
}
|
||
// // the main thread gets the urls
|
||
else {
|
||
ArrayList<String> elem = new ArrayList<String> ();
|
||
elem.add(path);
|
||
elem.add(id);
|
||
elem.add(name);
|
||
listUrls.add(elem);
|
||
}
|
||
continue;
|
||
} else if (Utils.checkEndElement(event, "result")){
|
||
// logger.trace("break");
|
||
break;
|
||
}
|
||
}
|
||
} catch (Exception e) {
|
||
logger.error("ExceptionPrintStackTrace",e);
|
||
}finally{
|
||
try {
|
||
// logger.trace("close 3");
|
||
if (eventReader != null)
|
||
eventReader.close();
|
||
if (is != null)
|
||
is.close();
|
||
} catch (XMLStreamException e) {
|
||
logger.error("XMLStreamException",e);
|
||
}
|
||
}
|
||
}
|
||
return listUrls;
|
||
}
|
||
|
||
|
||
|
||
protected static void createOrUpdate(String id_parent, String id, String name, String path, String rank) {
|
||
|
||
// logger.trace(path);
|
||
ResultSet res = null;
|
||
// Database database = null;
|
||
String stmt = "";
|
||
ArrayList<String> terms = new ArrayList<String>();
|
||
Map<String, String> values = null;
|
||
ConnectionPool pool = null;
|
||
Connection con = null;
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
res = pool.selectPrestatement("select count(*) from "+ FloraPlugin.tableName + " where id = ? ", id);
|
||
|
||
if(res.next()) {
|
||
values = findTags(id);
|
||
if (values.size()>0){
|
||
terms.add(id);
|
||
terms.add(rank);
|
||
terms.add(name);
|
||
terms.add(values.get("plain_name"));
|
||
terms.add(id_parent);
|
||
terms.add(values.get("author"));
|
||
terms.add(values.get("status"));
|
||
terms.add(path);
|
||
terms.add(values.get("qualifier"));
|
||
|
||
if (res.getInt(1) == 0) {
|
||
//Set values
|
||
stmt = ("insert into "+ FloraPlugin.tableName + " (id, rank, name, scientific_name, id_parent, citation, status, path, qualifier) values (?, ?, ?, ?, ?, ?, ?, ?, ?)");
|
||
}
|
||
else{
|
||
// logger.trace("update "+ FloraPlugin.tableName + " set id = ?, rank = ?, scientific_name = ?, id_parent = ?, citation = ?, status = ? where id = '" + id + "'");
|
||
stmt = ("update "+ FloraPlugin.tableName + " set id = ?, rank = ?, name = ?, scientific_name = ?, id_parent = ?, citation = ?, status = ?, path = ?, qualifier = ? where id = '" + id + "'");
|
||
}
|
||
|
||
if (!pool.preStatement(stmt, terms)){
|
||
logger.trace("error");
|
||
}
|
||
terms.clear();
|
||
values.clear();
|
||
}
|
||
}
|
||
}
|
||
catch (SQLException e) {
|
||
logger.error("SQL Exception",e);
|
||
} catch (ConnectException e) {
|
||
logger.error("Connection timed out",e);
|
||
} catch (ConnectionPoolException e) {
|
||
logger.error("ConnectionPoolException",e);
|
||
}finally{
|
||
try {
|
||
if (res != null) {
|
||
res.close();
|
||
}
|
||
if ((pool!=null) && (con!=null)){
|
||
pool.releaseConnection(con);
|
||
}
|
||
}catch (Exception e) {
|
||
logger.error("Exception",e);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Return true if a table exists
|
||
*/
|
||
public static boolean SQLTableExists(String tableName) {
|
||
boolean exists = false;
|
||
ConnectionPool pool = null;
|
||
Connection con = null;
|
||
ResultSet results = null;
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
if (pool!=null){
|
||
con = pool.getConnection();
|
||
if (con!=null){
|
||
Statement statement = con.createStatement();
|
||
|
||
String sqlText = "SELECT tables.table_name FROM information_schema.tables WHERE table_name = '" + tableName + "'";
|
||
|
||
results = statement.executeQuery(sqlText);
|
||
if (results.next()){
|
||
logger.trace(tableName + " already exists");
|
||
exists = true;
|
||
}
|
||
else{
|
||
logger.trace(tableName + " does not exists");
|
||
exists = false;
|
||
}
|
||
}
|
||
}
|
||
} catch (SQLException e) {
|
||
logger.error("SQLException", e);
|
||
} catch (ConnectionPoolException e) {
|
||
logger.error("ConnectionPoolException", e);
|
||
}finally {
|
||
if ((pool!=null) && (con!=null)){
|
||
pool.releaseConnection(con);
|
||
}
|
||
try {
|
||
if (results != null) {
|
||
results.close();
|
||
}
|
||
} catch (SQLException ex) {
|
||
logger.error("sql Error", ex);
|
||
}
|
||
}
|
||
|
||
return exists;
|
||
}
|
||
|
||
/**
|
||
* get next update date
|
||
*/
|
||
public static long lastupdate() {
|
||
|
||
ConnectionPool pool = null;
|
||
Connection con = null;
|
||
ResultSet results = null;
|
||
long nextUpdate = 0;
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
con = pool.getConnection();
|
||
if (con!=null){
|
||
Statement statement = con.createStatement();
|
||
|
||
String query = "select date from updates where id = (select max(id) from updates)";
|
||
logger.trace(query);
|
||
results = statement.executeQuery(query);
|
||
Date lastUpdate = null;
|
||
if (results.next()){
|
||
lastUpdate = results.getDate(1);
|
||
Date date = new Date();
|
||
long days = date.getTime() - lastUpdate.getTime();
|
||
if (days < 2592000000L){
|
||
return (2592000000L - days);
|
||
}
|
||
}
|
||
}
|
||
|
||
} catch (SQLException e) {
|
||
logger.error("SQLException", e);
|
||
} catch (ConnectionPoolException e) {
|
||
logger.error("ConnectionPoolException", e);
|
||
}finally {
|
||
if ((pool!=null) && (con!=null)){
|
||
pool.releaseConnection(con);
|
||
}
|
||
try {
|
||
if (results != null) {
|
||
results.close();
|
||
}
|
||
} catch (SQLException ex) {
|
||
logger.error("sql Error", ex);
|
||
}
|
||
}
|
||
return nextUpdate;
|
||
}
|
||
|
||
/**
|
||
* Convert long in date
|
||
*/
|
||
public static String nextUpdateDate(long input){
|
||
Date date = new Date(input);
|
||
Calendar cal = new GregorianCalendar();
|
||
cal.setTime(date);
|
||
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
|
||
return(dateFormat.format(date));
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/**
|
||
* Update floraDB thread
|
||
*/
|
||
|
||
class UpdateThread extends Thread {
|
||
|
||
long nextup;
|
||
static Logger logger = LoggerFactory.getLogger(UpdateThread.class);
|
||
|
||
UpdateThread(long update) {
|
||
super("Thread");
|
||
this.nextup = update;
|
||
start(); // Start the thread
|
||
}
|
||
|
||
// update db every month (30 days)
|
||
public void run() {
|
||
|
||
while (true) {
|
||
logger.trace(createLabel(nextup));
|
||
try {
|
||
sleep(nextup);
|
||
//Utils util = new Utils();
|
||
if (upInfo()){
|
||
setlastupdate();
|
||
this.nextup = 2592000000L;
|
||
}
|
||
} catch (SQLException e) {
|
||
logger.error("sql Error", e);
|
||
} catch (Throwable e) {
|
||
logger.error("General Error", e);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* Set next update date
|
||
*/
|
||
private String createLabel(long nextup) {
|
||
Date date = new Date();
|
||
String label = "Flora DB will be updated on " + Utils.nextUpdateDate(nextup + date.getTime());
|
||
return label;
|
||
|
||
}
|
||
|
||
/**
|
||
* Set next update date
|
||
*/
|
||
private void setlastupdate() {
|
||
|
||
ConnectionPool pool = null;
|
||
Connection con = null;
|
||
boolean result;
|
||
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
con = pool.getConnection();
|
||
|
||
Date date = new Date();
|
||
long dt = date.getTime();
|
||
java.sql.Date today = new java.sql.Date (dt);
|
||
String query = "insert into updates (date) values ('" + today + "')";
|
||
|
||
result = pool.insertPreStatement(query);
|
||
if (!result){
|
||
logger.trace("problem setting last update date");
|
||
|
||
}
|
||
} catch (ConnectionPoolException e) {
|
||
logger.error("ConnectionPoolException", e);
|
||
}finally {
|
||
if ((pool!=null) && (con!=null)){
|
||
pool.releaseConnection(con);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Update db by new threads
|
||
*/
|
||
public static boolean upInfo() throws SQLException, MalformedURLException, IOException {
|
||
|
||
logger.trace("Update DB in BRAZILIAN-FLORA-PLUGIN");
|
||
try{
|
||
ArrayList<ArrayList<String>> list = Utils.discoverPath("http://checklist.florabrasil.net/service/TREE/VERSION/2012/FORMAT/xml/LANG/en/", null, "", null, false);
|
||
int sizeList = list.size();
|
||
logger.trace(list.toString());
|
||
Thread[] threads = new Thread[sizeList];
|
||
|
||
for (int i = 0; i < sizeList; i++) {
|
||
logger.trace(list.get(i).toString());
|
||
threads[i] = new NewThread(list.get(i), i); // creo un nuovo thread
|
||
|
||
}
|
||
|
||
for (int i = 0; i < sizeList; i++) {
|
||
try {
|
||
logger.trace("join");
|
||
threads[i].join();
|
||
} catch (InterruptedException e) {
|
||
logger.trace("interrupted join");
|
||
return false;
|
||
}
|
||
}
|
||
}catch (Exception e) {
|
||
logger.error("exc", e);
|
||
logger.trace("Exception");
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* Update Synonyms table
|
||
*/
|
||
|
||
class UpdateSynonymsThread extends Thread {
|
||
|
||
static Logger logger = LoggerFactory.getLogger(UpdateThread.class);
|
||
long nextup;
|
||
|
||
UpdateSynonymsThread(long update) {
|
||
super("Thread");
|
||
this.nextup = update;
|
||
start(); // Start the thread
|
||
}
|
||
|
||
// update db every month (30 days)
|
||
public void run() {
|
||
Date date = new Date();
|
||
logger.trace("Synonyms table in Flora DB will be updated on " + Utils.nextUpdateDate(nextup + date.getTime() ));
|
||
while (true) {
|
||
try {
|
||
|
||
sleep(nextup);
|
||
//Utils util = new Utils();
|
||
if (synonyms()){
|
||
this.nextup = 2764800000L;
|
||
}
|
||
|
||
} catch (SQLException e) {
|
||
logger.error("sql Error", e);
|
||
} catch (Throwable e) {
|
||
logger.error("General Error", e);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* Parse every path looking for synonyms
|
||
* @return
|
||
*/
|
||
protected static boolean synonyms() throws SQLException {
|
||
|
||
ResultSet res = null;
|
||
ConnectionPool pool = null;
|
||
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
logger.trace("select a.id, a.name, a.rank, b.name, c.name, a.id_parent from " + FloraPlugin.tableName + " as a join flora as b on (a.rank = 'SubSpecies' or a.rank = 'Species' or a.rank = 'Genus') and a.id_parent = b.id join flora as c on b.id_parent=c.id where a.status = 'Accepted name'");
|
||
res = pool.selectPrestatement("select a.id, a.name, a.rank, b.name, c.name, a.id_parent from " + FloraPlugin.tableName + " as a join flora as b on (a.rank = 'SubSpecies' or a.rank = 'Species' or a.rank = 'Genus') and a.id_parent = b.id join flora as c on b.id_parent=c.id where a.status = 'Accepted name'", null);
|
||
|
||
// res = database.get("select a.id, a.name, a.rank, b.name, c.name, a.id_parent from " + FloraPlugin.tableName + " as a join flora as b on (a.rank = 'SubSpecies' or a.rank = 'Species' or a.rank = 'Genus') and a.id_parent = b.id join flora as c on b.id_parent=c.id where a.status = 'Accepted name' ORDER BY a.id");
|
||
|
||
while(res.next()) {
|
||
|
||
String id = res.getString(1);
|
||
String name = res.getString(2);
|
||
String rank = res.getString(3);
|
||
String parent = res.getString(4);
|
||
String grandparent = res.getString(5);
|
||
String id_parent = res.getString(6);
|
||
String pathUrl = "";
|
||
|
||
if (rank.equals("Genus")) {
|
||
pathUrl = "http://www.checklist.florabrasil.net/service/VERSION/2012/FORMAT/xml/LANG/en/SYNONYMS/GENUS/" + name.replace(" ", "%20");
|
||
// rankParent = "family";
|
||
}
|
||
else if (rank.equals("Species")) {
|
||
pathUrl = "http://www.checklist.florabrasil.net/service/VERSION/2012/FORMAT/xml/LANG/en/SYNONYMS/GENUS/" + parent + "/SPECIES/" + name.replace(" ", "%20");
|
||
// rankParent = "genus";
|
||
}
|
||
else if (rank.equals("SubSpecies")) {
|
||
pathUrl = "http://www.checklist.florabrasil.net/service/VERSION/2012/FORMAT/xml/LANG/en/SYNONYMS/GENUS/" + grandparent + "/SPECIES/" + parent + "/SUBSPECIES/" + name.replace(" ", "%20");
|
||
// rankParent = "species";
|
||
}
|
||
|
||
// logger.trace(pathUrl);
|
||
insertSynonym(id, id_parent, pathUrl);
|
||
}
|
||
} catch (SQLException sqlExcept) {
|
||
|
||
logger.error("SQL Exception", sqlExcept);
|
||
return false;
|
||
} catch (ConnectionPoolException e) {
|
||
// TODO Auto-generated catch block
|
||
e.printStackTrace();
|
||
}finally{
|
||
if (res != null)
|
||
res.close();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Populate table synonyms
|
||
*/
|
||
protected static void insertSynonym(String id, String id_parent, String pathUrl) {
|
||
try {
|
||
// logger.trace(" pathUrl: " +pathUrl);
|
||
String idSyn = "";
|
||
String stmt = "";
|
||
Map<String, String> values = null;
|
||
if (Utils.urlExists(pathUrl)){
|
||
|
||
InputStream is = null;
|
||
XMLInputFactory ifactory;
|
||
XMLEventReader eventReader = null;
|
||
try{
|
||
// logger.trace("open 2");
|
||
is = URI.create(pathUrl.replace(" ", "")).toURL().openStream();
|
||
ifactory = XMLInputFactory.newInstance();
|
||
eventReader = ifactory.createXMLEventReader(is, "utf-8");
|
||
|
||
while (eventReader.hasNext()){
|
||
XMLEvent event = eventReader.nextEvent();
|
||
|
||
if (Utils.checkStartElement(event, "id")){
|
||
idSyn = Utils.readCharacters(eventReader);
|
||
|
||
continue;
|
||
} else if (Utils.checkEndElement(event, "result")){
|
||
break;
|
||
} else if (Utils.checkEndElement(event, "record")){
|
||
|
||
if (!idSyn.equals(id)){
|
||
// logger.trace("found synonym");
|
||
ConnectionPool pool = null;
|
||
Connection con = null;
|
||
ResultSet res = null;
|
||
try {
|
||
pool = ConnectionPool.getConnectionPool();
|
||
con = pool.getConnection();
|
||
ArrayList<String> terms = new ArrayList<String>();
|
||
res = pool.selectPrestatement("select count(*) from " + FloraPlugin.tableName + " where id = ? ", idSyn);
|
||
if(res.next()) {
|
||
if (res.getInt(1) == 0) {
|
||
values = Utils.findTags(idSyn);
|
||
|
||
terms.add(idSyn);
|
||
terms.add(values.get("rank"));
|
||
terms.add(values.get("plain_name"));
|
||
terms.add(id_parent);
|
||
terms.add(values.get("author"));
|
||
terms.add(id);
|
||
terms.add(values.get("status"));
|
||
terms.add(pathUrl);
|
||
terms.add(values.get("qualifier"));
|
||
|
||
|
||
stmt = ("insert into flora (id, rank, scientific_name, id_parent, citation, acceptednameusageid, status, path, qualifier) values (?, ?, ?, ?, ?, ?, ?, ?, ?)");
|
||
|
||
// else{
|
||
// stmt = ("update flora set id = ?, rank = ?, scientific_name = ?, id_parent = ?, citation = ?, acceptednameusageid = ?, status = ?, path = ?, qualifier = ? where id = '" + idSyn + "'");
|
||
// }
|
||
|
||
if (!pool.preStatement(stmt, terms)){
|
||
logger.trace("error");
|
||
}
|
||
terms.clear();
|
||
values.clear();
|
||
}
|
||
}
|
||
}catch (Exception e) {
|
||
logger.error("Error reading " + pathUrl);
|
||
// logger.error("General Error", e);
|
||
}finally{
|
||
if (res != null)
|
||
res.close();
|
||
if ((pool!=null) && (con!=null)){
|
||
pool.releaseConnection(con);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (Exception e) {
|
||
logger.error("ExceptionPrintStackTrace",e);
|
||
}finally{
|
||
// logger.trace("close 2");
|
||
try {
|
||
if (eventReader != null)
|
||
eventReader.close();
|
||
if (is != null)
|
||
is.close();
|
||
} catch (XMLStreamException e) {
|
||
logger.error("XMLStreamException",e);
|
||
}
|
||
}
|
||
}
|
||
}catch (Exception e) {
|
||
logger.error("General Error", e);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
class NewThread extends Thread {
|
||
|
||
static Logger logger = LoggerFactory.getLogger(NewThread.class);
|
||
|
||
ArrayList<String> elem;
|
||
String pathUrls;
|
||
String id_parent;
|
||
Integer idThread;
|
||
String sName;
|
||
|
||
NewThread(ArrayList<String> arrayList, Integer idThread) {
|
||
|
||
super("Thread");
|
||
this.elem = arrayList;
|
||
this.pathUrls = (elem.get(0));
|
||
this.id_parent = (elem.get(1));
|
||
this.sName = (elem.get(2));
|
||
this.idThread = idThread;
|
||
start(); // Start the thread
|
||
|
||
}
|
||
|
||
// This is the entry point for the child threads
|
||
public void run() {
|
||
try {
|
||
// logger.trace("http://checklist.florabrasil.net/service/TREE/VERSION/2012/FORMAT/xml/LANG/en/PATH/" + pathUrls);
|
||
Utils.discoverPath("http://checklist.florabrasil.net/service/TREE/VERSION/2012/FORMAT/xml/LANG/en/PATH/" + pathUrls, id_parent, sName, idThread, true);
|
||
// Discover.shutdown();
|
||
}catch (SQLException e) {
|
||
logger.error("SQL Exception", e);
|
||
} catch (MalformedURLException e) {
|
||
logger.error("MalformedURL Exception", e);
|
||
} catch (IOException e) {
|
||
logger.error("IOException", e);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|