- more refactoring >> YMarkEntry
- integration of SurrogateReader as bookmark importer
- various small bug fixes e.g. get_xbel.xml

git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@7668 6c8d7289-2bf4-0310-a012-ef5d649a1542
pull/1/head
apfelmaennchen 14 years ago
parent 7c149e0f9d
commit 60412d2bb3

@ -1,6 +1,5 @@
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -11,6 +10,7 @@ import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.blob.Tables; import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.index.RowSpaceExceededException; import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables; import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil; import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard; import de.anomic.search.Switchboard;
@ -159,7 +159,7 @@ public class Table_YMark_p {
} }
if (!post.get("commitrow", "").isEmpty()) { if (!post.get("commitrow", "").isEmpty()) {
final HashMap<String, String> bmk = new HashMap<String, String>(); final YMarkEntry bmk = new YMarkEntry();
for (final Map.Entry<String, String> entry: post.entrySet()) { for (final Map.Entry<String, String> entry: post.entrySet()) {
if (entry.getKey().startsWith("col_")) { if (entry.getKey().startsWith("col_")) {
bmk.put(entry.getKey().substring(4), entry.getValue()); bmk.put(entry.getKey().substring(4), entry.getValue());
@ -244,7 +244,7 @@ public class Table_YMark_p {
mapIterator = sb.tables.bookmarks.getBookmarksByFolder(bmk_user, post.get("folders")); mapIterator = sb.tables.bookmarks.getBookmarksByFolder(bmk_user, post.get("folders"));
} else if(post.containsKey("tags") && !post.get("tags").isEmpty()) { } else if(post.containsKey("tags") && !post.get("tags").isEmpty()) {
// mapIterator = sb.tables.orderByPK(sb.tables.bookmarks.tags.getBookmarks(bmk_user, post.get("tags")), maxcount).iterator(); // mapIterator = sb.tables.orderByPK(sb.tables.bookmarks.tags.getBookmarks(bmk_user, post.get("tags")), maxcount).iterator();
final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkTables.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR); final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkEntry.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR);
mapIterator = sb.tables.bookmarks.getBookmarksByTag(bmk_user, tagArray); mapIterator = sb.tables.bookmarks.getBookmarksByTag(bmk_user, tagArray);
} else { } else {
mapIterator = sb.tables.orderByPK(sb.tables.iterator(table, matcher), maxcount).iterator(); mapIterator = sb.tables.orderByPK(sb.tables.iterator(table, matcher), maxcount).iterator();

@ -1,10 +1,9 @@
import java.io.IOException; import java.io.IOException;
import java.util.HashMap;
import net.yacy.cora.protocol.RequestHeader; import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.index.RowSpaceExceededException; import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB; import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables; import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil; import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard; import de.anomic.search.Switchboard;
@ -25,7 +24,7 @@ public class add_ymark {
if(isAdmin || isAuthUser) { if(isAdmin || isAuthUser) {
final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN); final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
String url = post.get(YMarkTables.BOOKMARK.URL.key(),YMarkTables.BOOKMARK.URL.deflt()); String url = post.get(YMarkEntry.BOOKMARK.URL.key(),YMarkEntry.BOOKMARK.URL.deflt());
boolean hasProtocol = false; boolean hasProtocol = false;
for (YMarkTables.PROTOCOLS p : YMarkTables.PROTOCOLS.values()) { for (YMarkTables.PROTOCOLS p : YMarkTables.PROTOCOLS.values()) {
hasProtocol = url.toLowerCase().startsWith(p.protocol()); hasProtocol = url.toLowerCase().startsWith(p.protocol());
@ -34,17 +33,17 @@ public class add_ymark {
url=YMarkTables.PROTOCOLS.HTTP.protocol(url); url=YMarkTables.PROTOCOLS.HTTP.protocol(url);
} }
final HashMap<String,String> data = new HashMap<String,String>(); final YMarkEntry bmk = new YMarkEntry();
data.put(YMarkTables.BOOKMARK.URL.key(), url); bmk.put(YMarkEntry.BOOKMARK.URL.key(), url);
data.put(YMarkTables.BOOKMARK.TITLE.key(), post.get(YMarkTables.BOOKMARK.TITLE.key(),YMarkTables.BOOKMARK.TITLE.deflt())); bmk.put(YMarkEntry.BOOKMARK.TITLE.key(), post.get(YMarkEntry.BOOKMARK.TITLE.key(),YMarkEntry.BOOKMARK.TITLE.deflt()));
data.put(YMarkTables.BOOKMARK.DESC.key(), post.get(YMarkTables.BOOKMARK.DESC.key(),YMarkTables.BOOKMARK.DESC.deflt())); bmk.put(YMarkEntry.BOOKMARK.DESC.key(), post.get(YMarkEntry.BOOKMARK.DESC.key(),YMarkEntry.BOOKMARK.DESC.deflt()));
data.put(YMarkTables.BOOKMARK.PUBLIC.key(), post.get(YMarkTables.BOOKMARK.PUBLIC.key(),YMarkTables.BOOKMARK.PUBLIC.deflt())); bmk.put(YMarkEntry.BOOKMARK.PUBLIC.key(), post.get(YMarkEntry.BOOKMARK.PUBLIC.key(),YMarkEntry.BOOKMARK.PUBLIC.deflt()));
data.put(YMarkTables.BOOKMARK.TAGS.key(), YMarkUtil.cleanTagsString(post.get(YMarkTables.BOOKMARK.TAGS.key(),YMarkTables.BOOKMARK.TAGS.deflt()))); bmk.put(YMarkEntry.BOOKMARK.TAGS.key(), YMarkUtil.cleanTagsString(post.get(YMarkEntry.BOOKMARK.TAGS.key(),YMarkEntry.BOOKMARK.TAGS.deflt())));
data.put(YMarkTables.BOOKMARK.FOLDERS.key(), YMarkUtil.cleanFoldersString(post.get(YMarkTables.BOOKMARK.FOLDERS.key(),YMarkTables.FOLDERS_UNSORTED))); bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(), YMarkUtil.cleanFoldersString(post.get(YMarkEntry.BOOKMARK.FOLDERS.key(),YMarkEntry.FOLDERS_UNSORTED)));
try { try {
sb.tables.bookmarks.addBookmark(bmk_user, data, false); sb.tables.bookmarks.addBookmark(bmk_user, bmk, false);
} catch (IOException e) { } catch (IOException e) {
Log.logException(e); Log.logException(e);
} catch (RowSpaceExceededException e) { } catch (RowSpaceExceededException e) {

@ -4,6 +4,7 @@ import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.index.RowSpaceExceededException; import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB; import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables; import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil; import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard; import de.anomic.search.Switchboard;
@ -27,10 +28,10 @@ public class delete_ymark {
final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN); final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
byte[] urlHash = null; byte[] urlHash = null;
try { try {
if(post.containsKey(YMarkTables.BOOKMARKS_ID)) { if(post.containsKey(YMarkEntry.BOOKMARKS_ID)) {
urlHash = post.get(YMarkTables.BOOKMARKS_ID).getBytes(); urlHash = post.get(YMarkEntry.BOOKMARKS_ID).getBytes();
} else if(post.containsKey(YMarkTables.BOOKMARK.URL.key())) { } else if(post.containsKey(YMarkEntry.BOOKMARK.URL.key())) {
urlHash = YMarkUtil.getBookmarkId(post.get(YMarkTables.BOOKMARK.URL.key())); urlHash = YMarkUtil.getBookmarkId(post.get(YMarkEntry.BOOKMARK.URL.key()));
} else { } else {
prop.put("result", "0"); prop.put("result", "0");
return prop; return prop;

@ -17,6 +17,7 @@ import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB; import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkCrawlStart; import de.anomic.data.ymark.YMarkCrawlStart;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkMetadata; import de.anomic.data.ymark.YMarkMetadata;
import de.anomic.data.ymark.YMarkTables; import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil; import de.anomic.data.ymark.YMarkUtil;
@ -112,8 +113,8 @@ public class get_treeview {
while (bit.hasNext()) { while (bit.hasNext()) {
bmk_row = bit.next(); bmk_row = bit.next();
if(bmk_row != null) { if(bmk_row != null) {
final String url = UTF8.String(bmk_row.get(YMarkTables.BOOKMARK.URL.key())); final String url = UTF8.String(bmk_row.get(YMarkEntry.BOOKMARK.URL.key()));
final String title = bmk_row.get(YMarkTables.BOOKMARK.TITLE.key(), YMarkTables.BOOKMARK.TITLE.deflt()); final String title = bmk_row.get(YMarkEntry.BOOKMARK.TITLE.key(), YMarkEntry.BOOKMARK.TITLE.deflt());
// TODO: get_treeview - get rid of bmtype // TODO: get_treeview - get rid of bmtype
if (post.containsKey("bmtype")) { if (post.containsKey("bmtype")) {
@ -164,8 +165,8 @@ public class get_treeview {
if (key.equals("url")) if (key.equals("url"))
url = value; url = value;
prop.put("folders_"+count+"_foldername","<small><b>"+key+":</b> " + value + "</small>"); prop.put("folders_"+count+"_foldername","<small><b>"+key+":</b> " + value + "</small>");
if(YMarkTables.BOOKMARK.contains(key)) if(YMarkEntry.BOOKMARK.contains(key))
putProp(count, YMarkTables.BOOKMARK.get(key).type()); putProp(count, YMarkEntry.BOOKMARK.get(key).type());
else else
putProp(count, "meta"); putProp(count, "meta");
count++; count++;

@ -9,6 +9,7 @@ import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB; import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkDate; import de.anomic.data.ymark.YMarkDate;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables; import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil; import de.anomic.data.ymark.YMarkUtil;
import de.anomic.data.ymark.YMarkXBELImporter; import de.anomic.data.ymark.YMarkXBELImporter;
@ -63,8 +64,6 @@ public class get_xbel {
} catch (IOException e) { } catch (IOException e) {
Log.logException(e); Log.logException(e);
} }
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "root: "+root+" root_deph: "+root_depth);
while (fit.hasNext()) { while (fit.hasNext()) {
String folder = fit.next(); String folder = fit.next();
@ -114,29 +113,29 @@ public class get_xbel {
buffer.append(" id=\"b:"); buffer.append(" id=\"b:");
buffer.append(urlHash); buffer.append(urlHash);
buffer.append(YMarkTables.BOOKMARK.URL.xbel()); buffer.append(YMarkEntry.BOOKMARK.URL.xbel());
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkTables.BOOKMARK.URL.key(), YMarkTables.BOOKMARK.URL.deflt()), true)); buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkEntry.BOOKMARK.URL.key(), YMarkEntry.BOOKMARK.URL.deflt()), true));
buffer.append(YMarkTables.BOOKMARK.DATE_ADDED.xbel()); buffer.append(YMarkEntry.BOOKMARK.DATE_ADDED.xbel());
date.set(bmk_row.get(YMarkTables.BOOKMARK.DATE_ADDED.key())); date.set(bmk_row.get(YMarkEntry.BOOKMARK.DATE_ADDED.key()));
buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true)); buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true));
buffer.append(YMarkTables.BOOKMARK.DATE_MODIFIED.xbel()); buffer.append(YMarkEntry.BOOKMARK.DATE_MODIFIED.xbel());
date.set(bmk_row.get(YMarkTables.BOOKMARK.DATE_MODIFIED.key())); date.set(bmk_row.get(YMarkEntry.BOOKMARK.DATE_MODIFIED.key()));
buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true)); buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true));
buffer.append(YMarkTables.BOOKMARK.DATE_VISITED.xbel()); buffer.append(YMarkEntry.BOOKMARK.DATE_VISITED.xbel());
date.set(bmk_row.get(YMarkTables.BOOKMARK.DATE_VISITED.key())); date.set(bmk_row.get(YMarkEntry.BOOKMARK.DATE_VISITED.key()));
buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true)); buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true));
buffer.append(YMarkTables.BOOKMARK.TAGS.xbel()); buffer.append(YMarkEntry.BOOKMARK.TAGS.xbel());
buffer.append(bmk_row.get(YMarkTables.BOOKMARK.TAGS.key(), YMarkTables.BOOKMARK.TAGS.deflt())); buffer.append(bmk_row.get(YMarkEntry.BOOKMARK.TAGS.key(), YMarkEntry.BOOKMARK.TAGS.deflt()));
buffer.append(YMarkTables.BOOKMARK.PUBLIC.xbel()); buffer.append(YMarkEntry.BOOKMARK.PUBLIC.xbel());
buffer.append(bmk_row.get(YMarkTables.BOOKMARK.PUBLIC.key(), YMarkTables.BOOKMARK.PUBLIC.deflt())); buffer.append(bmk_row.get(YMarkEntry.BOOKMARK.PUBLIC.key(), YMarkEntry.BOOKMARK.PUBLIC.deflt()));
buffer.append(YMarkTables.BOOKMARK.VISITS.xbel()); buffer.append(YMarkEntry.BOOKMARK.VISITS.xbel());
buffer.append(bmk_row.get(YMarkTables.BOOKMARK.VISITS.key(), YMarkTables.BOOKMARK.VISITS.deflt())); buffer.append(bmk_row.get(YMarkEntry.BOOKMARK.VISITS.key(), YMarkEntry.BOOKMARK.VISITS.deflt()));
buffer.append("\"\n>"); buffer.append("\"\n>");
prop.put("xbel_"+count+"_elements", buffer.toString()); prop.put("xbel_"+count+"_elements", buffer.toString());
@ -144,14 +143,14 @@ public class get_xbel {
buffer.setLength(0); buffer.setLength(0);
buffer.append(YMarkXBELImporter.XBEL.TITLE.startTag(false)); buffer.append(YMarkXBELImporter.XBEL.TITLE.startTag(false));
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkTables.BOOKMARK.TITLE.key(), YMarkTables.BOOKMARK.TITLE.deflt()), true)); buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkEntry.BOOKMARK.TITLE.key(), YMarkEntry.BOOKMARK.TITLE.deflt()), true));
buffer.append(YMarkXBELImporter.XBEL.TITLE.endTag(false)); buffer.append(YMarkXBELImporter.XBEL.TITLE.endTag(false));
prop.put("xbel_"+count+"_elements", buffer.toString()); prop.put("xbel_"+count+"_elements", buffer.toString());
count++; count++;
buffer.setLength(0); buffer.setLength(0);
buffer.append(YMarkXBELImporter.XBEL.DESC.startTag(false)); buffer.append(YMarkXBELImporter.XBEL.DESC.startTag(false));
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkTables.BOOKMARK.DESC.key(), YMarkTables.BOOKMARK.DESC.deflt()), true)); buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkEntry.BOOKMARK.DESC.key(), YMarkEntry.BOOKMARK.DESC.deflt()), true));
buffer.append(YMarkXBELImporter.XBEL.DESC.endTag(false)); buffer.append(YMarkXBELImporter.XBEL.DESC.endTag(false));
prop.put("xbel_"+count+"_elements", buffer.toString()); prop.put("xbel_"+count+"_elements", buffer.toString());
count++; count++;
@ -163,11 +162,14 @@ public class get_xbel {
} }
} }
} }
if(root_depth < 3)
n--;
while(n > root_depth) { while(n > root_depth) {
prop.put("xbel_"+count+"_elements", YMarkXBELImporter.XBEL.FOLDER.endTag(false)); prop.put("xbel_"+count+"_elements", YMarkXBELImporter.XBEL.FOLDER.endTag(false));
count++; count++;
n--; n--;
} }
prop.put("root", root);
prop.put("user", bmk_user.substring(0,1).toUpperCase() + bmk_user.substring(1)); prop.put("user", bmk_user.substring(0,1).toUpperCase() + bmk_user.substring(1));
prop.put("xbel", count); prop.put("xbel", count);

@ -4,7 +4,7 @@
<!ENTITY % local.url.att "yacy:public CDATA #IMPLIED yacy:tags CDATA #IMPLIED yacy:visits CDATA #IMPLIED"> <!ENTITY % local.url.att "yacy:public CDATA #IMPLIED yacy:tags CDATA #IMPLIED yacy:visits CDATA #IMPLIED">
]> ]>
<xbel version="1.0" xmlns:yacy="http://www.yacy.net"> <xbel version="1.0" xmlns:yacy="http://www.yacy.net">
<title>#[user]# YaCy Bookmarks</title> <title>#[user]# YaCy Bookmarks: #[root]#</title>
<info> <info>
<metadata owner="http://www.yacy.net" /> <metadata owner="http://www.yacy.net" />
</info> </info>

@ -6,6 +6,7 @@ import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.blob.Tables; import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB; import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables; import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil; import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard; import de.anomic.search.Switchboard;
@ -32,9 +33,9 @@ public class get_ymark {
if(isAdmin || isAuthUser) { if(isAdmin || isAuthUser) {
final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN); final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
if(post.containsKey(YMarkTables.BOOKMARK.TAGS.key())) { if(post.containsKey(YMarkEntry.BOOKMARK.TAGS.key())) {
//tags = true; //tags = true;
final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkTables.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR); final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkEntry.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR);
try { try {
bookmarks = sb.tables.bookmarks.getBookmarksByTag(bmk_user, tagArray); bookmarks = sb.tables.bookmarks.getBookmarksByTag(bmk_user, tagArray);
} catch (IOException e) { } catch (IOException e) {
@ -71,7 +72,7 @@ public class get_ymark {
Tables.Row bmk_row = bit.next(); Tables.Row bmk_row = bit.next();
if (bmk_row != null) { if (bmk_row != null) {
prop.putXML("bookmarks_"+count+"_id", UTF8.String(bmk_row.getPK())); prop.putXML("bookmarks_"+count+"_id", UTF8.String(bmk_row.getPK()));
for (YMarkTables.BOOKMARK bmk : YMarkTables.BOOKMARK.values()) { for (YMarkEntry.BOOKMARK bmk : YMarkEntry.BOOKMARK.values()) {
prop.putXML("bookmarks_"+count+"_"+bmk.key(), bmk_row.get(bmk.key(),bmk.deflt())); prop.putXML("bookmarks_"+count+"_"+bmk.key(), bmk_row.get(bmk.key(),bmk.deflt()));
} }
count++; count++;

@ -2,11 +2,10 @@ import java.io.ByteArrayInputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException; import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import net.yacy.cora.document.UTF8; import net.yacy.cora.document.UTF8;
import net.yacy.cora.protocol.RequestHeader; import net.yacy.cora.protocol.RequestHeader;
import net.yacy.document.Parser.Failure; import net.yacy.document.Parser.Failure;
import net.yacy.document.content.SurrogateReader;
import net.yacy.kelondro.data.meta.DigestURI; import net.yacy.kelondro.data.meta.DigestURI;
import net.yacy.kelondro.index.RowSpaceExceededException; import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log; import net.yacy.kelondro.logging.Log;
@ -14,6 +13,7 @@ import net.yacy.kelondro.logging.Log;
import org.xml.sax.SAXException; import org.xml.sax.SAXException;
import de.anomic.data.UserDB; import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkHTMLImporter; import de.anomic.data.ymark.YMarkHTMLImporter;
import de.anomic.data.ymark.YMarkJSONImporter; import de.anomic.data.ymark.YMarkJSONImporter;
import de.anomic.data.ymark.YMarkMetadata; import de.anomic.data.ymark.YMarkMetadata;
@ -33,9 +33,9 @@ public class import_ymark {
final boolean isAdmin = (sb.verifyAuthentication(header, true)); final boolean isAdmin = (sb.verifyAuthentication(header, true));
final boolean isAuthUser = user!= null && user.hasRight(UserDB.AccessRight.BOOKMARK_RIGHT); final boolean isAuthUser = user!= null && user.hasRight(UserDB.AccessRight.BOOKMARK_RIGHT);
Thread t; Thread t;
HashMap<String,String> bmk; YMarkEntry bmk;
String root = YMarkTables.FOLDERS_IMPORTED; String root = YMarkEntry.FOLDERS_IMPORTED;
InputStreamReader reader = null; ByteArrayInputStream stream = null;
if(isAdmin || isAuthUser) { if(isAdmin || isAuthUser) {
String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN); String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
@ -50,49 +50,69 @@ public class import_ymark {
root = post.get("root"); root = post.get("root");
} }
if(post.containsKey("bmkfile") && post.containsKey("importer")){ if(post.containsKey("bmkfile") && post.containsKey("importer")){
try { stream = new ByteArrayInputStream(UTF8.getBytes(post.get("bmkfile$file")));
reader = new InputStreamReader(new ByteArrayInputStream(UTF8.getBytes(post.get("bmkfile$file"))),"UTF-8"); if(post.get("importer").equals("surro") && stream != null) {
} catch (UnsupportedEncodingException e1) { SurrogateReader surrogateReader;
Log.logException(e1); try {
// return rewrite properties surrogateReader = new SurrogateReader(stream, 10);
prop.put("result", "0"); } catch (IOException e) {
return prop; //TODO: display an error message
Log.logException(e);
prop.put("result", "0");
return prop;
}
t = new Thread(surrogateReader, "YMarks - Surrogate Reader");
t.start();
while ((bmk = new YMarkEntry(surrogateReader.take())) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
} else {
InputStreamReader reader = null;
try {
reader = new InputStreamReader(stream,"UTF-8");
} catch (UnsupportedEncodingException e1) {
//TODO: display an error message
Log.logException(e1);
prop.put("result", "0");
return prop;
}
if(post.get("importer").equals("html") && reader != null) {
final YMarkHTMLImporter htmlImporter = new YMarkHTMLImporter(reader, 10, root);
t = new Thread(htmlImporter, "YMarks - HTML Importer");
t.start();
while ((bmk = htmlImporter.take()) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
} else if(post.get("importer").equals("xbel") && reader != null) {
final YMarkXBELImporter xbelImporter;
try {
//TODO: make RootFold
xbelImporter = new YMarkXBELImporter(reader, 10, root);
} catch (SAXException e) {
//TODO: display an error message
Log.logException(e);
prop.put("result", "0");
return prop;
}
t = new Thread(xbelImporter, "YMarks - XBEL Importer");
t.start();
while ((bmk = xbelImporter.take()) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
} else if(post.get("importer").equals("json") && reader != null) {
YMarkJSONImporter jsonImporter;
jsonImporter = new YMarkJSONImporter(reader, 10, root);
t = new Thread(jsonImporter, "YMarks - JSON Importer");
t.start();
while ((bmk = jsonImporter.take()) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
}
} }
if(post.get("importer").equals("html") && reader != null) {
final YMarkHTMLImporter htmlImporter = new YMarkHTMLImporter(reader, 10, root);
t = new Thread(htmlImporter, "YMarks - HTML Importer");
t.start();
while ((bmk = htmlImporter.take()) != YMarkTables.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
} else if(post.get("importer").equals("xbel") && reader != null) {
final YMarkXBELImporter xbelImporter;
try {
//TODO: make RootFold
xbelImporter = new YMarkXBELImporter(reader, 10, root);
} catch (SAXException e) {
//TODO: display an error message
Log.logException(e);
prop.put("result", "0");
return prop;
}
t = new Thread(xbelImporter, "YMarks - XBEL Importer");
t.start();
while ((bmk = xbelImporter.take()) != YMarkTables.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
} else if(post.get("importer").equals("json") && reader != null) {
YMarkJSONImporter jsonImporter;
jsonImporter = new YMarkJSONImporter(reader, 10, root);
t = new Thread(jsonImporter, "YMarks - JSON Importer");
t.start();
while ((bmk = jsonImporter.take()) != YMarkTables.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
}
} }
} else { } else {
prop.put(YMarkTables.USER_AUTHENTICATE,YMarkTables.USER_AUTHENTICATE_MSG); prop.put(YMarkTables.USER_AUTHENTICATE,YMarkTables.USER_AUTHENTICATE_MSG);
@ -101,16 +121,16 @@ public class import_ymark {
return prop; return prop;
} }
public static void putBookmark(final Switchboard sb, final String bmk_user, final HashMap<String, String> bmk) { public static void putBookmark(final Switchboard sb, final String bmk_user, final YMarkEntry bmk) {
try { try {
if(!bmk.containsKey(YMarkTables.BOOKMARK.TAGS.key()) || bmk.get(YMarkTables.BOOKMARK.TAGS.key()).equals(YMarkTables.BOOKMARK.TAGS.deflt())) { if(!bmk.containsKey(YMarkEntry.BOOKMARK.TAGS.key()) || bmk.get(YMarkEntry.BOOKMARK.TAGS.key()).equals(YMarkEntry.BOOKMARK.TAGS.deflt())) {
final YMarkMetadata meta = new YMarkMetadata(new DigestURI(bmk.get(YMarkTables.BOOKMARK.URL.key()))); final YMarkMetadata meta = new YMarkMetadata(new DigestURI(bmk.get(YMarkEntry.BOOKMARK.URL.key())));
meta.loadDocument(sb.loader); meta.loadDocument(sb.loader);
bmk.put(YMarkTables.BOOKMARK.TAGS.key(), meta.autoTag(3)); bmk.put(YMarkEntry.BOOKMARK.TAGS.key(), meta.autoTag(3));
} }
sb.tables.bookmarks.addBookmark(bmk_user, bmk, true); sb.tables.bookmarks.addBookmark(bmk_user, bmk, true);
} catch (IOException e) { } catch (IOException e) {
Log.logWarning(YMarkTables.BOOKMARKS_LOG.toString(), "Importer - IOException for URL: "+bmk.get(YMarkTables.BOOKMARK.URL.key())); Log.logWarning(YMarkTables.BOOKMARKS_LOG.toString(), "Importer - IOException for URL: "+bmk.get(YMarkEntry.BOOKMARK.URL.key()));
} catch (RowSpaceExceededException e) { } catch (RowSpaceExceededException e) {
Log.logException(e); Log.logException(e);
} catch (Failure e) { } catch (Failure e) {

@ -25,6 +25,8 @@
XML Bookmark Exchange Language XML Bookmark Exchange Language
</a> </a>
</small> </small>
<br />
<input type="radio" name="importer" value="surro" /> Surrogate Reader
</dd> </dd>
<br /> <br />
<dt> <dt>

@ -67,7 +67,11 @@ public class YMarkDate {
} }
public String toISO8601() { public String toISO8601() {
return ISO8601Formatter.FORMATTER.format(new Date(this.date)); if(this.date == 0) {
return YMarkEntry.BOOKMARK.DATE_MODIFIED.deflt();
} else {
return ISO8601Formatter.FORMATTER.format(new Date(this.date));
}
} }
public byte[] toBytes() { public byte[] toBytes() {
@ -87,6 +91,11 @@ public class YMarkDate {
} }
public void set(byte[] date) { public void set(byte[] date) {
this.date = Long.parseLong(UTF8.String(date)); final String s = UTF8.String(date);
if(!s.isEmpty()) {
this.date = Long.parseLong(s);
} else {
this.date = 0;
}
} }
} }

@ -0,0 +1,158 @@
package de.anomic.data.ymark;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import net.yacy.document.content.DCEntry;
import net.yacy.kelondro.blob.Tables;
public class YMarkEntry extends TreeMap<String, String> {
private static final long serialVersionUID = 2179622977348536148L;
public static final YMarkEntry POISON = new YMarkEntry();
public static final String BOOKMARKS_ID = "id";
public static final String BOOKMARKS_REF = "ref";
public static final String FOLDERS_IMPORTED = "/imported";
public static final String FOLDERS_UNSORTED = "/unsorted";
public static enum BOOKMARK {
// key dc_attrb dflt html_attrb xbel_attrb json_attrb type
URL ("url", "dc:identifier", "", "href", "href", "uri", "link"),
TITLE ("title", "dc:title", "", "", "", "title", "meta"),
DESC ("desc", "dc:description", "", "", "", "", "comment"),
DATE_ADDED ("date_added", "", "", "add_date", "added", "dateAdded", "date"),
DATE_MODIFIED ("date_modified", "", "", "last_modified", "modified", "lastModified", "date"),
DATE_VISITED ("date_visited", "", "", "last_visited", "visited", "", "date"),
PUBLIC ("public", "", "flase", "", "yacy:public", "", "lock"),
TAGS ("tags", "dc:subject", "unsorted", "shortcuturl", "yacy:tags", "keyword", "tag"),
VISITS ("visits", "", "0", "", "yacy:visits", "", "stat"),
FOLDERS ("folders", "", "/unsorted", "", "", "", "folder");
private String key;
private String dc_attrb;
private String dflt;
private String html_attrb;
private String xbel_attrb;
private String json_attrb;
private String type;
private static final Map<String,BOOKMARK> lookup = new HashMap<String,BOOKMARK>();
static {
for(BOOKMARK b : EnumSet.allOf(BOOKMARK.class))
lookup.put(b.key(), b);
}
private static StringBuilder buffer = new StringBuilder(25);
private BOOKMARK(final String k, final String d, final String s, final String a, final String x, final String j, final String t) {
this.key = k;
this.dc_attrb = d;
this.dflt = s;
this.html_attrb = a;
this.xbel_attrb = x;
this.json_attrb = j;
this.type = t;
}
public static BOOKMARK get(String key) {
return lookup.get(key);
}
public static boolean contains(String key) {
return lookup.containsKey(key);
}
public String key() {
return this.key;
}
public String deflt() {
return this.dflt;
}
public String html_attrb() {
return this.html_attrb;
}
public String xbel_attrb() {
return this.xbel_attrb;
}
public String json_attrb() {
return this.json_attrb;
}
public String dc_attrb() {
return this.dc_attrb;
}
public String xbel() {
buffer.setLength(0);
buffer.append('"');
buffer.append('\n');
buffer.append(' ');
buffer.append(this.xbel_attrb);
buffer.append('=');
buffer.append('"');
return buffer.toString();
}
public String type() {
return this.type;
}
}
public YMarkEntry() {
super();
setCurrentTimeMillis(BOOKMARK.DATE_ADDED);
setCurrentTimeMillis(BOOKMARK.DATE_MODIFIED);
setDefaults();
}
public YMarkEntry(final DCEntry dc) {
for (BOOKMARK b : BOOKMARK.values()) {
if(dc.containsKey(b.dc_attrb)) {
this.put(b.key(), dc.get(b.dc_attrb));
}
}
setCurrentTimeMillis(BOOKMARK.DATE_ADDED);
setCurrentTimeMillis(BOOKMARK.DATE_MODIFIED);
setDefaults();
}
public YMarkEntry(final Tables.Row bmk_row) {
for (BOOKMARK b : BOOKMARK.values()) {
if(bmk_row.containsKey(b.key())) {
this.put(b.key(), bmk_row.get(b.key(), b.deflt()));
}
}
}
private void setCurrentTimeMillis(BOOKMARK b) {
final String date = String.valueOf(System.currentTimeMillis());
this.put(b.key(), date);
}
private void setDefaults() {
for (BOOKMARK b : BOOKMARK.values()) {
if(!b.deflt().isEmpty() && !this.containsKey(b.key())) {
this.put(b.key(), b.deflt());
}
}
}
public DCEntry getDCEntry() {
final DCEntry dc = new DCEntry();
for (BOOKMARK b : BOOKMARK.values()) {
if(!b.dc_attrb.isEmpty() && this.containsKey(b.key())) {
dc.put(b.dc_attrb, this.get(b.key()));
}
}
return dc;
}
public Tables.Data getData() {
final Tables.Data data = new Tables.Data();
for (BOOKMARK b : BOOKMARK.values()) {
if(this.containsKey(b.key()) && this.get(b.key()) != null) {
data.put(b.key(), this.get(b.key()));
} else {
data.put(b.key(), b.deflt());
}
}
return data;
}
}

@ -28,7 +28,6 @@ package de.anomic.data.ymark;
import java.io.IOException; import java.io.IOException;
import java.io.Reader; import java.io.Reader;
import java.util.HashMap;
import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ArrayBlockingQueue;
import javax.swing.text.MutableAttributeSet; import javax.swing.text.MutableAttributeSet;
@ -41,11 +40,11 @@ import net.yacy.kelondro.logging.Log;
public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements Runnable { public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements Runnable {
// Importer Variables // Importer Variables
private final ArrayBlockingQueue<HashMap<String,String>> bookmarks; private final ArrayBlockingQueue<YMarkEntry> bookmarks;
private final Reader bmk_file; private final Reader bmk_file;
private final String RootFolder; private final String RootFolder;
private final StringBuilder folderstring; private final StringBuilder folderstring;
private HashMap<String,String> bmk; private YMarkEntry bmk;
private final ParserDelegator htmlParser; private final ParserDelegator htmlParser;
// Statics // Statics
@ -63,12 +62,12 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
private HTML.Tag prevTag; private HTML.Tag prevTag;
public YMarkHTMLImporter(final Reader bmk_file, final int queueSize, final String root) { public YMarkHTMLImporter(final Reader bmk_file, final int queueSize, final String root) {
this.bookmarks = new ArrayBlockingQueue<HashMap<String,String>>(queueSize); this.bookmarks = new ArrayBlockingQueue<YMarkEntry>(queueSize);
this.bmk_file = bmk_file; this.bmk_file = bmk_file;
this.RootFolder = root; this.RootFolder = root;
this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE); this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folderstring.append(this.RootFolder); this.folderstring.append(this.RootFolder);
this.bmk = new HashMap<String,String>(); this.bmk = new YMarkEntry();
this.htmlParser = new ParserDelegator(); this.htmlParser = new ParserDelegator();
@ -83,7 +82,7 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
Log.logException(e); Log.logException(e);
} finally { } finally {
try { try {
this.bookmarks.put(YMarkTables.POISON); this.bookmarks.put(YMarkEntry.POISON);
} catch (InterruptedException e) { } catch (InterruptedException e) {
Log.logException(e); Log.logException(e);
} }
@ -100,10 +99,10 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
case NOTHING: case NOTHING:
break; break;
case BOOKMARK: case BOOKMARK:
this.bmk.put(YMarkTables.BOOKMARK.TITLE.key(), new String(data)); this.bmk.put(YMarkEntry.BOOKMARK.TITLE.key(), new String(data));
this.bmk.put(YMarkTables.BOOKMARK.FOLDERS.key(), this.folderstring.toString()); this.bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(), this.folderstring.toString());
this.bmk.put(YMarkTables.BOOKMARK.PUBLIC.key(), YMarkTables.BOOKMARK.PUBLIC.deflt()); this.bmk.put(YMarkEntry.BOOKMARK.PUBLIC.key(), YMarkEntry.BOOKMARK.PUBLIC.deflt());
this.bmk.put(YMarkTables.BOOKMARK.VISITS.key(), YMarkTables.BOOKMARK.VISITS.deflt()); this.bmk.put(YMarkEntry.BOOKMARK.VISITS.key(), YMarkEntry.BOOKMARK.VISITS.deflt());
break; break;
case FOLDER: case FOLDER:
this.folderstring.append(YMarkUtil.FOLDERS_SEPARATOR); this.folderstring.append(YMarkUtil.FOLDERS_SEPARATOR);
@ -113,7 +112,7 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "YMarksHTMLImporter - folder: "+this.folderstring+" desc: " + new String(data)); Log.logInfo(YMarkTables.BOOKMARKS_LOG, "YMarksHTMLImporter - folder: "+this.folderstring+" desc: " + new String(data));
break; break;
case BMK_DESC: case BMK_DESC:
this.bmk.put(YMarkTables.BOOKMARK.DESC.key(), new String(data)); this.bmk.put(YMarkEntry.BOOKMARK.DESC.key(), new String(data));
break; break;
default: default:
break; break;
@ -125,15 +124,15 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
if (!this.bmk.isEmpty()) { if (!this.bmk.isEmpty()) {
try { try {
this.bookmarks.put(this.bmk); this.bookmarks.put(this.bmk);
bmk = new HashMap<String,String>(); bmk = new YMarkEntry();
} catch (InterruptedException e) { } catch (InterruptedException e) {
Log.logException(e); Log.logException(e);
} }
} }
final String url = (String)a.getAttribute(HTML.Attribute.HREF); final String url = (String)a.getAttribute(HTML.Attribute.HREF);
this.bmk.put(YMarkTables.BOOKMARK.URL.key(), url); this.bmk.put(YMarkEntry.BOOKMARK.URL.key(), url);
for (YMarkTables.BOOKMARK bmk : YMarkTables.BOOKMARK.values()) { for (YMarkEntry.BOOKMARK bmk : YMarkEntry.BOOKMARK.values()) {
final String s = (String)a.getAttribute(bmk.html_attrb()); final String s = (String)a.getAttribute(bmk.html_attrb());
if(s != null) { if(s != null) {
switch(bmk) { switch(bmk) {
@ -175,7 +174,7 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
} }
} }
public HashMap<String,String> take() { public YMarkEntry take() {
try { try {
return this.bookmarks.take(); return this.bookmarks.take();
} catch (InterruptedException e) { } catch (InterruptedException e) {

@ -14,11 +14,11 @@ import org.json.simple.parser.ParseException;
public class YMarkJSONImporter implements Runnable, ContentHandler{ public class YMarkJSONImporter implements Runnable, ContentHandler{
// Importer Variables // Importer Variables
private final ArrayBlockingQueue<HashMap<String,String>> bookmarks; private final ArrayBlockingQueue<YMarkEntry> bookmarks;
private final Reader bmk_file; private final Reader bmk_file;
private final String RootFolder; private final String RootFolder;
private final StringBuilder folderstring; private final StringBuilder folderstring;
private HashMap<String,String> bmk; private YMarkEntry bmk;
private final JSONParser parser; private final JSONParser parser;
// Statics // Statics
@ -40,12 +40,12 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
private Boolean isAnnos; private Boolean isAnnos;
public YMarkJSONImporter(final Reader bmk_file, final int queueSize, final String root) { public YMarkJSONImporter(final Reader bmk_file, final int queueSize, final String root) {
this.bookmarks = new ArrayBlockingQueue<HashMap<String,String>>(queueSize); this.bookmarks = new ArrayBlockingQueue<YMarkEntry>(queueSize);
this.bmk_file = bmk_file; this.bmk_file = bmk_file;
this.RootFolder = root; this.RootFolder = root;
this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE); this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folderstring.append(this.RootFolder); this.folderstring.append(this.RootFolder);
this.bmk = new HashMap<String,String>(); this.bmk = new YMarkEntry();
this.parser = new JSONParser(); this.parser = new JSONParser();
@ -71,7 +71,7 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
if(key.equals(CHILDREN) && this.isFolder) { if(key.equals(CHILDREN) && this.isFolder) {
if(this.depth > 0) { if(this.depth > 0) {
this.folderstring.append(YMarkUtil.FOLDERS_SEPARATOR); this.folderstring.append(YMarkUtil.FOLDERS_SEPARATOR);
this.folderstring.append(this.obj.get(YMarkTables.BOOKMARK.TITLE.json_attrb())); this.folderstring.append(this.obj.get(YMarkEntry.BOOKMARK.TITLE.json_attrb()));
} }
this.depth++; this.depth++;
} else if(key.equals(ANNOS)) { } else if(key.equals(ANNOS)) {
@ -102,26 +102,26 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
public boolean endObject() throws ParseException, IOException { public boolean endObject() throws ParseException, IOException {
if(this.isBookmark) { if(this.isBookmark) {
this.bmk.put(YMarkTables.BOOKMARK.TITLE.key(),obj.get(YMarkTables.BOOKMARK.TITLE.json_attrb())); this.bmk.put(YMarkEntry.BOOKMARK.TITLE.key(),obj.get(YMarkEntry.BOOKMARK.TITLE.json_attrb()));
this.bmk.put(YMarkTables.BOOKMARK.URL.key(),obj.get(YMarkTables.BOOKMARK.URL.json_attrb())); this.bmk.put(YMarkEntry.BOOKMARK.URL.key(),obj.get(YMarkEntry.BOOKMARK.URL.json_attrb()));
date.setLength(0); date.setLength(0);
date.append(obj.get(YMarkTables.BOOKMARK.DATE_ADDED.json_attrb())); date.append(obj.get(YMarkEntry.BOOKMARK.DATE_ADDED.json_attrb()));
date.setLength(date.length()-3); date.setLength(date.length()-3);
this.bmk.put(YMarkTables.BOOKMARK.DATE_ADDED.key(), date.toString()); this.bmk.put(YMarkEntry.BOOKMARK.DATE_ADDED.key(), date.toString());
date.setLength(0); date.setLength(0);
date.append(obj.get(YMarkTables.BOOKMARK.DATE_MODIFIED.json_attrb())); date.append(obj.get(YMarkEntry.BOOKMARK.DATE_MODIFIED.json_attrb()));
date.setLength(date.length()-3); date.setLength(date.length()-3);
this.bmk.put(YMarkTables.BOOKMARK.DATE_MODIFIED.key(), date.toString()); this.bmk.put(YMarkEntry.BOOKMARK.DATE_MODIFIED.key(), date.toString());
this.bmk.put(YMarkTables.BOOKMARK.FOLDERS.key(),this.folderstring.toString()); this.bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(),this.folderstring.toString());
if(this.obj.containsKey(YMarkTables.BOOKMARK.TAGS.json_attrb())) { if(this.obj.containsKey(YMarkEntry.BOOKMARK.TAGS.json_attrb())) {
this.bmk.put(YMarkTables.BOOKMARK.TAGS.key(),obj.get(YMarkTables.BOOKMARK.TAGS.json_attrb())); this.bmk.put(YMarkEntry.BOOKMARK.TAGS.key(),obj.get(YMarkEntry.BOOKMARK.TAGS.json_attrb()));
} }
try { try {
this.bookmarks.put(this.bmk); this.bookmarks.put(this.bmk);
} catch (InterruptedException e) { } catch (InterruptedException e) {
Log.logException(e); Log.logException(e);
} }
this.bmk = new HashMap<String,String>(); this.bmk = new YMarkEntry();
} }
this.isBookmark = false; this.isBookmark = false;
return true; return true;
@ -176,14 +176,14 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
} finally { } finally {
try { try {
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "JSON Importer inserted poison pill in queue"); Log.logInfo(YMarkTables.BOOKMARKS_LOG, "JSON Importer inserted poison pill in queue");
this.bookmarks.put(YMarkTables.POISON); this.bookmarks.put(YMarkEntry.POISON);
} catch (InterruptedException e) { } catch (InterruptedException e) {
Log.logException(e); Log.logException(e);
} }
} }
} }
public HashMap<String,String> take() { public YMarkEntry take() {
try { try {
return this.bookmarks.take(); return this.bookmarks.take();
} catch (InterruptedException e) { } catch (InterruptedException e) {

@ -27,18 +27,14 @@
package de.anomic.data.ymark; package de.anomic.data.ymark;
import java.io.IOException; import java.io.IOException;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
import java.util.Map;
import java.util.TreeSet; import java.util.TreeSet;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import de.anomic.data.WorkTables; import de.anomic.data.WorkTables;
import net.yacy.kelondro.blob.Tables; import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.blob.Tables.Data;
import net.yacy.kelondro.index.RowSpaceExceededException; import net.yacy.kelondro.index.RowSpaceExceededException;
public class YMarkTables { public class YMarkTables {
@ -78,88 +74,9 @@ public class YMarkTables {
} }
} }
public static enum BOOKMARK {
// key dflt html_attrb xbel_attrb json_attrb type
URL ("url", "", "href", "href", "uri", "link"),
TITLE ("title", "", "", "", "title", "meta"),
DESC ("desc", "", "", "", "", "comment"),
DATE_ADDED ("date_added", "", "add_date", "added", "dateAdded", "date"),
DATE_MODIFIED ("date_modified", "", "last_modified", "modified", "lastModified", "date"),
DATE_VISITED ("date_visited", "", "last_visited", "visited", "", "date"),
PUBLIC ("public", "flase", "", "yacy:public", "", "lock"),
TAGS ("tags", "unsorted", "shortcuturl", "yacy:tags", "keyword", "tag"),
VISITS ("visits", "0", "", "yacy:visits", "", "stat"),
FOLDERS ("folders", "/unsorted", "", "", "", "folder");
private String key;
private String dflt;
private String html_attrb;
private String xbel_attrb;
private String json_attrb;
private String type;
private static final Map<String,BOOKMARK> lookup = new HashMap<String,BOOKMARK>();
static {
for(BOOKMARK b : EnumSet.allOf(BOOKMARK.class))
lookup.put(b.key(), b);
}
private static StringBuilder buffer = new StringBuilder(25);;
private BOOKMARK(String k, String s, String a, String x, String j, String t) {
this.key = k;
this.dflt = s;
this.html_attrb = a;
this.xbel_attrb = x;
this.json_attrb = j;
this.type = t;
}
public static BOOKMARK get(String key) {
return lookup.get(key);
}
public static boolean contains(String key) {
return lookup.containsKey(key);
}
public String key() {
return this.key;
}
public String deflt() {
return this.dflt;
}
public String html_attrb() {
return this.html_attrb;
}
public String xbel_attrb() {
return this.xbel_attrb;
}
public String json_attrb() {
return this.json_attrb;
}
public String xbel() {
buffer.setLength(0);
buffer.append('"');
buffer.append('\n');
buffer.append(' ');
buffer.append(this.xbel_attrb);
buffer.append('=');
buffer.append('"');
return buffer.toString();
}
public String type() {
return this.type;
}
}
public final static HashMap<String,String> POISON = new HashMap<String,String>();
public final static String FOLDERS_ROOT = "/"; public final static String FOLDERS_ROOT = "/";
public final static String FOLDERS_UNSORTED = "/unsorted"; public final static int FOLDER_BUFFER_SIZE = 100;
public final static String FOLDERS_IMPORTED = "/imported";
public static final int FOLDER_BUFFER_SIZE = 100;
public final static String BOOKMARKS_LOG = "BOOKMARKS"; public final static String BOOKMARKS_LOG = "BOOKMARKS";
public final static String BOOKMARKS_ID = "id";
public final static String USER_ADMIN = "admin"; public final static String USER_ADMIN = "admin";
public final static String USER_AUTHENTICATE = "AUTHENTICATE"; public final static String USER_AUTHENTICATE = "AUTHENTICATE";
public final static String USER_AUTHENTICATE_MSG = "Authentication required!"; public final static String USER_AUTHENTICATE_MSG = "Authentication required!";
@ -204,15 +121,15 @@ public class YMarkTables {
this.patternBuilder.append(p8); this.patternBuilder.append(p8);
final Pattern r = Pattern.compile(this.patternBuilder.toString()); final Pattern r = Pattern.compile(this.patternBuilder.toString());
final Iterator<Tables.Row> bit = this.worktables.iterator(bmk_table, YMarkTables.BOOKMARK.FOLDERS.key(), r); final Iterator<Tables.Row> bit = this.worktables.iterator(bmk_table, YMarkEntry.BOOKMARK.FOLDERS.key(), r);
final TreeSet<String> folders = new TreeSet<String>(); final TreeSet<String> folders = new TreeSet<String>();
final StringBuilder path = new StringBuilder(200); final StringBuilder path = new StringBuilder(200);
Tables.Row bmk_row = null; Tables.Row bmk_row = null;
while(bit.hasNext()) { while(bit.hasNext()) {
bmk_row = bit.next(); bmk_row = bit.next();
if(bmk_row.containsKey(BOOKMARK.FOLDERS.key())) { if(bmk_row.containsKey(YMarkEntry.BOOKMARK.FOLDERS.key())) {
final String[] folderArray = (new String(bmk_row.get(BOOKMARK.FOLDERS.key()),"UTF8")).split(YMarkUtil.TAGS_SEPARATOR); final String[] folderArray = (new String(bmk_row.get(YMarkEntry.BOOKMARK.FOLDERS.key()),"UTF8")).split(YMarkUtil.TAGS_SEPARATOR);
for (final String folder : folderArray) { for (final String folder : folderArray) {
if(folder.length() > root.length() && folder.substring(0, root.length()+1).equals(root+'/')) { if(folder.length() > root.length() && folder.substring(0, root.length()+1).equals(root+'/')) {
if(!folders.contains(folder)) { if(!folders.contains(folder)) {
@ -243,7 +160,7 @@ public class YMarkTables {
this.patternBuilder.append(')'); this.patternBuilder.append(')');
this.patternBuilder.append(p4); this.patternBuilder.append(p4);
final Pattern p = Pattern.compile(this.patternBuilder.toString()); final Pattern p = Pattern.compile(this.patternBuilder.toString());
return this.worktables.iterator(bmk_table, YMarkTables.BOOKMARK.FOLDERS.key(), p); return this.worktables.iterator(bmk_table, YMarkEntry.BOOKMARK.FOLDERS.key(), p);
} }
public Iterator<Tables.Row> getBookmarksByTag(final String bmk_user, final String[] tagArray) throws IOException { public Iterator<Tables.Row> getBookmarksByTag(final String bmk_user, final String[] tagArray) throws IOException {
@ -262,59 +179,28 @@ public class YMarkTables {
this.patternBuilder.append(tagArray.length); this.patternBuilder.append(tagArray.length);
this.patternBuilder.append('}'); this.patternBuilder.append('}');
final Pattern p = Pattern.compile(this.patternBuilder.toString()); final Pattern p = Pattern.compile(this.patternBuilder.toString());
return this.worktables.iterator(bmk_table, YMarkTables.BOOKMARK.TAGS.key(), p); return this.worktables.iterator(bmk_table, YMarkEntry.BOOKMARK.TAGS.key(), p);
} }
public void addBookmark(final String bmk_user, final HashMap<String,String> bmk, final boolean importer) throws IOException, RowSpaceExceededException { public void addBookmark(final String bmk_user, final YMarkEntry bmk, final boolean importer) throws IOException, RowSpaceExceededException {
final String bmk_table = TABLES.BOOKMARKS.tablename(bmk_user); final String bmk_table = TABLES.BOOKMARKS.tablename(bmk_user);
final String date = String.valueOf(System.currentTimeMillis()); final String date = String.valueOf(System.currentTimeMillis());
final byte[] urlHash = YMarkUtil.getBookmarkId(bmk.get(BOOKMARK.URL.key())); final byte[] urlHash = YMarkUtil.getBookmarkId(bmk.get(YMarkEntry.BOOKMARK.URL.key()));
Tables.Row bmk_row = null; Tables.Row bmk_row = null;
if (urlHash != null) { if (urlHash != null) {
bmk_row = this.worktables.select(bmk_table, urlHash); bmk_row = this.worktables.select(bmk_table, urlHash);
if (bmk_row == null) { if (bmk_row == null) {
// create and insert new entry // create and insert new entry
final Data data = new Data(); this.worktables.insert(bmk_table, urlHash, bmk.getData());
for (BOOKMARK b : BOOKMARK.values()) {
switch(b) {
case DATE_ADDED:
case DATE_MODIFIED:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
} else {
data.put(b.key(), String.valueOf(System.currentTimeMillis()).getBytes());
}
break;
case TAGS:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
} else {
data.put(b.key(), b.deflt());
}
break;
case FOLDERS:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
} else {
data.put(b.key(), b.deflt());
}
break;
default:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
}
}
}
this.worktables.insert(bmk_table, urlHash, data);
} else { } else {
// modify and update existing entry // modify and update existing entry
HashSet<String> oldSet; HashSet<String> oldSet;
HashSet<String> newSet; HashSet<String> newSet;
for (BOOKMARK b : BOOKMARK.values()) { for (YMarkEntry.BOOKMARK b : YMarkEntry.BOOKMARK.values()) {
switch(b) { switch(b) {
case DATE_ADDED: case DATE_ADDED:
if(!bmk_row.containsKey(b.key)) if(!bmk_row.containsKey(b.key()))
bmk_row.put(b.key(), date); bmk_row.put(b.key(), date);
break; break;
case DATE_MODIFIED: case DATE_MODIFIED:
@ -329,11 +215,11 @@ public class YMarkTables {
bmk_row.put(b.key(), YMarkUtil.keySetToString(newSet)); bmk_row.put(b.key(), YMarkUtil.keySetToString(newSet));
oldSet.clear(); oldSet.clear();
} else { } else {
bmk_row.put(b.key, bmk.get(b.key())); bmk_row.put(b.key(), bmk.get(b.key()));
} }
} else { } else {
newSet = new HashSet<String>(); newSet = new HashSet<String>();
bmk_row.put(b.key, bmk_row.get(b.key(), b.deflt())); bmk_row.put(b.key(), bmk_row.get(b.key(), b.deflt()));
} }
break; break;
case FOLDERS: case FOLDERS:
@ -345,18 +231,18 @@ public class YMarkTables {
bmk_row.put(b.key(), YMarkUtil.keySetToString(newSet)); bmk_row.put(b.key(), YMarkUtil.keySetToString(newSet));
oldSet.clear(); oldSet.clear();
} else { } else {
bmk_row.put(b.key, bmk.get(b.key())); bmk_row.put(b.key(), bmk.get(b.key()));
} }
} else { } else {
newSet = new HashSet<String>(); newSet = new HashSet<String>();
bmk_row.put(b.key, bmk_row.get(b.key(), b.deflt())); bmk_row.put(b.key(), bmk_row.get(b.key(), b.deflt()));
} }
break; break;
default: default:
if(bmk.containsKey(b.key())) { if(bmk.containsKey(b.key())) {
bmk_row.put(b.key, bmk.get(b.key())); bmk_row.put(b.key(), bmk.get(b.key()));
} else { } else {
bmk_row.put(b.key, bmk_row.get(b.key(), b.deflt())); bmk_row.put(b.key(), bmk_row.get(b.key(), b.deflt()));
} }
} }
} }

@ -86,7 +86,7 @@ public class YMarkUtil {
public final static String cleanTagsString(final String tagsString) { public final static String cleanTagsString(final String tagsString) {
StringBuilder ts = new StringBuilder(tagsString); StringBuilder ts = new StringBuilder(tagsString);
if(ts.length() == 0) if(ts.length() == 0)
return YMarkTables.BOOKMARK.TAGS.deflt(); return YMarkEntry.BOOKMARK.TAGS.deflt();
// get rid of double commas and space characters following a comma // get rid of double commas and space characters following a comma
for (int i = 0; i < ts.length()-1; i++) { for (int i = 0; i < ts.length()-1; i++) {
if (ts.charAt(i) == TAGS_SEPARATOR.charAt(0)) { if (ts.charAt(i) == TAGS_SEPARATOR.charAt(0)) {
@ -107,7 +107,7 @@ public class YMarkUtil {
public final static String cleanFoldersString(final String foldersString) { public final static String cleanFoldersString(final String foldersString) {
StringBuilder fs = new StringBuilder(cleanTagsString(foldersString)); StringBuilder fs = new StringBuilder(cleanTagsString(foldersString));
if(fs.length() == 0) if(fs.length() == 0)
return YMarkTables.BOOKMARK.FOLDERS.deflt(); return YMarkEntry.BOOKMARK.FOLDERS.deflt();
for (int i = 0; i < fs.length()-1; i++) { for (int i = 0; i < fs.length()-1; i++) {
if (fs.charAt(i) == FOLDERS_SEPARATOR.charAt(0)) { if (fs.charAt(i) == FOLDERS_SEPARATOR.charAt(0)) {
if (fs.charAt(i+1) == TAGS_SEPARATOR.charAt(0) || fs.charAt(i+1) == FOLDERS_SEPARATOR.charAt(0)) { if (fs.charAt(i+1) == TAGS_SEPARATOR.charAt(0) || fs.charAt(i+1) == FOLDERS_SEPARATOR.charAt(0)) {

@ -46,11 +46,11 @@ import org.xml.sax.helpers.XMLReaderFactory;
public class YMarkXBELImporter extends DefaultHandler implements Runnable { public class YMarkXBELImporter extends DefaultHandler implements Runnable {
// Importer Variables // Importer Variables
private final ArrayBlockingQueue<HashMap<String,String>> bookmarks; private final ArrayBlockingQueue<YMarkEntry> bookmarks;
private final Reader bmk_file; private final Reader bmk_file;
private final String RootFolder; private final String RootFolder;
private final StringBuilder folderstring; private final StringBuilder folderstring;
private HashMap<String,String> bmk; private YMarkEntry bmk;
private final XMLReader xmlReader; private final XMLReader xmlReader;
// Statics // Statics
@ -96,23 +96,23 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
} }
// Parser Variables // Parser Variables
private final HashMap<String,HashMap<String,String>> bmkRef; private final HashMap<String,YMarkEntry> bmkRef;
private final HashSet<HashMap<String,String>> aliasRef; private final HashSet<YMarkEntry> aliasRef;
private final StringBuilder buffer; private final StringBuilder buffer;
private final StringBuilder folder; private final StringBuilder folder;
private HashMap<String,String> ref; private YMarkEntry ref;
private XBEL outer_state; // BOOKMARK, FOLDER, NOTHING private XBEL outer_state; // BOOKMARK, FOLDER, NOTHING
private XBEL inner_state; // DESC, TITLE, INFO, ALIAS, (METADATA), NOTHING private XBEL inner_state; // DESC, TITLE, INFO, ALIAS, (METADATA), NOTHING
private boolean parse_value; private boolean parse_value;
public YMarkXBELImporter (final Reader bmk_file, final int queueSize, final String root) throws SAXException { public YMarkXBELImporter (final Reader bmk_file, final int queueSize, final String root) throws SAXException {
this.bookmarks = new ArrayBlockingQueue<HashMap<String,String>>(queueSize); this.bookmarks = new ArrayBlockingQueue<YMarkEntry>(queueSize);
this.bmk_file = bmk_file; this.bmk_file = bmk_file;
this.RootFolder = root; this.RootFolder = root;
this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE); this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folderstring.append(this.RootFolder); this.folderstring.append(this.RootFolder);
this.bmk = new HashMap<String,String>(); this.bmk = new YMarkEntry();
this.xmlReader = XMLReaderFactory.createXMLReader(); this.xmlReader = XMLReaderFactory.createXMLReader();
this.xmlReader.setContentHandler(this); this.xmlReader.setContentHandler(this);
@ -120,8 +120,8 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
this.xmlReader.setFeature("http://xml.org/sax/features/namespaces", false); this.xmlReader.setFeature("http://xml.org/sax/features/namespaces", false);
this.xmlReader.setFeature("http://xml.org/sax/features/validation", false); this.xmlReader.setFeature("http://xml.org/sax/features/validation", false);
this.bmkRef = new HashMap<String,HashMap<String,String>>(); this.bmkRef = new HashMap<String,YMarkEntry>();
this.aliasRef = new HashSet<HashMap<String,String>>(); this.aliasRef = new HashSet<YMarkEntry>();
this.buffer = new StringBuilder(); this.buffer = new StringBuilder();
this.folder = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE); this.folder = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folder.append(this.RootFolder); this.folder.append(this.RootFolder);
@ -139,7 +139,7 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
} finally { } finally {
try { try {
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "XBEL Importer inserted poison pill in queue"); Log.logInfo(YMarkTables.BOOKMARKS_LOG, "XBEL Importer inserted poison pill in queue");
this.bookmarks.put(YMarkTables.POISON); this.bookmarks.put(YMarkEntry.POISON);
} catch (InterruptedException e1) { } catch (InterruptedException e1) {
Log.logException(e1); Log.logException(e1);
} }
@ -159,27 +159,27 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
if (tag == null) return; if (tag == null) return;
tag = tag.toLowerCase(); tag = tag.toLowerCase();
if (XBEL.BOOKMARK.tag().equals(tag)) { if (XBEL.BOOKMARK.tag().equals(tag)) {
this.bmk = new HashMap<String,String>(); this.bmk = new YMarkEntry();
this.bmk.put(YMarkTables.BOOKMARK.URL.key(), atts.getValue(uri, YMarkTables.BOOKMARK.URL.xbel_attrb())); this.bmk.put(YMarkEntry.BOOKMARK.URL.key(), atts.getValue(uri, YMarkEntry.BOOKMARK.URL.xbel_attrb()));
try { try {
date.parseISO8601(atts.getValue(uri, YMarkTables.BOOKMARK.DATE_ADDED.xbel_attrb())); date.parseISO8601(atts.getValue(uri, YMarkEntry.BOOKMARK.DATE_ADDED.xbel_attrb()));
} catch (ParseException e) { } catch (ParseException e) {
// TODO: exception handling // TODO: exception handling
} }
this.bmk.put(YMarkTables.BOOKMARK.DATE_ADDED.key(), date.toString()); this.bmk.put(YMarkEntry.BOOKMARK.DATE_ADDED.key(), date.toString());
try { try {
date.parseISO8601(atts.getValue(uri, YMarkTables.BOOKMARK.DATE_VISITED.xbel_attrb())); date.parseISO8601(atts.getValue(uri, YMarkEntry.BOOKMARK.DATE_VISITED.xbel_attrb()));
} catch (ParseException e) { } catch (ParseException e) {
// TODO: exception handling // TODO: exception handling
} }
this.bmk.put(YMarkTables.BOOKMARK.DATE_VISITED.key(), date.toString()); this.bmk.put(YMarkEntry.BOOKMARK.DATE_VISITED.key(), date.toString());
try { try {
date.parseISO8601(atts.getValue(uri, YMarkTables.BOOKMARK.DATE_MODIFIED.xbel_attrb())); date.parseISO8601(atts.getValue(uri, YMarkEntry.BOOKMARK.DATE_MODIFIED.xbel_attrb()));
} catch (ParseException e) { } catch (ParseException e) {
// TODO: exception handling // TODO: exception handling
} }
this.bmk.put(YMarkTables.BOOKMARK.DATE_MODIFIED.key(), date.toString()); this.bmk.put(YMarkEntry.BOOKMARK.DATE_MODIFIED.key(), date.toString());
UpdateBmkRef(atts.getValue(uri, "id"), true); UpdateBmkRef(atts.getValue(uri, YMarkEntry.BOOKMARKS_ID), true);
outer_state = XBEL.BOOKMARK; outer_state = XBEL.BOOKMARK;
inner_state = XBEL.NOTHING; inner_state = XBEL.NOTHING;
this.parse_value = false; this.parse_value = false;
@ -200,7 +200,7 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
atts.getValue(uri, "owner"); atts.getValue(uri, "owner");
*/ */
} else if (XBEL.ALIAS.tag().equals(tag)) { } else if (XBEL.ALIAS.tag().equals(tag)) {
final String r = atts.getValue(uri, "ref"); final String r = atts.getValue(uri, YMarkEntry.BOOKMARKS_REF);
UpdateBmkRef(r, false); UpdateBmkRef(r, false);
this.aliasRef.add(this.bmkRef.get(r)); this.aliasRef.add(this.bmkRef.get(r));
} }
@ -217,10 +217,10 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
if(XBEL.BOOKMARK.tag().equals(tag)) { if(XBEL.BOOKMARK.tag().equals(tag)) {
// write bookmark // write bookmark
if (!this.bmk.isEmpty()) { if (!this.bmk.isEmpty()) {
this.bmk.put(YMarkTables.BOOKMARK.FOLDERS.key(), this.folder.toString()); this.bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(), this.folder.toString());
try { try {
this.bookmarks.put(this.bmk); this.bookmarks.put(this.bmk);
bmk = new HashMap<String,String>(); bmk = new YMarkEntry();
} catch (InterruptedException e) { } catch (InterruptedException e) {
Log.logException(e); Log.logException(e);
} }
@ -253,10 +253,10 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
case BOOKMARK: case BOOKMARK:
switch(inner_state) { switch(inner_state) {
case DESC: case DESC:
this.bmk.put(YMarkTables.BOOKMARK.DESC.key(), buffer.toString()); this.bmk.put(YMarkEntry.BOOKMARK.DESC.key(), buffer.toString());
break; break;
case TITLE: case TITLE:
this.bmk.put(YMarkTables.BOOKMARK.TITLE.key(), buffer.toString()); this.bmk.put(YMarkEntry.BOOKMARK.TITLE.key(), buffer.toString());
break; break;
case METADATA: case METADATA:
// TODO: handle xbel bookmark metadata // TODO: handle xbel bookmark metadata
@ -288,7 +288,7 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
} }
} }
public HashMap<String,String> take() { public YMarkEntry take() {
try { try {
return this.bookmarks.take(); return this.bookmarks.take();
} catch (InterruptedException e) { } catch (InterruptedException e) {
@ -301,16 +301,16 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
this.folderstring.setLength(0); this.folderstring.setLength(0);
if(this.bmkRef.containsKey(id)) { if(this.bmkRef.containsKey(id)) {
this.folderstring.append(this.bmkRef.get(id).get(YMarkTables.BOOKMARK.FOLDERS.key())); this.folderstring.append(this.bmkRef.get(id).get(YMarkEntry.BOOKMARK.FOLDERS.key()));
this.folderstring.append(','); this.folderstring.append(',');
this.ref = this.bmkRef.get(id); this.ref = this.bmkRef.get(id);
} else { } else {
this.ref = new HashMap<String,String>(); this.ref = new YMarkEntry();
} }
this.folderstring.append(this.folder); this.folderstring.append(this.folder);
if(url) if(url)
this.ref.put(YMarkTables.BOOKMARK.URL.key(), this.bmk.get(YMarkTables.BOOKMARK.URL.key())); this.ref.put(YMarkEntry.BOOKMARK.URL.key(), this.bmk.get(YMarkEntry.BOOKMARK.URL.key()));
this.ref.put(YMarkTables.BOOKMARK.FOLDERS.key(), this.folderstring.toString()); this.ref.put(YMarkEntry.BOOKMARK.FOLDERS.key(), this.folderstring.toString());
this.bmkRef.put(id, ref); this.bmkRef.put(id, ref);
} }
} }

Loading…
Cancel
Save