/** @inheritDoc */
public long getCommentCount(Weblog website) throws WebloggerException {
TypedQuery<Long> q =
strategy.getNamedQuery("WeblogEntryComment.getCountDistinctByWebsite&Status", Long.class);
q.setParameter(1, website);
q.setParameter(2, ApprovalStatus.APPROVED);
return q.getResultList().get(0);
}
/** @inheritDoc */
public String createAnchor(WeblogEntry entry) throws WebloggerException {
// Check for uniqueness of anchor
String base = entry.createAnchorBase();
String name = base;
int count = 0;
while (true) {
if (count > 0) {
name = base + count;
}
TypedQuery<WeblogEntry> q =
strategy.getNamedQuery("WeblogEntry.getByWebsite&Anchor", WeblogEntry.class);
q.setParameter(1, entry.getWebsite());
q.setParameter(2, name);
List results = q.getResultList();
if (results.size() < 1) {
break;
} else {
count++;
}
}
return name;
}
/** @inheritDoc */
public long getEntryCount(Weblog website) throws WebloggerException {
TypedQuery<Long> q =
strategy.getNamedQuery("WeblogEntry.getCountDistinctByStatus&Website", Long.class);
q.setParameter(1, PubStatus.PUBLISHED);
q.setParameter(2, website);
return q.getResultList().get(0);
}
/** @inheritDoc */
public void incrementHitCount(Weblog weblog, int amount) throws WebloggerException {
if (amount == 0) {
throw new WebloggerException("Tag increment amount cannot be zero.");
}
if (weblog == null) {
throw new WebloggerException("Website cannot be NULL.");
}
TypedQuery<WeblogHitCount> q =
strategy.getNamedQuery("WeblogHitCount.getByWeblog", WeblogHitCount.class);
q.setParameter(1, weblog);
WeblogHitCount hitCount;
try {
hitCount = q.getSingleResult();
} catch (NoResultException e) {
hitCount = null;
}
// create it if it doesn't exist
if (hitCount == null && amount > 0) {
hitCount = new WeblogHitCount();
hitCount.setWeblog(weblog);
hitCount.setDailyHits(amount);
strategy.store(hitCount);
} else if (hitCount != null) {
hitCount.setDailyHits(hitCount.getDailyHits() + amount);
strategy.store(hitCount);
}
}
/** @inheritDoc */
public boolean isWeblogCategoryInUse(WeblogCategory cat) throws WebloggerException {
if (cat.getWeblog().getBloggerCategory().equals(cat)) {
return true;
}
TypedQuery<WeblogEntry> q =
strategy.getNamedQuery("WeblogEntry.getByCategory", WeblogEntry.class);
q.setParameter(1, cat);
int entryCount = q.getResultList().size();
return entryCount > 0;
}
/** @inheritDoc */
public WeblogHitCount getHitCountByWeblog(Weblog weblog) throws WebloggerException {
TypedQuery<WeblogHitCount> q =
strategy.getNamedQuery("WeblogHitCount.getByWeblog", WeblogHitCount.class);
q.setParameter(1, weblog);
try {
return q.getSingleResult();
} catch (NoResultException e) {
return null;
}
}
/** @inheritDoc */
public List<WeblogEntry> getWeblogEntriesPinnedToMain(Integer max) throws WebloggerException {
TypedQuery<WeblogEntry> query =
strategy.getNamedQuery(
"WeblogEntry.getByPinnedToMain&statusOrderByPubTimeDesc", WeblogEntry.class);
query.setParameter(1, Boolean.TRUE);
query.setParameter(2, PubStatus.PUBLISHED);
if (max != null) {
query.setMaxResults(max);
}
return query.getResultList();
}
/** @inheritDoc */
@Override
public List<WeblogCategory> getWeblogCategories(Weblog website) throws WebloggerException {
if (website == null) {
throw new WebloggerException("website is null");
}
TypedQuery<WeblogCategory> q =
strategy.getNamedQuery("WeblogCategory.getByWeblog", WeblogCategory.class);
q.setParameter(1, website);
return q.getResultList();
}
/** @inheritDoc */
public WeblogCategory getWeblogCategoryByName(Weblog weblog, String categoryName)
throws WebloggerException {
TypedQuery<WeblogCategory> q =
strategy.getNamedQuery("WeblogCategory.getByWeblog&Name", WeblogCategory.class);
q.setParameter(1, weblog);
q.setParameter(2, categoryName);
try {
return q.getSingleResult();
} catch (NoResultException e) {
return null;
}
}
/** @inheritDoc */
public void resetHitCount(Weblog weblog) throws WebloggerException {
TypedQuery<WeblogHitCount> q =
strategy.getNamedQuery("WeblogHitCount.getByWeblog", WeblogHitCount.class);
q.setParameter(1, weblog);
WeblogHitCount hitCount;
try {
hitCount = q.getSingleResult();
hitCount.setDailyHits(0);
strategy.store(hitCount);
} catch (NoResultException e) {
// ignore: no hit count for weblog
}
}
/** @inheritDoc */
public WeblogEntry getWeblogEntryByAnchor(Weblog website, String anchor)
throws WebloggerException {
if (website == null) {
throw new WebloggerException("Website is null");
}
if (anchor == null) {
throw new WebloggerException("Anchor is null");
}
// mapping key is combo of weblog + anchor
String mappingKey = website.getHandle() + ":" + anchor;
// check cache first
// NOTE: if we ever allow changing anchors then this needs updating
if (this.entryAnchorToIdMap.containsKey(mappingKey)) {
WeblogEntry entry = this.getWeblogEntry(this.entryAnchorToIdMap.get(mappingKey));
if (entry != null) {
LOG.debug("entryAnchorToIdMap CACHE HIT - " + mappingKey);
return entry;
} else {
// mapping hit with lookup miss? mapping must be old, remove it
this.entryAnchorToIdMap.remove(mappingKey);
}
}
// cache failed, do lookup
TypedQuery<WeblogEntry> q =
strategy.getNamedQuery(
"WeblogEntry.getByWebsite&AnchorOrderByPubTimeDesc", WeblogEntry.class);
q.setParameter(1, website);
q.setParameter(2, anchor);
WeblogEntry entry;
try {
entry = q.getSingleResult();
} catch (NoResultException e) {
entry = null;
}
// add mapping to cache
if (entry != null) {
LOG.debug("entryAnchorToIdMap CACHE MISS - " + mappingKey);
this.entryAnchorToIdMap.put(mappingKey, entry.getId());
}
return entry;
}
/** @inheritDoc */
public List<WeblogHitCount> getHotWeblogs(int sinceDays, int offset, int length)
throws WebloggerException {
// figure out start date
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
cal.add(Calendar.DATE, -1 * sinceDays);
Date startDate = cal.getTime();
TypedQuery<WeblogHitCount> query =
strategy.getNamedQuery(
"WeblogHitCount.getByWeblogEnabledTrueAndActiveTrue&DailyHitsGreaterThenZero&WeblogLastModifiedGreaterOrderByDailyHitsDesc",
WeblogHitCount.class);
query.setParameter(1, startDate);
if (offset != 0) {
query.setFirstResult(offset);
}
if (length != -1) {
query.setMaxResults(length);
}
return query.getResultList();
}
/** @inheritDoc */
public List<TagStat> getPopularTags(Weblog website, Date startDate, int offset, int limit)
throws WebloggerException {
TypedQuery<TagStat> query;
List queryResults;
if (website != null) {
if (startDate != null) {
Timestamp start = new Timestamp(startDate.getTime());
query =
strategy.getNamedQuery(
"WeblogEntryTagAggregate.getPopularTagsByWebsite&StartDate", TagStat.class);
query.setParameter(1, website);
query.setParameter(2, start);
} else {
query =
strategy.getNamedQuery(
"WeblogEntryTagAggregate.getPopularTagsByWebsite", TagStat.class);
query.setParameter(1, website);
}
} else {
if (startDate != null) {
Timestamp start = new Timestamp(startDate.getTime());
query =
strategy.getNamedQuery(
"WeblogEntryTagAggregate.getPopularTagsByWebsiteNull&StartDate", TagStat.class);
query.setParameter(1, start);
} else {
query =
strategy.getNamedQuery(
"WeblogEntryTagAggregate.getPopularTagsByWebsiteNull", TagStat.class);
}
}
if (offset != 0) {
query.setFirstResult(offset);
}
if (limit != -1) {
query.setMaxResults(limit);
}
queryResults = query.getResultList();
double min = Integer.MAX_VALUE;
double max = Integer.MIN_VALUE;
List<TagStat> results = new ArrayList<TagStat>(limit >= 0 ? limit : 25);
if (queryResults != null) {
for (Object obj : queryResults) {
Object[] row = (Object[]) obj;
TagStat t = new TagStat();
t.setName((String) row[0]);
t.setCount(((Number) row[1]).intValue());
min = Math.min(min, t.getCount());
max = Math.max(max, t.getCount());
results.add(t);
}
}
min = Math.log(1 + min);
max = Math.log(1 + max);
double range = Math.max(.01, max - min) * 1.0001;
for (TagStat t : results) {
t.setIntensity((int) (1 + Math.floor(5 * (Math.log(1 + t.getCount()) - min) / range)));
}
// sort results by name, because query had to sort by total
Collections.sort(results, TAG_STAT_NAME_COMPARATOR);
return results;
}
/** @inheritDoc */
public List<StatCount> getMostCommentedWeblogEntries(
Weblog website, Date startDate, Date endDate, int offset, int length)
throws WebloggerException {
TypedQuery<WeblogEntryComment> query;
List queryResults;
Timestamp end = new Timestamp(endDate != null ? endDate.getTime() : new Date().getTime());
if (website != null) {
if (startDate != null) {
Timestamp start = new Timestamp(startDate.getTime());
query =
strategy.getNamedQuery(
"WeblogEntryComment.getMostCommentedWeblogEntryByWebsite&EndDate&StartDate",
WeblogEntryComment.class);
query.setParameter(1, website);
query.setParameter(2, end);
query.setParameter(3, start);
} else {
query =
strategy.getNamedQuery(
"WeblogEntryComment.getMostCommentedWeblogEntryByWebsite&EndDate",
WeblogEntryComment.class);
query.setParameter(1, website);
query.setParameter(2, end);
}
} else {
if (startDate != null) {
Timestamp start = new Timestamp(startDate.getTime());
query =
strategy.getNamedQuery(
"WeblogEntryComment.getMostCommentedWeblogEntryByEndDate&StartDate",
WeblogEntryComment.class);
query.setParameter(1, end);
query.setParameter(2, start);
} else {
query =
strategy.getNamedQuery(
"WeblogEntryComment.getMostCommentedWeblogEntryByEndDate",
WeblogEntryComment.class);
query.setParameter(1, end);
}
}
if (offset != 0) {
query.setFirstResult(offset);
}
if (length != -1) {
query.setMaxResults(length);
}
queryResults = query.getResultList();
List<StatCount> results = new ArrayList<StatCount>();
if (queryResults != null) {
for (Object obj : queryResults) {
Object[] row = (Object[]) obj;
StatCount sc =
new StatCount(
(String) row[1], // weblog handle
(String) row[2], // entry anchor
(String) row[3], // entry title
"statCount.weblogEntryCommentCountType", // stat desc
((Long) row[0])); // count
sc.setWeblogHandle((String) row[1]);
results.add(sc);
}
}
// Original query ordered by desc count.
// JPA QL doesn't allow queries to be ordered by agregates; do it in memory
Collections.sort(results, STAT_COUNT_COUNT_REVERSE_COMPARATOR);
return results;
}
/**
* This method maintains the tag aggregate table up-to-date with total counts. More specifically
* every time this method is called it will act upon exactly two rows in the database
* (tag,website,count), one with website matching the argument passed and one where website is
* null. If the count ever reaches zero, the row must be deleted.
*
* @param name The tag name
* @param website The website to used when updating the stats.
* @param amount The amount to increment the tag count (it can be positive or negative).
* @throws WebloggerException
*/
private void updateTagCount(String name, Weblog website, int amount) throws WebloggerException {
if (amount == 0) {
throw new WebloggerException("Tag increment amount cannot be zero.");
}
if (website == null) {
throw new WebloggerException("Website cannot be NULL.");
}
// The reason why add order lastUsed desc is to make sure we keep picking the most recent
// one in the case where we have multiple rows (clustered environment)
// eventually that second entry will have a very low total (most likely 1) and
// won't matter
TypedQuery<WeblogEntryTagAggregate> weblogQuery =
strategy.getNamedQuery(
"WeblogEntryTagAggregate.getByName&WebsiteOrderByLastUsedDesc",
WeblogEntryTagAggregate.class);
weblogQuery.setParameter(1, name);
weblogQuery.setParameter(2, website);
WeblogEntryTagAggregate weblogTagData;
try {
weblogTagData = weblogQuery.getSingleResult();
} catch (NoResultException e) {
weblogTagData = null;
}
TypedQuery<WeblogEntryTagAggregate> siteQuery =
strategy.getNamedQuery(
"WeblogEntryTagAggregate.getByName&WebsiteNullOrderByLastUsedDesc",
WeblogEntryTagAggregate.class);
siteQuery.setParameter(1, name);
WeblogEntryTagAggregate siteTagData;
try {
siteTagData = siteQuery.getSingleResult();
} catch (NoResultException e) {
siteTagData = null;
}
Timestamp lastUsed = new Timestamp((new Date()).getTime());
// create it only if we are going to need it.
if (weblogTagData == null && amount > 0) {
weblogTagData = new WeblogEntryTagAggregate(null, website, name, amount);
weblogTagData.setLastUsed(lastUsed);
strategy.store(weblogTagData);
} else if (weblogTagData != null) {
weblogTagData.setTotal(weblogTagData.getTotal() + amount);
weblogTagData.setLastUsed(lastUsed);
strategy.store(weblogTagData);
}
// create it only if we are going to need it.
if (siteTagData == null && amount > 0) {
siteTagData = new WeblogEntryTagAggregate(null, null, name, amount);
siteTagData.setLastUsed(lastUsed);
strategy.store(siteTagData);
} else if (siteTagData != null) {
siteTagData.setTotal(siteTagData.getTotal() + amount);
siteTagData.setLastUsed(lastUsed);
strategy.store(siteTagData);
}
// delete all bad counts
Query removeq = strategy.getNamedUpdate("WeblogEntryTagAggregate.removeByTotalLessEqual");
removeq.setParameter(1, 0);
removeq.executeUpdate();
}
