/*
* gnizr is a trademark of Image Matters LLC in the United States.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either expressed or implied. See the License
* for the specific language governing rights and limitations under the License.
*
* The Initial Contributor of the Original Code is Image Matters LLC.
* Portions created by the Initial Contributor are Copyright (C) 2007
* Image Matters LLC. All Rights Reserved.
*/
package com.gnizr.core.util;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HeaderElement;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.HeadMethod;
import com.gnizr.core.exceptions.MissingIdException;
import com.gnizr.core.exceptions.NoSuchBookmarkException;
import com.gnizr.core.exceptions.NoSuchLinkException;
import com.gnizr.core.exceptions.NoSuchLinkTagException;
import com.gnizr.core.exceptions.NoSuchTagAssertionException;
import com.gnizr.core.exceptions.NoSuchTagException;
import com.gnizr.core.exceptions.NoSuchTagPropertyException;
import com.gnizr.core.exceptions.NoSuchUserException;
import com.gnizr.core.exceptions.NoSuchUserTagException;
import com.gnizr.core.exceptions.ParseTagException;
import com.gnizr.core.folder.FolderManager;
import com.gnizr.core.vocab.TimeRange;
import com.gnizr.db.dao.Bookmark;
import com.gnizr.db.dao.ForUser;
import com.gnizr.db.dao.Link;
import com.gnizr.db.dao.LinkTag;
import com.gnizr.db.dao.Tag;
import com.gnizr.db.dao.TagAssertion;
import com.gnizr.db.dao.TagProperty;
import com.gnizr.db.dao.User;
import com.gnizr.db.dao.UserTag;
import com.gnizr.db.dao.bookmark.BookmarkDao;
import com.gnizr.db.dao.foruser.ForUserDao;
import com.gnizr.db.dao.link.LinkDao;
import com.gnizr.db.dao.tag.TagAssertionDao;
import com.gnizr.db.dao.tag.TagDao;
import com.gnizr.db.dao.tag.TagPropertyDao;
import com.gnizr.db.dao.user.UserDao;
import com.gnizr.db.vocab.MIMEType;
/**
* This class defines convenience methods for working gnizr data transport
* objects.
*
* @author Harry Chen
*
*/
public class GnizrDaoUtil {
/**
* Initializes <code>user.id</code> of the input <code>User</code>
* object. Based on the value of <code>user.getUsername()</code>, the
* method tries to find the <code>id</code> of the user. If
* <code>UserDao</code> can't find user of the given username, then an
* exception is thrown.
*
* @param userDao
* the DAO object of accessing user data records
* @param user
* a user object whose <code>id</code> value needs to be
* filled. The value of <code>user.getUsername()</code> must
* not be <code>null</code>.
* @throws NoSuchUserException
*/
public static void fillId(UserDao userDao, User user)
throws NoSuchUserException {
if (hasMissingId(user) == true) {
User obj = getUser(userDao, user.getUsername());
if (obj == null) {
throw new NoSuchUserException("no such user="
+ user.getUsername());
}
user.setId(obj.getId());
}
}
public static void fillId(LinkDao linkDao, Link link)
throws NoSuchLinkException {
if (hasMissingId(link) == true) {
Link obj = null;
if (link.getUrl() != null) {
obj = getLink(linkDao, link.getUrl());
} else if (link.getUrlHash() != null) {
obj = getLinkByUrlHash(linkDao, link.getUrlHash());
}
if (obj == null) {
throw new NoSuchLinkException("no such link=" + link.getUrl());
}
link.setId(obj.getId());
}
}
public static Link getLinkByUrlHash(LinkDao linkDao, String urlHash) {
if (urlHash == null) {
throw new NullPointerException("urlHash is NULL");
}
Link link = null;
List<Link> links = linkDao.findLinkByUrlHash(urlHash);
if (links.isEmpty() == false) {
link = links.get(0);
}
return link;
}
public static void fillId(BookmarkDao bmarkDao, UserDao userDao,
LinkDao linkDao, Bookmark bmark) throws NoSuchUserException,
NoSuchLinkException, MissingIdException, NoSuchBookmarkException {
if (hasMissingId(bmark) == true) {
User user = bmark.getUser();
if (hasMissingId(user) == true) {
fillId(userDao, user);
}
Link link = bmark.getLink();
if (hasMissingId(link) == true) {
fillId(linkDao, link);
}
Bookmark obj = getBookmark(bmarkDao, user, link);
if (obj == null) {
throw new NoSuchBookmarkException("no such bookmark: user="
+ user + ",link=" + link);
}
bmark.setId(obj.getId());
}
}
private static boolean hasMissingId(ForUser forUser) {
checkNull(forUser);
if (forUser.getId() > 0) {
return false;
}
return true;
}
public static void fillId(TagDao tagDao, UserDao userDao, UserTag userTag)
throws NoSuchUserException, NoSuchTagException,
NoSuchUserTagException, MissingIdException {
if (hasMissingId(userTag) == true) {
User user = userTag.getUser();
Tag tag = userTag.getTag();
fillId(userDao, user);
fillId(tagDao, tag);
UserTag obj = getUserTag(tagDao, user, tag);
if (obj == null) {
throw new NoSuchUserTagException("no such userTag: user="
+ user.getUsername() + ",tag=" + tag.getLabel());
}
userTag.setId(obj.getId());
}
}
public static void fillId(TagDao tagDao, LinkDao linkDao, LinkTag linkTag)
throws NoSuchLinkException, NoSuchTagException, MissingIdException,
NoSuchLinkTagException {
if (hasMissingId(linkTag) == true) {
Link link = linkTag.getLink();
Tag tag = linkTag.getTag();
fillId(linkDao, link);
fillId(tagDao, tag);
LinkTag obj = getLinkTag(tagDao, link, tag);
if (obj == null) {
throw new NoSuchLinkTagException("no such linkTag=" + linkTag);
}
linkTag.setId(obj.getId());
}
}
public static void fillId(TagDao tagDao, Tag tag) throws NoSuchTagException {
if (hasMissingId(tag) == true) {
Tag obj = getTag(tagDao, tag.getLabel());
if (obj == null) {
throw new NoSuchTagException("no such tag=" + tag);
}
tag.setId(obj.getId());
}
}
public static void fillId(TagPropertyDao tagPrptDao, TagProperty tagPrpt)
throws NoSuchTagPropertyException {
if (hasMissingId(tagPrpt) == true) {
TagProperty obj = null;
String name = tagPrpt.getName();
String ns = tagPrpt.getNamespacePrefix();
if (name != null && ns != null) {
obj = tagPrptDao.getTagProperty(ns, name);
}
if (obj == null) {
throw new NoSuchTagPropertyException("no such tagPrpt: ns="
+ ns + ",name=" + name);
}
tagPrpt.setId(obj.getId());
}
}
public static void fillId(TagAssertionDao tagAssertionDao,
TagPropertyDao tagPrptDao, TagDao tagDao, UserDao userDao,
TagAssertion assertion) throws NoSuchUserException,
NoSuchTagException, NoSuchUserTagException,
NoSuchTagPropertyException, NoSuchTagAssertionException,
MissingIdException {
if (hasMissingId(assertion)) {
User user = assertion.getUser();
UserTag subjTag = assertion.getSubject();
TagProperty prpt = assertion.getProperty();
UserTag objTag = assertion.getObject();
fillId(userDao, user);
fillId(tagDao, userDao, subjTag);
fillId(tagPrptDao, prpt);
fillId(tagDao, userDao, objTag);
TagAssertion obj = getTagAssertion(tagAssertionDao, user, subjTag,
prpt, objTag);
if (obj == null) {
throw new NoSuchTagAssertionException(
"no such tagAssertion: user=" + user + ",subjTag="
+ subjTag + ",prpt=" + prpt + ",objTag="
+ objTag);
}
assertion.setId(obj.getId());
}
}
public static boolean hasMissingId(User user) {
checkNull(user);
return (user.getId() <= 0);
}
public static boolean hasMissingId(Link link) {
checkNull(link);
return (link.getId() <= 0);
}
public static boolean hasMissingId(Bookmark bm) {
checkNull(bm);
return (bm.getId() <= 0);
}
public static boolean hasMissingId(Tag tag) {
checkNull(tag);
return (tag.getId() <= 0);
}
public static boolean hasMissingId(UserTag userTag) {
checkNull(userTag);
return (userTag.getId() <= 0);
}
public static boolean hasMissingId(LinkTag linkTag) {
checkNull(linkTag);
return (linkTag.getId() <= 0);
}
public static boolean hasMissingId(TagProperty tagPrpt) {
checkNull(tagPrpt);
return (tagPrpt.getId() <= 0);
}
public static boolean hasMissingId(TagAssertion tagAssertion) {
checkNull(tagAssertion);
return (tagAssertion.getId() <= 0);
}
public static User getUser(UserDao userDao, String username) {
if (username == null) {
throw new NullPointerException("username is NULL");
}
User user = null;
List<User> users = userDao.findUser(username);
if (users.isEmpty() == false) {
user = users.get(0);
}
return user;
}
public static Link getLink(LinkDao linkDao, String url) {
if (url == null) {
throw new NullPointerException("url is NULL");
}
Link link = null;
List<Link> links = linkDao.findLink(url);
if (links.isEmpty() == false) {
link = links.get(0);
}
return link;
}
public static Bookmark getBookmark(BookmarkDao bmarkDao, User user,
Link link) throws MissingIdException {
if (hasMissingId(user) == false && hasMissingId(link) == false) {
Bookmark bmark = null;
List<Bookmark> bmarks = bmarkDao.findBookmark(user, link);
if (bmarks.isEmpty() == false) {
bmark = bmarks.get(0);
}
return bmark;
}
throw new MissingIdException(
"either user or link object is missing a valid id");
}
public static Tag getTag(TagDao tagDao, String tag) {
if (tag == null) {
throw new NullPointerException("tag is NULL");
}
Tag aTag = null;
List<Tag> tags = tagDao.findTag(tag);
if (tags.isEmpty() == false) {
aTag = tags.get(0);
}
return aTag;
}
public static UserTag getUserTag(TagDao tagDao, User user, Tag tag)
throws MissingIdException {
if (hasMissingId(user) == false && hasMissingId(tag) == false) {
UserTag aTag = null;
List<UserTag> aTags = tagDao.findUserTag(user, tag);
if (aTags.isEmpty() == false) {
aTag = aTags.get(0);
}
return aTag;
}
throw new MissingIdException(
"either user or tag object is missing a valid id");
}
public static LinkTag getLinkTag(TagDao tagDao, Link link, Tag tag)
throws MissingIdException {
if (hasMissingId(link) == false && hasMissingId(tag) == false) {
LinkTag aTag = null;
List<LinkTag> aTags = tagDao.findLinkTag(link, tag);
if (aTags.isEmpty() == false) {
aTag = aTags.get(0);
}
return aTag;
}
throw new MissingIdException(
"either link or tag object is missing a valid id");
}
public static TagAssertion getTagAssertion(TagAssertionDao tagAssertionDao,
User user, UserTag subjTag, TagProperty tagPrpt, UserTag objTag)
throws MissingIdException {
if (hasMissingId(user) == true) {
throw new MissingIdException("user object is missing a valid id");
}
if (hasMissingId(subjTag) == true) {
throw new MissingIdException("subjectTag is missing a valid id");
}
if (hasMissingId(objTag) == true) {
throw new MissingIdException("objectTag is missing a valid id");
}
if (hasMissingId(tagPrpt) == true) {
throw new MissingIdException("tagProperty is missing a valid id");
}
TagAssertion asrt = null;
List<TagAssertion> asrts = tagAssertionDao.findTagAssertion(user,
subjTag, tagPrpt, objTag);
if (asrts.isEmpty() == false) {
asrt = asrts.get(0);
}
return asrt;
}
public static Integer detectMIMEType(String url) {
try {
HttpClient httpClient = new HttpClient();
HeadMethod method = new HeadMethod(url);
method.getParams().setIntParameter("http.socket.timeout",5000);
int code = httpClient.executeMethod(method);
if (code == 200) {
Header h = method.getResponseHeader("Content-Type");
if (h != null) {
HeaderElement[] headElm = h.getElements();
if(headElm != null & headElm.length > 0){
String mimeType = headElm[0].getValue();
if(mimeType == null){
mimeType = headElm[0].getName();
}
if (mimeType != null) {
return getMimeTypeIdCode(mimeType);
}
}
}
}
} catch (Exception e) {
// no code;
}
return MIMEType.UNKNOWN;
}
private static int getMimeTypeIdCode(String mimeType) {
if (mimeType.equals("text/xml")) {
return MIMEType.TEXT_XML;
} else if (mimeType.equals("text/plain")) {
return MIMEType.TEXT_PLAIN;
} else if (mimeType.equals("text/html")) {
return MIMEType.TEXT_HTML;
} else if (mimeType.equals("image/jpeg")) {
return MIMEType.IMG_JPEG;
} else if (mimeType.equals("image/png")) {
return MIMEType.IMG_PNG;
} else if (mimeType.equals("image/tiff")) {
return MIMEType.IMG_TIFF;
} else if (mimeType.equals("image/gif")) {
return MIMEType.IMG_GIF;
}else if(mimeType.equals("application/rss+xml")){
return MIMEType.APP_RSS_XML;
}else if(mimeType.equals("application/rdf+xml")){
return MIMEType.APP_RDF_XML;
}else if(mimeType.equals("application/owl+xml")){
return MIMEType.APP_OWL_XML;
}
return MIMEType.UNKNOWN;
}
public static Date getNow() {
return GregorianCalendar.getInstance().getTime();
}
public static void checkNull(User user) {
if (user == null) {
throw new NullPointerException("User is NULL");
}
}
public static void checkNull(Tag tag) {
if (tag == null) {
throw new NullPointerException("Tag is NULL");
}
}
public static void checkNull(Link link) {
if (link == null) {
throw new NullPointerException("Link is NULL");
}
}
public static void checkNull(Bookmark bmark) {
if (bmark == null) {
throw new NullPointerException("Bookmark is NULL");
}
}
public static void checkNull(UserTag userTag) {
if (userTag == null) {
throw new NullPointerException("UserTag is NULL");
}
}
public static void checkNull(LinkTag linkTag) {
if (linkTag == null) {
throw new NullPointerException("LinkTag is NULL");
}
}
public static void checkNull(TagProperty tagPrpt) {
if (tagPrpt == null) {
throw new NullPointerException("TagProperty is NULL");
}
}
public static void checkNull(TagAssertion assertion) {
if (assertion == null) {
throw new NullPointerException("TagAssertion is NULL");
}
}
public static void fillObject(TagDao tagDao, UserDao userDao,
UserTag userTag) throws NoSuchUserException, NoSuchTagException,
NoSuchUserTagException, MissingIdException {
if (hasMissingId(userTag) == true) {
fillId(tagDao, userDao, userTag);
}
UserTag ut = tagDao.getUserTag(userTag.getId());
Tag t = ut.getTag();
User u = ut.getUser();
fillObject(tagDao, t);
fillObject(userDao, u);
userTag.setTag(t);
userTag.setUser(u);
userTag.setCount(ut.getCount());
}
public static void fillObject(TagDao tagDao, LinkDao linkDao,
LinkTag linkTag) throws NoSuchLinkException, NoSuchTagException,
MissingIdException, NoSuchLinkTagException, NoSuchUserException {
if (hasMissingId(linkTag) == true) {
fillId(tagDao, linkDao, linkTag);
}
LinkTag obj = tagDao.getLinkTag(linkTag.getId());
Link l = obj.getLink();
Tag t = obj.getTag();
fillObject(linkDao, l);
fillObject(tagDao, t);
linkTag.setLink(l);
linkTag.setTag(t);
linkTag.setCount(obj.getCount());
}
public static void fillObject(TagDao tagDao, Tag tag)
throws NoSuchTagException {
fillId(tagDao, tag);
Tag t = tagDao.getTag(tag.getId());
tag.setLabel(t.getLabel());
tag.setCount(t.getCount());
}
/**
* Initializes all parameters of the input <code>user</code> object. Based
* on the value of <code>user.getId()</code>, this method finds a
* matching user data record and then sets the parameters of
* <code>user</code> with the parameter values of the user data record.
*
* @param userDao
* the DAO object used to find a matching user data record
* @param user
* a <code>User</code> with partially initialized parameter
* values. The value of <code>user.getId()</code> must return a
* valid ID number and must not be <code>null</code>.
* @throws NoSuchUserException
* thrown if no user data record exists for the input user ID.
*/
public static void fillObject(UserDao userDao, User user)
throws NoSuchUserException {
fillId(userDao, user);
User u = userDao.getUser(user.getId());
user.setFullname(u.getFullname());
user.setPassword(u.getPassword());
user.setUsername(u.getUsername());
user.setEmail(u.getEmail());
user.setCreatedOn(u.getCreatedOn());
user.setAccountStatus(u.getAccountStatus());
}
public static void fillObject(BookmarkDao bmarkDao, UserDao userDao,
LinkDao linkDao, Bookmark bmark) throws NoSuchUserException,
NoSuchLinkException, MissingIdException, NoSuchBookmarkException {
if (hasMissingId(bmark) == true) {
fillId(bmarkDao, userDao, linkDao, bmark);
}
Bookmark bm = bmarkDao.getBookmark(bmark.getId());
User u = bm.getUser();
Link l = bm.getLink();
fillObject(userDao, u);
fillObject(linkDao, l);
bmark.setLink(l);
bmark.setUser(u);
bmark.setNotes(bm.getNotes());
bmark.setTags(bm.getTags());
bmark.setTitle(bm.getTitle());
if (bm.getCreatedOn() != null) {
bmark.setCreatedOn((Date) bm.getCreatedOn().clone());
} else {
bmark.setCreatedOn(null);
}
if (bm.getLastUpdated() != null) {
bmark.setLastUpdated((Date) bm.getLastUpdated().clone());
} else {
bmark.setLastUpdated(null);
}
}
public static void fillObject(LinkDao linkDao, Link link)
throws NoSuchLinkException {
fillId(linkDao, link);
Link l = linkDao.getLink(link.getId());
if (l != null) {
link.setCount(l.getCount());
link.setMimeTypeId(l.getMimeTypeId());
link.setUrl(l.getUrl());
link.setUrlHash(l.getUrlHash());
}
}
public static void fillObject(TagPropertyDao tagPrptDao, TagProperty tagPrpt)
throws NoSuchTagPropertyException {
fillId(tagPrptDao, tagPrpt);
TagProperty p = tagPrptDao.getTagProperty(tagPrpt.getId());
tagPrpt.setName(p.getName());
tagPrpt.setDescription(p.getDescription());
tagPrpt.setNamespacePrefix(p.getNamespacePrefix());
tagPrpt.setPropertyType(p.getPropertyType());
tagPrpt.setCardinality(p.getCardinality());
}
public static void fillObject(TagAssertionDao tagAssertionDao,
TagPropertyDao tagPrptDao, TagDao tagDao, UserDao userDao,
TagAssertion assertion) throws NoSuchUserException,
NoSuchTagException, NoSuchUserTagException,
NoSuchTagPropertyException, NoSuchTagAssertionException,
MissingIdException {
if (hasMissingId(assertion) == true) {
fillId(tagAssertionDao, tagPrptDao, tagDao, userDao, assertion);
}
TagAssertion ta = tagAssertionDao.getTagAssertion(assertion.getId());
UserTag s = ta.getSubject();
TagProperty p = ta.getProperty();
UserTag o = ta.getObject();
User u = ta.getUser();
fillObject(tagDao, userDao, s);
fillObject(tagDao, userDao, o);
fillObject(tagPrptDao, p);
fillObject(userDao, u);
assertion.setUser(u);
assertion.setSubject(s);
assertion.setProperty(p);
assertion.setObject(o);
}
/**
* Creates a <code>Tag</code> data record for the input <code>tag</code>
* string. If a data record of the same <code>tag</code> string already
* exists in the database, then the ID of that data record is returned.
* Otherwise, returns the ID of the newly created <code>Tag</code> data
* record.
*
* @param tagDao
* the DAO object used for creating/fetching data record
* @param tag
* a tag string, which may be a prefixed tag string (e.g.,
* <code>gnizr:javaprogramming</code>) or a plain tag string
* (e.g., <code>javaprogramming</code>)
* @return the ID of the <code>Tag<code> data records
* @throws ParseTagException an exception is thrown if unable to parse
* the input <code>tag</code> string.
*
*/
public static int createTagIfNotExist(TagDao tagDao, String tag)
throws ParseTagException {
Tag tagObj = null;
String tagLabel = null;
if (TagUtil.isPrefixedUserTag(tag) == true) {
UserTag ut = TagUtil.parsePrefixedUserTag(tag);
if (ut != null) {
tagLabel = ut.getTag().getLabel();
} else {
throw new ParseTagException("unable to parse tag: " + tag);
}
} else {
tagLabel = tag;
}
List<Tag> tags = tagDao.findTag(tagLabel);
if (tags.isEmpty()) {
tagObj = new Tag(tagLabel);
int id = tagDao.createTag(tagObj);
tagObj.setId(id);
} else {
tagObj = tags.get(0);
}
return tagObj.getId();
}
public static final int createUserTagIfNotExist(TagDao tagDao,
UserDao userDao, String tag, User defaultUser)
throws ParseTagException, NoSuchUserException {
int userTagId = 0;
UserTag tagParsed = null;
if (TagUtil.isPrefixedUserTag(tag)) {
tagParsed = TagUtil.parsePrefixedUserTag(tag);
if (tagParsed == null) {
throw new ParseTagException("unable to parse tag: " + tag);
}
} else {
checkNull(defaultUser);
tagParsed = new UserTag(defaultUser.getUsername(), tag);
}
Tag tagObj = new Tag();
User userObj = new User();
// fills the id of the tag
int tagId = createTagIfNotExist(tagDao, tagParsed.getTag().getLabel());
tagObj.setId(tagId);
// fills the id of the user
userObj.setUsername(tagParsed.getUser().getUsername());
GnizrDaoUtil.fillId(userDao, userObj);
if (tagObj.getId() > 0 && userObj.getId() > 0) {
List<UserTag> ut = tagDao.findUserTag(userObj, tagObj);
if (ut.isEmpty()) {
userTagId = tagDao.createUserTag(new UserTag(userObj, tagObj));
} else {
UserTag userTag = ut.get(0);
userTagId = userTag.getId();
}
}
return userTagId;
}
public static void checkNull(ForUser forUser) {
if (forUser == null) {
throw new NullPointerException("forUser is NULL");
}
}
public static void fillObject(ForUserDao forUserDao,
BookmarkDao bookmarkDao, UserDao userDao, LinkDao linkDao,
ForUser forUser) throws MissingIdException, NoSuchUserException,
NoSuchLinkException, NoSuchBookmarkException {
if (hasMissingId(forUser) == true) {
throw new MissingIdException("missing forUser.getId()");
}
Bookmark bm = forUser.getBookmark();
fillObject(bookmarkDao, userDao, linkDao, bm);
User user = forUser.getForUser();
fillObject(userDao, user);
}
/**
* Returns a <code>Date</code> object that represents the beginning
* hour,min,second of a day (i.e., 00:00:00). The returned object shares the
* same year, month, day values as the input <code>date</code>
*
* @param date
* an instantiated date
* @return the beginning hour/min/sec of <code>date</code>
*/
public static Date toDayBegins(Date date) {
Calendar cal = GregorianCalendar.getInstance();
cal.setTime(date);
cal.set(Calendar.HOUR_OF_DAY, cal
.getActualMinimum(Calendar.HOUR_OF_DAY));
cal.set(Calendar.MINUTE, cal.getActualMinimum(Calendar.MINUTE));
cal.set(Calendar.SECOND, cal.getActualMinimum(Calendar.SECOND));
return cal.getTime();
}
/**
* Returns a <code>Date</code> object that represents the ending
* hour,min,second of a day (i.e., 23:59:59). The returned object shares the
* same year, month, day values as the input <code>date</code>
*
* @param date
* an instantiated date
* @return the ending hour/min/sec of <code>date</code>
*/
public static Date toDayEnds(Date date) {
Calendar cal = GregorianCalendar.getInstance();
cal.setTime(date);
cal.set(Calendar.HOUR_OF_DAY, cal
.getActualMaximum(Calendar.HOUR_OF_DAY));
cal.set(Calendar.MINUTE, cal.getActualMaximum(Calendar.MINUTE));
cal.set(Calendar.SECOND, cal.getActualMaximum(Calendar.SECOND));
return cal.getTime();
}
public static Date addNHours(Date date, int nHours) {
Calendar cal = GregorianCalendar.getInstance();
cal.setTime(date);
cal.add(Calendar.HOUR_OF_DAY, nHours);
return cal.getTime();
}
public static Date subNHours(Date date, int nHours) {
Calendar cal = GregorianCalendar.getInstance();
cal.setTime(date);
cal.add(Calendar.HOUR_OF_DAY, (nHours * -1));
return cal.getTime();
}
public static Date[] getTimeRangeDate(int timeRange) {
Date[] dates = new Date[2];
Date now = GnizrDaoUtil.getNow();
dates[0] = GnizrDaoUtil.toDayBegins(now);
dates[1] = GnizrDaoUtil.toDayEnds(now);
if (TimeRange.TODAY == timeRange) {
return dates;
} else if (TimeRange.YESTERDAY == timeRange) {
Calendar cal = Calendar.getInstance();
cal.setTime(dates[0]);
cal.add(Calendar.DAY_OF_MONTH, -1);
dates[0] = cal.getTime();
cal.setTime(dates[1]);
cal.add(Calendar.DAY_OF_MONTH, -1);
dates[1] = cal.getTime();
} else if (TimeRange.LAST_7_DAYS == timeRange) {
Calendar cal = Calendar.getInstance();
cal.setTime(dates[0]);
cal.add(Calendar.DAY_OF_MONTH, -6);
dates[0] = cal.getTime();
} else if (TimeRange.THIS_MONTH == timeRange) {
Calendar cal = Calendar.getInstance();
cal.setTime(dates[0]);
cal.set(Calendar.DAY_OF_MONTH, cal
.getActualMinimum(Calendar.DAY_OF_MONTH));
dates[0] = cal.getTime();
} else if (TimeRange.LAST_MONTH == timeRange) {
Calendar cal = Calendar.getInstance();
cal.setTime(dates[0]);
cal.add(Calendar.MONTH, -1);
cal.set(Calendar.DAY_OF_MONTH, cal
.getActualMinimum(Calendar.DAY_OF_MONTH));
dates[0] = cal.getTime();
cal.setTime(dates[1]);
cal.add(Calendar.MONTH, -1);
cal.set(Calendar.DAY_OF_MONTH, cal
.getActualMaximum(Calendar.DAY_OF_MONTH));
dates[1] = cal.getTime();
} else {
return null;
}
return dates;
}
public static boolean isUrlSafeString(String s){
if(s != null){
if(s.matches(".*[?/\\\\;'\"&+*^%]+.*")){
return false;
}
}else{
return false;
}
return true;
}
public static boolean isLegalFolderName(String s){
if(s == null || s.length() == 0){
return false;
}else{
if(isUrlSafeString(s) && !s.contains("_")){
return true;
}else if(s.equals(FolderManager.MY_BOOKMARKS_LABEL) ||
s.equals(FolderManager.IMPORTED_BOOKMARKS_LABEL)){
return true;
}
}
return false;
}
public static String encodeURI(String uri){
try {
return URLEncoder.encode(uri, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return null;
}
/**
* Returns a list of String objects that appear aList but don't appear
* in bList.
* @param aList
* @param bList
* @return objects in aList but not in bList
*/
public static List<String> diffList(List<String> aList, List<String> bList){
List<String> result = new ArrayList<String>();
for(String a : aList){
if(bList.contains(a) == false){
result.add(a);
}
}
return result;
}
public static String stripNonPrintableChar(String s){
if(s != null){
return s.replaceAll("[\\t\\n\\r\\f\\a\\e]+"," ");
}
return s;
}
/**
* Creates a <code>Map</code> view from a list of <code>Bookmark</code> objects. Map keys are
* created from <code>Bookmark.getId</code> and map values are object references to
* <code>bookmarks</code>. If multiple objects in <code>bookmarks</code> have the same <code>Bookmark.getId</code>
* value, only one of those objects will appear in the output <code>Map</code>.
*
* @param bookmarks objects with instantiated bookmark ID that will be used to create a <code>Map</code>
*
* @return a <code>Map</code> of ID (key) and <code>Bookmark</code> (value). This method will always return an instantiated
* <code>Map</code> object, even if <code>bookmarks</code> is <code>null</code>.
*/
public static Map<Integer,Bookmark> getBookmarksMap(List<Bookmark> bookmarks){
Map<Integer,Bookmark> map = new HashMap<Integer, Bookmark>();
if(bookmarks != null){
for(Bookmark b : bookmarks){
map.put(b.getId(),b);
}
}
return map;
}
public static String getRandomURI(){
StringBuffer sb = new StringBuffer("urn-x:gnizr:");
sb.append(UUID.randomUUID().toString());
return sb.toString();
}
}