@Override
public void setMessagesReadden(String userId, String tagId, UserTags tags) {
Query<UnreaddenMessage> q =
ds.createQuery(UnreaddenMessage.class).field("userId").equal(userId);
if (!tagId.equals(UserTags.ALL_TAGS)) {
SocioTag tag = tags.getTag(tagId);
List<String> tagsIds = new ArrayList<String>();
List<SocioTag> leaves = tag.getLeaves();
for (SocioTag leaf : leaves) {
tagsIds.add(leaf.getUniqueId());
}
q.field("tagId").hasAnyOf(tagsIds);
}
List<UnreaddenMessage> unreadMessages = q.asList();
List<GeneralMessage> messages = new ArrayList<GeneralMessage>();
List<ReaddenMessage> readdenMessages = new ArrayList<ReaddenMessage>();
for (UnreaddenMessage unreaddenMessage : unreadMessages) {
GeneralMessage message = unreaddenMessage.getMessage();
messages.add(message);
ReaddenMessage readdenMessage = new ReaddenMessage();
readdenMessage.setUserId(userId);
readdenMessage.setMessageUniqueId(message.getUniqueFieldValue().toString());
readdenMessages.add(readdenMessage);
}
ds.save(readdenMessages);
ds.delete(q);
for (GeneralMessage message : messages) {
// TODO Next lines are just to save space in unpaid mongoDB on CloudBees
Query<UnreaddenMessage> isMore =
ds.createQuery(UnreaddenMessage.class).field("message").equal(message);
if (isMore.countAll() <= 0) {
ds.delete(message);
}
}
}
@Override
public <T extends GeneralMessage> boolean isNewMessage(String userId, T message, Class<T> T) {
Cache cache = cm.getCache("Messages");
String key = message.getUniqueFieldValue() + userId;
Element element = cache.get(key);
if (element != null) {
return (Boolean) element.getValue();
}
Query<UnreaddenMessage> isUnread =
ds.createQuery(UnreaddenMessage.class)
.field("userId")
.equal(userId)
.field("message")
.equal(new Key<T>(T, message.getId()));
Query<ReaddenMessage> isRead =
ds.createQuery(ReaddenMessage.class)
.field("userId")
.equal(userId)
.field("messageUniqueId")
.equal(message.getUniqueFieldValue().toString());
Boolean newMessage = isUnread.countAll() <= 0 && isRead.countAll() <= 0;
element = new Element(key, new Boolean(false));
cache.put(element);
return newMessage;
}
public <T extends ISocioObject> void saveObject(T object) throws DuplicateMySocioObjectException {
if (object instanceof IUniqueObject) {
IUniqueObject uniqueObject = (IUniqueObject) object;
Cache cache = cm.getCache("Objects");
String key = uniqueObject.getUniqueFieldName() + uniqueObject.getUniqueFieldValue();
Element element = cache.get(key);
if (element != null) {
((SocioObject) object).setId((ObjectId) element.getValue());
return;
}
@SuppressWarnings("unchecked")
Query<T> q =
(Query<T>)
ds.createQuery(object.getClass())
.field(uniqueObject.getUniqueFieldName())
.equal(uniqueObject.getUniqueFieldValue());
T objectT = (T) q.get();
if (objectT != null) {
((SocioObject) object).setId(objectT.getId());
element = new Element(key, objectT.getId());
cache.put(element);
logger.info(
"Duplicate object of type: " + object.getClass() + " for query: " + q.toString());
throw new DuplicateMySocioObjectException(
"Duplicate object of type: " + object.getClass() + " for query: " + q.toString());
}
}
ds.save(object);
}
public List<GeneralMessage> getUnreadMessages(String userId, String tagId, UserTags tags) {
Query<UnreaddenMessage> q =
ds.createQuery(UnreaddenMessage.class).field("userId").equal(userId.toString());
String order = tags.getOrder();
if (!tagId.equals(UserTags.ALL_TAGS)) {
SocioTag tag = tags.getTag(tagId);
order = tag.getOrder();
List<String> tagsIds = new ArrayList<String>();
List<SocioTag> leaves = tag.getLeaves();
for (SocioTag leaf : leaves) {
tagsIds.add(leaf.getUniqueId());
}
q.field("tagId").hasAnyOf(tagsIds);
}
if (order.equals(SocioTag.ASCENDING_ORDER)) {
q.order("-messageDate");
} else {
q.order("messageDate");
}
q.limit(tags.getRange());
List<GeneralMessage> messagesList = new ArrayList<GeneralMessage>();
Iterable<UnreaddenMessage> messages = q.fetch();
for (UnreaddenMessage unreaddenMessage : messages) {
messagesList.add(unreaddenMessage.getMessage());
}
tags.setSelectedTag(tagId);
ds.save(tags);
return messagesList;
}
public Long countUnreadMessages(String userId, String tagId) {
return ds.createQuery(UnreaddenMessage.class)
.field("tagId")
.equal(tagId)
.field("userId")
.equal(userId)
.countAll();
}
public EssayCount findByUser(String user) throws Exception {
try {
Query q = ds.createQuery(EssayCount.class).field("user").equal(user);
EssayCount app = (EssayCount) q.get();
return app;
} catch (Exception e) {
throw e;
}
}
public <T extends ISocioObject> List<T> getObjects(Class<T> T) {
Query<T> q = (Query<T>) ds.createQuery(T);
Iterable<T> objects = q.fetch();
ArrayList<T> ret = new ArrayList<T>();
for (T object : objects) {
ret.add(object);
}
return ret;
}
public static void query() throws Exception {
Datastore ds = getDatastore();
// find
List<PureMorphiaUser> users =
ds.createQuery(PureMorphiaUser.class)
.filter("fName", "John")
.filter("lName", "Smith")
.asList();
}
public List<EssayCount> findAll() throws Exception {
try {
Query q = ds.createQuery(EssayCount.class).order("-count");
List<EssayCount> list = q.asList();
return list;
} catch (Exception e) {
throw e;
}
}
@Override
public <T> void deleteUserProcessorByField(
Class<T> clazz, String fieldName, String fieldValue, String userId) {
Query<T> q =
processorsDs
.createQuery(clazz)
.field(fieldName)
.equal(fieldValue)
.field("userId")
.equal(userId);
processorsDs.delete(q);
}
public String getPage(String userId, String pageKey) {
Query<UserPage> q =
ds.createQuery(UserPage.class)
.field("userId")
.equal(userId)
.field("pageKey")
.equal(pageKey);
UserPage userPage = q.get();
if (userPage == null) {
return null;
}
return userPage.getPageHTML();
}
public Boolean update(EssayCount count) throws Exception {
try {
Query q = ds.createQuery(EssayCount.class).field("_id").equal(count.getId());
EssayCount app = (EssayCount) q.get();
if (app != null) {
ds.save(count);
return true;
} else {
return false;
}
} catch (Exception e) {
throw e;
}
}
@Override
public void setMessageReadden(String userId, String messageId) {
Query<UnreaddenMessage> q =
ds.createQuery(UnreaddenMessage.class)
.field("message")
.equal(new Key<GeneralMessage>(GeneralMessage.class, new ObjectId(messageId)))
.field("userId")
.equal(userId);
ds.delete(q);
ReaddenMessage readdenMessage = new ReaddenMessage();
readdenMessage.setUserId(userId);
readdenMessage.setMessageUniqueId(
ds.get(GeneralMessage.class, new ObjectId(messageId)).getUniqueFieldValue().toString());
ds.save(readdenMessage);
// TODO Next lines are just to save space in unpaid mongoDB on CloudBees
Query<UnreaddenMessage> isMore =
ds.createQuery(UnreaddenMessage.class)
.field("message")
.equal(new Key<GeneralMessage>(GeneralMessage.class, new ObjectId(messageId)));
if (isMore.countAll() <= 0) {
ds.delete(GeneralMessage.class, new ObjectId(messageId));
}
}
@Override
public <T extends GeneralMessage> List<T> getMessagesAfterDate(
Class<T> T, Long date, String sourceField, String sourceId) {
Query<T> q =
(Query<T>)
ds.createQuery(T)
.field("date")
.greaterThanOrEq(date)
.field(sourceField)
.equal(sourceId);
Iterable<T> messages = q.fetch();
ArrayList<T> ret = new ArrayList<T>();
for (T message : messages) {
ret.add(message);
}
return ret;
}
public void plusOne(String user) throws Exception {
try {
Query q = ds.createQuery(EssayCount.class).field("user").equal(user);
EssayCount ec = (EssayCount) q.get();
if (ec == null) {
ec = new EssayCount();
ec.setCount(1);
ec.setLastRate(new Date());
ec.setUser(user);
ds.save(ec);
} else {
ec.setCount(ec.getCount() + 1);
ec.setLastRate(new Date());
ds.save(ec);
}
} catch (Exception e) {
throw e;
}
}
@Override
public <T extends AbstractUserMessagesProcessor> void saveProcessor(
T processor, String uniqueFieldName, String uniqueFieldValue)
throws DuplicateMySocioObjectException {
@SuppressWarnings("unchecked")
Query<T> q =
(Query<T>)
processorsDs
.createQuery(processor.getClass())
.field(uniqueFieldName)
.equal(uniqueFieldValue);
String userId = processor.getUserId();
if (userId != null) {
q.field("userId").equal(userId);
}
AbstractUserMessagesProcessor existingProcessor = q.get();
if (existingProcessor != null) {
processor.setId(existingProcessor.getId());
logger.info("Duplicate processor for query: " + q.toString());
throw new DuplicateMySocioObjectException("Duplicate processor for query: " + q.toString());
}
processorsDs.save(processor);
}
/**
* @param account
* @param user
* @throws Exception
*/
public void addAccountToUser(Account account, String userId, UserTags userTags) throws Exception {
Query<UserAccount> q = ds.createQuery(UserAccount.class).field("account").equal(account);
if (q.get() != null) {
logger.debug(
"Attempt was made to add existing account of type "
+ account.getAccountType()
+ " to user "
+ userId);
return;
}
SocioUser user = getObject(SocioUser.class, userId);
account.setUser(user);
saveObject(account);
UserAccount userAccount = new UserAccount();
userAccount.setUserId(userId);
userAccount.setAccount(account);
saveObject(userAccount);
account.createAccountTagset(userTags);
saveObject(userTags);
for (Source source : account.getSources()) {
addSourceToUser(userId, source);
}
}
public List<AbstractUserMessagesProcessor> getUserProcessors(String userId) {
Query<AbstractUserMessagesProcessor> q =
processorsDs.createQuery(AbstractUserMessagesProcessor.class).field("userId").equal(userId);
return q.asList();
}
@PostConstruct
public void init() {
try {
System.out.println("UMIGON - semantic analyzer for large twitter accounts");
Mongo m;
Morphia morphia;
Mongo mLocal;
Morphia morphiaLocal;
mLocal = new Mongo();
morphiaLocal = new Morphia();
setTweets = new ArrayList();
if (dev) {
ExcelToCsv.load();
}
if (!dev) {
saveOnDisk = false;
analyzeNewlyArrivedTweets = false;
analyzeAllFromDisk = false;
loadTweetsFromLocal = false;
loadFromTrainingFile = false;
bigTrainingFile = false;
clementTests = false;
}
// loads the heuristics from the csv files just created
Hloader = new HeuristicsLoader();
Hloader.load();
// loads Categories
Categories.populate();
if (saveOnDisk || analyzeNewlyArrivedTweets) {
m = new Mongo("alex.mongohq.com", 10056);
morphia = new Morphia();
ds =
morphia.createDatastore(
m, APIkeys.getMongoHQAPIkey(), "seinecle", APIkeys.getMongoHQPass().toCharArray());
if (ds != null) {
System.out.println("Morphia datastore on CloudBees / MongoHQ created!!!!!!!");
}
morphia.map(Tweet.class);
listTweets = ds.find(Tweet.class).asList();
setTweets.addAll(listTweets);
}
if (saveOnDisk || analyzeAllFromDisk || loadTweetsFromLocal) {
dsLocal = morphiaLocal.createDatastore(mLocal, "hp");
morphiaLocal.map(Tweet.class);
}
if (saveOnDisk) {
Iterator<Tweet> setTweetsIterator = setTweets.iterator();
while (setTweetsIterator.hasNext()) {
Tweet tweet = setTweetsIterator.next();
dsLocal.save(tweet);
}
ds.delete(ds.createQuery(Tweet.class));
System.out.println("------------------------------------------------");
System.out.println(
"saved " + setTweets.size() + " on disk and deleted them fromm the cloud");
}
if (analyzeAllFromDisk) {
listTweets = dsLocal.find(Tweet.class).asList();
setTweets.addAll(listTweets);
System.out.println("------------------------------------------------");
System.out.println(
"retrieving all tweets from disk (collected since Dec. 02, 2012): " + setTweets.size());
hl1 = new TweetLooper(setTweets);
setTweets = hl1.applyLevel1(loadFromTrainingFile);
for (Tweet tweet : setTweets) {
updateQuery = dsLocal.createQuery(Tweet.class).field("text").equal(tweet.getText());
ops =
dsLocal
.createUpdateOperations(Tweet.class)
.set("setCategories", tweet.getSetCategories());
dsLocal.update(updateQuery, ops, true);
}
}
if (loadTweetsFromLocal) {
listTweets = dsLocal.find(Tweet.class).asList();
setTweets.addAll(listTweets);
System.out.println("------------------------------------------------");
System.out.println(
"retrieved all tweets from disk (collected since Dec. 02, 2012): " + setTweets.size());
}
if (analyzeNewlyArrivedTweets) {
listTweets = ds.find(Tweet.class).asList();
setTweets.addAll(listTweets);
System.out.println("------------------------------------------------");
System.out.println("retrieving newly arrived tweets from the cloud: " + setTweets.size());
hl1 = new TweetLooper(setTweets);
hl1.applyLevel1(loadFromTrainingFile);
}
if (loadFromTrainingFile) {
ExternalSourceTweetLoader comp = new ExternalSourceTweetLoader();
if (bigTrainingFile) {
setTweets = comp.sentimentBigSetLoader(maxTweets, termFilter);
} else if (clementTests) {
setTweets = comp.clementTestTweetsLoader(maxTweets);
} else {
setTweets = comp.sentiment140Loader();
}
System.out.println("------------------------------------------------");
System.out.println("tweets from training file: " + setTweets.size());
hl1 = new TweetLooper(setTweets);
hl1.applyLevel1(loadFromTrainingFile);
}
} catch (LangDetectException ex) {
Logger.getLogger(ControllerBean.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
Logger.getLogger(ControllerBean.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(ControllerBean.class.getName()).log(Level.SEVERE, null, ex);
} catch (InvalidFormatException ex) {
Logger.getLogger(ControllerBean.class.getName()).log(Level.SEVERE, null, ex);
} catch (MongoException ex) {
Logger.getLogger(ControllerBean.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void deleteById(long userId) {
Datastore ds = ds();
Query query = ds.createQuery(User.class).filter("id", userId);
ds.delete(query);
}
/**
* @param account
* @return
*/
public Account getAccount(String accountUniqueId) {
Query<Account> q =
ds.createQuery(Account.class).field("accountUniqueId").equal(accountUniqueId);
return q.get();
}
@Override
public UserPermissions getUserPermissions(String mail) {
Query<UserPermissions> q = ds.createQuery(UserPermissions.class).field("mail").equal(mail);
return q.get();
}
public List<UserAccount> getAccounts(String userId) {
Query<UserAccount> q = ds.createQuery(UserAccount.class).field("userId").equal(userId);
return q.asList();
}
public UserTags getUserTags(String userId) {
Query<UserTags> q = ds.createQuery(UserTags.class).field("userId").equal(userId);
return q.get();
}
public <T> T getObject(Class<T> T, String id) {
Query<T> q = (Query<T>) ds.createQuery(T).field("id").equal(new ObjectId(id));
return q.get();
}
@Override
public boolean isProcessorExist(String userId) {
Query<DefaultUserProcessor> processor =
processorsDs.createQuery(DefaultUserProcessor.class).field("userId").equal(userId);
return (processor.countAll() > 0);
}
public CappedCollectionTimeStamp getTimestamp(String collection) {
Query<CappedCollectionTimeStamp> q =
(Query<CappedCollectionTimeStamp>)
ds.createQuery(CappedCollectionTimeStamp.class).field("collection").equal(collection);
return q.get();
}
@Override
public Source getSource(String url) {
Query<Source> q = ds.createQuery(Source.class).field("url").equal(url);
return q.get();
}
public UiObject getUiObject(String category, String name) {
Query<UiObject> q =
ds.createQuery(UiObject.class).field("category").equal(category).field("name").equal(name);
return q.get();
}
