@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(); }