|
|
|
@ -102,7 +102,7 @@ public class bookmarksDB {
|
|
|
|
|
|
|
|
|
|
|
|
// tags
|
|
|
|
// tags
|
|
|
|
kelondroMapObjects tagsTable;
|
|
|
|
kelondroMapObjects tagsTable;
|
|
|
|
HashMap tagCache;
|
|
|
|
HashMap<String, Tag> tagCache;
|
|
|
|
|
|
|
|
|
|
|
|
// dates
|
|
|
|
// dates
|
|
|
|
kelondroMapObjects datesTable;
|
|
|
|
kelondroMapObjects datesTable;
|
|
|
|
@ -114,7 +114,7 @@ public class bookmarksDB {
|
|
|
|
|
|
|
|
|
|
|
|
public bookmarksDB(File bookmarksFile, File tagsFile, File datesFile, long preloadTime) {
|
|
|
|
public bookmarksDB(File bookmarksFile, File tagsFile, File datesFile, long preloadTime) {
|
|
|
|
// bookmarks
|
|
|
|
// bookmarks
|
|
|
|
tagCache=new HashMap();
|
|
|
|
tagCache=new HashMap<String, Tag>();
|
|
|
|
bookmarkCache=new HashMap();
|
|
|
|
bookmarkCache=new HashMap();
|
|
|
|
bookmarksFile.getParentFile().mkdirs();
|
|
|
|
bookmarksFile.getParentFile().mkdirs();
|
|
|
|
//this.bookmarksTable = new kelondroMap(kelondroDyn.open(bookmarksFile, bufferkb * 1024, preloadTime, 12, 256, '_', true, false));
|
|
|
|
//this.bookmarksTable = new kelondroMap(kelondroDyn.open(bookmarksFile, bufferkb * 1024, preloadTime, 12, 256, '_', true, false));
|
|
|
|
@ -164,11 +164,11 @@ public class bookmarksDB {
|
|
|
|
|
|
|
|
|
|
|
|
Set<String> folders = new TreeSet<String>();
|
|
|
|
Set<String> folders = new TreeSet<String>();
|
|
|
|
String path = "";
|
|
|
|
String path = "";
|
|
|
|
Iterator it = this.getTagIterator(priv);
|
|
|
|
Iterator<Tag> it = this.getTagIterator(priv);
|
|
|
|
Tag tag;
|
|
|
|
Tag tag;
|
|
|
|
|
|
|
|
|
|
|
|
while(it.hasNext()){
|
|
|
|
while(it.hasNext()){
|
|
|
|
tag=(Tag) it.next();
|
|
|
|
tag=it.next();
|
|
|
|
if (tag.getFriendlyName().startsWith("/")) {
|
|
|
|
if (tag.getFriendlyName().startsWith("/")) {
|
|
|
|
path = tag.getFriendlyName();
|
|
|
|
path = tag.getFriendlyName();
|
|
|
|
path = cleanTagsString(path);
|
|
|
|
path = cleanTagsString(path);
|
|
|
|
@ -282,8 +282,8 @@ public class bookmarksDB {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getBookmarksIterator(boolean priv){
|
|
|
|
public Iterator<String> getBookmarksIterator(boolean priv){
|
|
|
|
TreeSet set=new TreeSet(new bookmarkComparator(true));
|
|
|
|
TreeSet<String> set=new TreeSet<String>(new bookmarkComparator(true));
|
|
|
|
Iterator it=bookmarkIterator(true);
|
|
|
|
Iterator it=bookmarkIterator(true);
|
|
|
|
Bookmark bm;
|
|
|
|
Bookmark bm;
|
|
|
|
while(it.hasNext()){
|
|
|
|
while(it.hasNext()){
|
|
|
|
@ -294,21 +294,21 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return set.iterator();
|
|
|
|
return set.iterator();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getBookmarksIterator(String tagName, boolean priv){
|
|
|
|
public Iterator<String> getBookmarksIterator(String tagName, boolean priv){
|
|
|
|
TreeSet set=new TreeSet(new bookmarkComparator(true));
|
|
|
|
TreeSet<String> set=new TreeSet<String>(new bookmarkComparator(true));
|
|
|
|
String tagHash=tagHash(tagName);
|
|
|
|
String tagHash=tagHash(tagName);
|
|
|
|
Tag tag=getTag(tagHash);
|
|
|
|
Tag tag=getTag(tagHash);
|
|
|
|
Set hashes=new HashSet();
|
|
|
|
Set<String> hashes=new HashSet<String>();
|
|
|
|
if(tag != null){
|
|
|
|
if(tag != null){
|
|
|
|
hashes=getTag(tagHash).getUrlHashes();
|
|
|
|
hashes=getTag(tagHash).getUrlHashes();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(priv){
|
|
|
|
if(priv){
|
|
|
|
set.addAll(hashes);
|
|
|
|
set.addAll(hashes);
|
|
|
|
}else{
|
|
|
|
}else{
|
|
|
|
Iterator it=hashes.iterator();
|
|
|
|
Iterator<String> it=hashes.iterator();
|
|
|
|
Bookmark bm;
|
|
|
|
Bookmark bm;
|
|
|
|
while(it.hasNext()){
|
|
|
|
while(it.hasNext()){
|
|
|
|
bm=getBookmark((String) it.next());
|
|
|
|
bm=getBookmark(it.next());
|
|
|
|
if(bm.getPublic()){
|
|
|
|
if(bm.getPublic()){
|
|
|
|
set.add(bm.getUrlHash());
|
|
|
|
set.add(bm.getUrlHash());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -335,7 +335,7 @@ public class bookmarksDB {
|
|
|
|
* @param hash an object of type String, containing a tagHash
|
|
|
|
* @param hash an object of type String, containing a tagHash
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
public Tag loadTag(String hash){ // TODO: check if loadTag() could be private
|
|
|
|
public Tag loadTag(String hash){ // TODO: check if loadTag() could be private
|
|
|
|
Map map;
|
|
|
|
HashMap<String, String> map;
|
|
|
|
Tag ret=null;
|
|
|
|
Tag ret=null;
|
|
|
|
map = tagsTable.getMap(hash);
|
|
|
|
map = tagsTable.getMap(hash);
|
|
|
|
if(map!=null){
|
|
|
|
if(map!=null){
|
|
|
|
@ -350,7 +350,7 @@ public class bookmarksDB {
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
public Tag getTag(String hash){
|
|
|
|
public Tag getTag(String hash){
|
|
|
|
if(tagCache.containsKey(hash)){
|
|
|
|
if(tagCache.containsKey(hash)){
|
|
|
|
return (Tag) tagCache.get(hash);
|
|
|
|
return tagCache.get(hash);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return loadTag(hash); //null if it does not exists
|
|
|
|
return loadTag(hash); //null if it does not exists
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -377,11 +377,11 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void flushTagCache(){
|
|
|
|
public void flushTagCache(){
|
|
|
|
Iterator it=tagCache.keySet().iterator();
|
|
|
|
Iterator<String> it=tagCache.keySet().iterator();
|
|
|
|
while(it.hasNext()){
|
|
|
|
while(it.hasNext()){
|
|
|
|
storeTag((Tag) tagCache.get(it.next()));
|
|
|
|
storeTag(tagCache.get(it.next()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tagCache=new HashMap();
|
|
|
|
tagCache=new HashMap<String, Tag>();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public String addTag(Tag tag){ // TODO: is addTag() really needed - check storeTag() and saveTag()
|
|
|
|
public String addTag(Tag tag){ // TODO: is addTag() really needed - check storeTag() and saveTag()
|
|
|
|
//tagsTable.set(tag.getTagName(), tag.getMap());
|
|
|
|
//tagsTable.set(tag.getTagName(), tag.getMap());
|
|
|
|
@ -404,14 +404,14 @@ public class bookmarksDB {
|
|
|
|
return new HashSet().iterator();
|
|
|
|
return new HashSet().iterator();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getTagIterator(boolean priv){
|
|
|
|
public Iterator<Tag> getTagIterator(boolean priv){
|
|
|
|
return getTagIterator(priv,1);
|
|
|
|
return getTagIterator(priv,1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getTagIterator(boolean priv, int c){
|
|
|
|
public Iterator<Tag> getTagIterator(boolean priv, int c){
|
|
|
|
Comparator comp;
|
|
|
|
Comparator comp;
|
|
|
|
if (c == SORT_SIZE) comp = new tagSizeComparator();
|
|
|
|
if (c == SORT_SIZE) comp = new tagSizeComparator();
|
|
|
|
else comp = new tagComparator();
|
|
|
|
else comp = new tagComparator();
|
|
|
|
TreeSet set=new TreeSet(comp);
|
|
|
|
TreeSet<Tag> set=new TreeSet<Tag>(comp);
|
|
|
|
Iterator it=tagIterator(true);
|
|
|
|
Iterator it=tagIterator(true);
|
|
|
|
Tag tag;
|
|
|
|
Tag tag;
|
|
|
|
while(it.hasNext()){
|
|
|
|
while(it.hasNext()){
|
|
|
|
@ -422,11 +422,11 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return set.iterator();
|
|
|
|
return set.iterator();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getTagIterator(boolean priv, int comp, int max){
|
|
|
|
public Iterator<Tag> getTagIterator(boolean priv, int comp, int max){
|
|
|
|
if (max==SHOW_ALL)
|
|
|
|
if (max==SHOW_ALL)
|
|
|
|
return getTagIterator(priv, comp);
|
|
|
|
return getTagIterator(priv, comp);
|
|
|
|
Iterator it = getTagIterator(priv, comp);
|
|
|
|
Iterator<Tag> it = getTagIterator(priv, comp);
|
|
|
|
TreeSet set=new TreeSet(new tagComparator());
|
|
|
|
TreeSet<Tag> set=new TreeSet<Tag>(new tagComparator());
|
|
|
|
int count = 0;
|
|
|
|
int count = 0;
|
|
|
|
while (it.hasNext() && count<=max) {
|
|
|
|
while (it.hasNext() && count<=max) {
|
|
|
|
set.add(it.next());
|
|
|
|
set.add(it.next());
|
|
|
|
@ -434,25 +434,25 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return set.iterator();
|
|
|
|
return set.iterator();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getTagIterator(String tagName, boolean priv){
|
|
|
|
public Iterator<Tag> getTagIterator(String tagName, boolean priv){
|
|
|
|
return getTagIterator(tagName, priv, 1);
|
|
|
|
return getTagIterator(tagName, priv, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getTagIterator(String tagName, boolean priv, int comp){
|
|
|
|
public Iterator<Tag> getTagIterator(String tagName, boolean priv, int comp){
|
|
|
|
Comparator c;
|
|
|
|
Comparator c;
|
|
|
|
if (comp == SORT_SIZE) c = new tagSizeComparator();
|
|
|
|
if (comp == SORT_SIZE) c = new tagSizeComparator();
|
|
|
|
else c = new tagComparator();
|
|
|
|
else c = new tagComparator();
|
|
|
|
TreeSet set=new TreeSet(c);
|
|
|
|
TreeSet<Tag> set=new TreeSet<Tag>(c);
|
|
|
|
Iterator it=null;
|
|
|
|
Iterator<String> it=null;
|
|
|
|
Iterator bit=getBookmarksIterator(tagName, priv);
|
|
|
|
Iterator<String> bit=getBookmarksIterator(tagName, priv);
|
|
|
|
Bookmark bm;
|
|
|
|
Bookmark bm;
|
|
|
|
Tag tag;
|
|
|
|
Tag tag;
|
|
|
|
Set<String> tags;
|
|
|
|
Set<String> tags;
|
|
|
|
while(bit.hasNext()){
|
|
|
|
while(bit.hasNext()){
|
|
|
|
bm=getBookmark((String)bit.next());
|
|
|
|
bm=getBookmark(bit.next());
|
|
|
|
tags = bm.getTags();
|
|
|
|
tags = bm.getTags();
|
|
|
|
it = tags.iterator();
|
|
|
|
it = tags.iterator();
|
|
|
|
while (it.hasNext()) {
|
|
|
|
while (it.hasNext()) {
|
|
|
|
tag=getTag( tagHash((String) it.next()) );
|
|
|
|
tag=getTag( tagHash(it.next()) );
|
|
|
|
if(priv ||tag.hasPublicItems()){
|
|
|
|
if(priv ||tag.hasPublicItems()){
|
|
|
|
set.add(tag);
|
|
|
|
set.add(tag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -460,11 +460,11 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return set.iterator();
|
|
|
|
return set.iterator();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Iterator getTagIterator(String tagName, boolean priv, int comp, int max){
|
|
|
|
public Iterator<Tag> getTagIterator(String tagName, boolean priv, int comp, int max){
|
|
|
|
if (max==SHOW_ALL)
|
|
|
|
if (max==SHOW_ALL)
|
|
|
|
return getTagIterator(priv, comp);
|
|
|
|
return getTagIterator(priv, comp);
|
|
|
|
Iterator it = getTagIterator(tagName, priv, comp);
|
|
|
|
Iterator<Tag> it = getTagIterator(tagName, priv, comp);
|
|
|
|
TreeSet set=new TreeSet(new tagComparator());
|
|
|
|
TreeSet<Tag> set=new TreeSet<Tag>(new tagComparator());
|
|
|
|
int count = 0;
|
|
|
|
int count = 0;
|
|
|
|
while (it.hasNext() && count<=max) {
|
|
|
|
while (it.hasNext() && count<=max) {
|
|
|
|
set.add(it.next());
|
|
|
|
set.add(it.next());
|
|
|
|
@ -502,7 +502,7 @@ public class bookmarksDB {
|
|
|
|
// ---------------------------------------
|
|
|
|
// ---------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
public bookmarksDate getDate(String date){
|
|
|
|
public bookmarksDate getDate(String date){
|
|
|
|
Map map;
|
|
|
|
HashMap<String, String> map;
|
|
|
|
map=datesTable.getMap(date);
|
|
|
|
map=datesTable.getMap(date);
|
|
|
|
if(map==null) return new bookmarksDate(date);
|
|
|
|
if(map==null) return new bookmarksDate(date);
|
|
|
|
return new bookmarksDate(date, map);
|
|
|
|
return new bookmarksDate(date, map);
|
|
|
|
@ -541,7 +541,7 @@ public class bookmarksDB {
|
|
|
|
removeTag(oldHash);
|
|
|
|
removeTag(oldHash);
|
|
|
|
Iterator it = urlHashes.iterator();
|
|
|
|
Iterator it = urlHashes.iterator();
|
|
|
|
Bookmark bookmark;
|
|
|
|
Bookmark bookmark;
|
|
|
|
Set tags = new HashSet();
|
|
|
|
Set<String> tags = new HashSet<String>();
|
|
|
|
String tagsString;
|
|
|
|
String tagsString;
|
|
|
|
while (it.hasNext()) { // looping through all bookmarks which were tagged with oldName
|
|
|
|
while (it.hasNext()) { // looping through all bookmarks which were tagged with oldName
|
|
|
|
bookmark = getBookmark((String) it.next());
|
|
|
|
bookmark = getBookmark((String) it.next());
|
|
|
|
@ -588,7 +588,7 @@ public class bookmarksDB {
|
|
|
|
String title;
|
|
|
|
String title;
|
|
|
|
yacyURL url;
|
|
|
|
yacyURL url;
|
|
|
|
Bookmark bm;
|
|
|
|
Bookmark bm;
|
|
|
|
Set tags=listManager.string2set(tag); //this allow multiple default tags
|
|
|
|
Set<String> tags=listManager.string2set(tag); //this allow multiple default tags
|
|
|
|
try {
|
|
|
|
try {
|
|
|
|
//load the links
|
|
|
|
//load the links
|
|
|
|
htmlFilterContentScraper scraper = new htmlFilterContentScraper(baseURL);
|
|
|
|
htmlFilterContentScraper scraper = new htmlFilterContentScraper(baseURL);
|
|
|
|
@ -672,7 +672,7 @@ public class bookmarksDB {
|
|
|
|
if(attributes.getNamedItem("time")!=null){
|
|
|
|
if(attributes.getNamedItem("time")!=null){
|
|
|
|
time=attributes.getNamedItem("time").getNodeValue();
|
|
|
|
time=attributes.getNamedItem("time").getNodeValue();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Set tags=new HashSet();
|
|
|
|
Set<String> tags=new HashSet<String>();
|
|
|
|
|
|
|
|
|
|
|
|
if(title != null){
|
|
|
|
if(title != null){
|
|
|
|
bm.setProperty(Bookmark.BOOKMARK_TITLE, title);
|
|
|
|
bm.setProperty(Bookmark.BOOKMARK_TITLE, title);
|
|
|
|
@ -721,32 +721,32 @@ public class bookmarksDB {
|
|
|
|
public static final String URL_HASHES="urlHashes";
|
|
|
|
public static final String URL_HASHES="urlHashes";
|
|
|
|
public static final String TAG_NAME="tagName";
|
|
|
|
public static final String TAG_NAME="tagName";
|
|
|
|
private String tagHash;
|
|
|
|
private String tagHash;
|
|
|
|
private Map mem;
|
|
|
|
private HashMap<String, String> mem;
|
|
|
|
private Set<String> urlHashes;
|
|
|
|
private Set<String> urlHashes;
|
|
|
|
|
|
|
|
|
|
|
|
public Tag(String hash, Map map){
|
|
|
|
public Tag(String hash, HashMap<String, String> map){
|
|
|
|
tagHash=hash;
|
|
|
|
tagHash=hash;
|
|
|
|
mem=map;
|
|
|
|
mem=map;
|
|
|
|
if(mem.containsKey(URL_HASHES))
|
|
|
|
if(mem.containsKey(URL_HASHES))
|
|
|
|
urlHashes = listManager.string2set((String) mem.get(URL_HASHES));
|
|
|
|
urlHashes = listManager.string2set(mem.get(URL_HASHES));
|
|
|
|
else
|
|
|
|
else
|
|
|
|
urlHashes = new HashSet();
|
|
|
|
urlHashes = new HashSet<String>();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Tag(String name, HashSet entries){
|
|
|
|
public Tag(String name, HashSet<String> entries){
|
|
|
|
tagHash=tagHash(name);
|
|
|
|
tagHash=tagHash(name);
|
|
|
|
mem=new HashMap();
|
|
|
|
mem=new HashMap<String, String>();
|
|
|
|
//mem.put(URL_HASHES, listManager.arraylist2string(entries));
|
|
|
|
//mem.put(URL_HASHES, listManager.arraylist2string(entries));
|
|
|
|
urlHashes=entries;
|
|
|
|
urlHashes=entries;
|
|
|
|
mem.put(TAG_NAME, name);
|
|
|
|
mem.put(TAG_NAME, name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Tag(String name){
|
|
|
|
public Tag(String name){
|
|
|
|
tagHash=tagHash(name);
|
|
|
|
tagHash=tagHash(name);
|
|
|
|
mem=new HashMap();
|
|
|
|
mem=new HashMap<String, String>();
|
|
|
|
//mem.put(URL_HASHES, "");
|
|
|
|
//mem.put(URL_HASHES, "");
|
|
|
|
urlHashes=new HashSet();
|
|
|
|
urlHashes=new HashSet<String>();
|
|
|
|
mem.put(TAG_NAME, name);
|
|
|
|
mem.put(TAG_NAME, name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Map getMap(){
|
|
|
|
public HashMap<String, String> getMap(){
|
|
|
|
mem.put(URL_HASHES, listManager.collection2string(this.urlHashes));
|
|
|
|
mem.put(URL_HASHES, listManager.collection2string(this.urlHashes));
|
|
|
|
return mem;
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -772,7 +772,7 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return getTagName();*/
|
|
|
|
return getTagName();*/
|
|
|
|
if(this.mem.containsKey(TAG_NAME)){
|
|
|
|
if(this.mem.containsKey(TAG_NAME)){
|
|
|
|
return (String) this.mem.get(TAG_NAME);
|
|
|
|
return this.mem.get(TAG_NAME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "notagname";
|
|
|
|
return "notagname";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -780,7 +780,7 @@ public class bookmarksDB {
|
|
|
|
return urlHashes;
|
|
|
|
return urlHashes;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public boolean hasPublicItems(){
|
|
|
|
public boolean hasPublicItems(){
|
|
|
|
Iterator it=getBookmarksIterator(this.getTagHash(), false);
|
|
|
|
Iterator<String> it=getBookmarksIterator(this.getTagHash(), false);
|
|
|
|
if(it.hasNext()){
|
|
|
|
if(it.hasNext()){
|
|
|
|
return true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -801,34 +801,34 @@ public class bookmarksDB {
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
public class bookmarksDate{
|
|
|
|
public class bookmarksDate{
|
|
|
|
public static final String URL_HASHES="urlHashes";
|
|
|
|
public static final String URL_HASHES="urlHashes";
|
|
|
|
private Map mem;
|
|
|
|
private HashMap<String, String> mem;
|
|
|
|
String date;
|
|
|
|
String date;
|
|
|
|
|
|
|
|
|
|
|
|
public bookmarksDate(String mydate){
|
|
|
|
public bookmarksDate(String mydate){
|
|
|
|
//round to seconds, but store as milliseconds (java timestamp)
|
|
|
|
//round to seconds, but store as milliseconds (java timestamp)
|
|
|
|
date=String.valueOf((Long.parseLong(mydate)/1000)*1000);
|
|
|
|
date=String.valueOf((Long.parseLong(mydate)/1000)*1000);
|
|
|
|
mem=new HashMap();
|
|
|
|
mem=new HashMap<String, String>();
|
|
|
|
mem.put(URL_HASHES, "");
|
|
|
|
mem.put(URL_HASHES, "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public bookmarksDate(String mydate, Map map){
|
|
|
|
public bookmarksDate(String mydate, HashMap<String, String> map){
|
|
|
|
//round to seconds, but store as milliseconds (java timestamp)
|
|
|
|
//round to seconds, but store as milliseconds (java timestamp)
|
|
|
|
date=String.valueOf((Long.parseLong(mydate)/1000)*1000);
|
|
|
|
date=String.valueOf((Long.parseLong(mydate)/1000)*1000);
|
|
|
|
mem=map;
|
|
|
|
mem=map;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public bookmarksDate(String mydate, ArrayList entries){
|
|
|
|
public bookmarksDate(String mydate, ArrayList<String> entries){
|
|
|
|
//round to seconds, but store as milliseconds (java timestamp)
|
|
|
|
//round to seconds, but store as milliseconds (java timestamp)
|
|
|
|
date=String.valueOf((Long.parseLong(mydate)/1000)*1000);
|
|
|
|
date=String.valueOf((Long.parseLong(mydate)/1000)*1000);
|
|
|
|
mem=new HashMap();
|
|
|
|
mem=new HashMap<String, String>();
|
|
|
|
mem.put(URL_HASHES, listManager.collection2string(entries));
|
|
|
|
mem.put(URL_HASHES, listManager.collection2string(entries));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void add(String urlHash){
|
|
|
|
public void add(String urlHash){
|
|
|
|
String urlHashes = (String)mem.get(URL_HASHES);
|
|
|
|
String urlHashes = mem.get(URL_HASHES);
|
|
|
|
ArrayList list;
|
|
|
|
ArrayList<String> list;
|
|
|
|
if(urlHashes != null && !urlHashes.equals("")){
|
|
|
|
if(urlHashes != null && !urlHashes.equals("")){
|
|
|
|
list=listManager.string2arraylist(urlHashes);
|
|
|
|
list=listManager.string2arraylist(urlHashes);
|
|
|
|
}else{
|
|
|
|
}else{
|
|
|
|
list=new ArrayList();
|
|
|
|
list=new ArrayList<String>();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!list.contains(urlHash) && urlHash != null && !urlHash.equals("")){
|
|
|
|
if(!list.contains(urlHash) && urlHash != null && !urlHash.equals("")){
|
|
|
|
list.add(urlHash);
|
|
|
|
list.add(urlHash);
|
|
|
|
@ -843,7 +843,7 @@ public class bookmarksDB {
|
|
|
|
}*/
|
|
|
|
}*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void delete(String urlHash){
|
|
|
|
public void delete(String urlHash){
|
|
|
|
ArrayList list=listManager.string2arraylist((String) this.mem.get(URL_HASHES));
|
|
|
|
ArrayList<String> list=listManager.string2arraylist(this.mem.get(URL_HASHES));
|
|
|
|
if(list.contains(urlHash)){
|
|
|
|
if(list.contains(urlHash)){
|
|
|
|
list.remove(urlHash);
|
|
|
|
list.remove(urlHash);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -862,10 +862,10 @@ public class bookmarksDB {
|
|
|
|
return date;
|
|
|
|
return date;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public ArrayList getBookmarkList(){
|
|
|
|
public ArrayList getBookmarkList(){
|
|
|
|
return listManager.string2arraylist((String)this.mem.get(URL_HASHES));
|
|
|
|
return listManager.string2arraylist(this.mem.get(URL_HASHES));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public int size(){
|
|
|
|
public int size(){
|
|
|
|
return listManager.string2arraylist(((String)this.mem.get(URL_HASHES))).size();
|
|
|
|
return listManager.string2arraylist(this.mem.get(URL_HASHES)).size();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
/**
|
|
|
|
@ -883,13 +883,13 @@ public class bookmarksDB {
|
|
|
|
private String urlHash;
|
|
|
|
private String urlHash;
|
|
|
|
private Set<String> tags;
|
|
|
|
private Set<String> tags;
|
|
|
|
private long timestamp;
|
|
|
|
private long timestamp;
|
|
|
|
public Bookmark(String urlHash, Map map){
|
|
|
|
public Bookmark(String urlHash, HashMap map){
|
|
|
|
super(map);
|
|
|
|
super(map);
|
|
|
|
this.urlHash=urlHash;
|
|
|
|
this.urlHash=urlHash;
|
|
|
|
if(map.containsKey(BOOKMARK_TAGS))
|
|
|
|
if(map.containsKey(BOOKMARK_TAGS))
|
|
|
|
tags=listManager.string2set((String) map.get(BOOKMARK_TAGS));
|
|
|
|
tags=listManager.string2set((String) map.get(BOOKMARK_TAGS));
|
|
|
|
else
|
|
|
|
else
|
|
|
|
tags=new HashSet();
|
|
|
|
tags=new HashSet<String>();
|
|
|
|
loadTimestamp();
|
|
|
|
loadTimestamp();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Bookmark(String url){
|
|
|
|
public Bookmark(String url){
|
|
|
|
@ -904,14 +904,14 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
entry.put(BOOKMARK_URL, url);
|
|
|
|
entry.put(BOOKMARK_URL, url);
|
|
|
|
this.timestamp=System.currentTimeMillis();
|
|
|
|
this.timestamp=System.currentTimeMillis();
|
|
|
|
tags=new HashSet();
|
|
|
|
tags=new HashSet<String>();
|
|
|
|
Bookmark oldBm=getBookmark(this.urlHash);
|
|
|
|
Bookmark oldBm=getBookmark(this.urlHash);
|
|
|
|
if(oldBm!=null && oldBm.entry.containsKey(BOOKMARK_TIMESTAMP)){
|
|
|
|
if(oldBm!=null && oldBm.entry.containsKey(BOOKMARK_TIMESTAMP)){
|
|
|
|
entry.put(BOOKMARK_TIMESTAMP, oldBm.entry.get(BOOKMARK_TIMESTAMP)); //preserve timestamp on edit
|
|
|
|
entry.put(BOOKMARK_TIMESTAMP, oldBm.entry.get(BOOKMARK_TIMESTAMP)); //preserve timestamp on edit
|
|
|
|
}else{
|
|
|
|
}else{
|
|
|
|
entry.put(BOOKMARK_TIMESTAMP, String.valueOf(System.currentTimeMillis()));
|
|
|
|
entry.put(BOOKMARK_TIMESTAMP, String.valueOf(System.currentTimeMillis()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bookmarksDate bmDate=getDate((String) entry.get(BOOKMARK_TIMESTAMP));
|
|
|
|
bookmarksDate bmDate=getDate(entry.get(BOOKMARK_TIMESTAMP));
|
|
|
|
bmDate.add(this.urlHash);
|
|
|
|
bmDate.add(this.urlHash);
|
|
|
|
bmDate.setDatesTable();
|
|
|
|
bmDate.setDatesTable();
|
|
|
|
|
|
|
|
|
|
|
|
@ -921,14 +921,14 @@ public class bookmarksDB {
|
|
|
|
super();
|
|
|
|
super();
|
|
|
|
this.urlHash=urlHash;
|
|
|
|
this.urlHash=urlHash;
|
|
|
|
entry.put(BOOKMARK_URL, url.toNormalform(false, true));
|
|
|
|
entry.put(BOOKMARK_URL, url.toNormalform(false, true));
|
|
|
|
tags=new HashSet();
|
|
|
|
tags=new HashSet<String>();
|
|
|
|
timestamp=System.currentTimeMillis();
|
|
|
|
timestamp=System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Bookmark(String urlHash, String url){
|
|
|
|
public Bookmark(String urlHash, String url){
|
|
|
|
super();
|
|
|
|
super();
|
|
|
|
this.urlHash=urlHash;
|
|
|
|
this.urlHash=urlHash;
|
|
|
|
entry.put(BOOKMARK_URL, url);
|
|
|
|
entry.put(BOOKMARK_URL, url);
|
|
|
|
tags=new HashSet();
|
|
|
|
tags=new HashSet<String>();
|
|
|
|
timestamp=System.currentTimeMillis();
|
|
|
|
timestamp=System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -936,20 +936,20 @@ public class bookmarksDB {
|
|
|
|
this((new yacyURL((String)map.map().get(BOOKMARK_URL), null)).hash(), map.map());
|
|
|
|
this((new yacyURL((String)map.map().get(BOOKMARK_URL), null)).hash(), map.map());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private Map toMap(){
|
|
|
|
private Map<String, String> toMap(){
|
|
|
|
entry.put(BOOKMARK_TAGS, listManager.collection2string(tags));
|
|
|
|
entry.put(BOOKMARK_TAGS, listManager.collection2string(tags));
|
|
|
|
entry.put(BOOKMARK_TIMESTAMP, String.valueOf(this.timestamp));
|
|
|
|
entry.put(BOOKMARK_TIMESTAMP, String.valueOf(this.timestamp));
|
|
|
|
return entry;
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void loadTimestamp(){
|
|
|
|
private void loadTimestamp(){
|
|
|
|
if(entry.containsKey(BOOKMARK_TIMESTAMP))
|
|
|
|
if(entry.containsKey(BOOKMARK_TIMESTAMP))
|
|
|
|
this.timestamp=Long.parseLong((String)entry.get(BOOKMARK_TIMESTAMP));
|
|
|
|
this.timestamp=Long.parseLong(entry.get(BOOKMARK_TIMESTAMP));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public String getUrlHash(){
|
|
|
|
public String getUrlHash(){
|
|
|
|
return urlHash;
|
|
|
|
return urlHash;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public String getUrl(){
|
|
|
|
public String getUrl(){
|
|
|
|
return (String) entry.get(BOOKMARK_URL);
|
|
|
|
return entry.get(BOOKMARK_URL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public Set<String> getTags(){
|
|
|
|
public Set<String> getTags(){
|
|
|
|
return tags;
|
|
|
|
return tags;
|
|
|
|
@ -976,19 +976,19 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public String getDescription(){
|
|
|
|
public String getDescription(){
|
|
|
|
if(entry.containsKey(BOOKMARK_DESCRIPTION)){
|
|
|
|
if(entry.containsKey(BOOKMARK_DESCRIPTION)){
|
|
|
|
return (String) entry.get(BOOKMARK_DESCRIPTION);
|
|
|
|
return entry.get(BOOKMARK_DESCRIPTION);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public String getTitle(){
|
|
|
|
public String getTitle(){
|
|
|
|
if(entry.containsKey(BOOKMARK_TITLE)){
|
|
|
|
if(entry.containsKey(BOOKMARK_TITLE)){
|
|
|
|
return (String) entry.get(BOOKMARK_TITLE);
|
|
|
|
return entry.get(BOOKMARK_TITLE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (String) entry.get(BOOKMARK_URL);
|
|
|
|
return entry.get(BOOKMARK_URL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public String getOwner(){
|
|
|
|
public String getOwner(){
|
|
|
|
if(entry.containsKey(BOOKMARK_OWNER)){
|
|
|
|
if(entry.containsKey(BOOKMARK_OWNER)){
|
|
|
|
return (String) entry.get(BOOKMARK_OWNER);
|
|
|
|
return entry.get(BOOKMARK_OWNER);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null; //null means admin
|
|
|
|
return null; //null means admin
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -997,13 +997,13 @@ public class bookmarksDB {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public boolean getPublic(){
|
|
|
|
public boolean getPublic(){
|
|
|
|
if(entry.containsKey(BOOKMARK_PUBLIC)){
|
|
|
|
if(entry.containsKey(BOOKMARK_PUBLIC)){
|
|
|
|
return ((String) entry.get(BOOKMARK_PUBLIC)).equals("public");
|
|
|
|
return entry.get(BOOKMARK_PUBLIC).equals("public");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public boolean getFeed(){
|
|
|
|
public boolean getFeed(){
|
|
|
|
if(entry.containsKey(BOOKMARK_IS_FEED)){
|
|
|
|
if(entry.containsKey(BOOKMARK_IS_FEED)){
|
|
|
|
return ((String) entry.get(BOOKMARK_IS_FEED)).equals("true");
|
|
|
|
return entry.get(BOOKMARK_IS_FEED).equals("true");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1045,7 +1045,7 @@ public class bookmarksDB {
|
|
|
|
// tags.addAll(tags2); // in order for renameTag() to work I had to change this form 'add' to 'set'
|
|
|
|
// tags.addAll(tags2); // in order for renameTag() to work I had to change this form 'add' to 'set'
|
|
|
|
Iterator<String> it=tags.iterator();
|
|
|
|
Iterator<String> it=tags.iterator();
|
|
|
|
while(it.hasNext()){
|
|
|
|
while(it.hasNext()){
|
|
|
|
String tagName=(String) it.next();
|
|
|
|
String tagName=it.next();
|
|
|
|
Tag tag=getTag(tagHash(tagName));
|
|
|
|
Tag tag=getTag(tagHash(tagName));
|
|
|
|
if(tag == null){
|
|
|
|
if(tag == null){
|
|
|
|
tag=new Tag(tagName);
|
|
|
|
tag=new Tag(tagName);
|
|
|
|
|
orbiter
17 years ago