Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
method2testcases
stringlengths
118
3.08k
### Question: HibernateSessionDAO extends HibernatePersistentObjectDAO<Session> implements SessionDAO { @Override public int countSessions(Long tenantId, Integer status) { StringBuffer query = new StringBuffer(" 1=1 "); if (tenantId != null) query.append(" and _entity.tenantId = " + tenantId); if (status != null) query.append(" and _entity.status = " + status); try { List<Session> sessions = findByWhere(query.toString(), null, null); return sessions.size(); } catch (PersistenceException e) { log.error(e.getMessage(), e); return 0; } } protected HibernateSessionDAO(); @Override void deleteCurrentNodeSessions(); @Override int countSessions(Long tenantId, Integer status); @Override Session findBySid(String sid); @Override void initialize(Session session); @Override List<Session> findByNode(String node); @Override void cleanOldSessions(int ttl); }### Answer: @Test public void testCountSessions() { Assert.assertEquals(1, dao.countSessions(1L, Session.STATUS_OPEN)); Assert.assertEquals(1, dao.countSessions(null, Session.STATUS_OPEN)); Assert.assertEquals(1, dao.countSessions(1L, null)); Assert.assertEquals(1, dao.countSessions(null, null)); Assert.assertEquals(0, dao.countSessions(1L, Session.STATUS_CLOSED)); Assert.assertEquals(0, dao.countSessions(2L, Session.STATUS_OPEN)); }
### Question: HibernateUserHistoryDAO extends HibernatePersistentObjectDAO<UserHistory> implements UserHistoryDAO { public List<UserHistory> findByUserId(long userId) { try { return findByWhere("_entity.userId =" + userId, "order by _entity.date asc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<UserHistory>(); } } private HibernateUserHistoryDAO(); List<UserHistory> findByUserId(long userId); @Override void createUserHistory(User user, String eventType, String comment, String ip, String sessionId); @Override void cleanOldHistories(int ttl); @Override boolean store(UserHistory history); }### Answer: @Test public void testDelete() throws PersistenceException { Collection<UserHistory> histories = (Collection<UserHistory>) dao.findByUserId(1); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); for (UserHistory history : histories) { boolean result = dao.delete(history.getId()); Assert.assertTrue(result); } histories = (Collection<UserHistory>) dao.findByUserId(4); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); } @SuppressWarnings("rawtypes") @Test public void testFindByUserId() { Collection histories = dao.findByUserId(1); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); histories = dao.findByUserId(99); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: HibernateUserHistoryDAO extends HibernatePersistentObjectDAO<UserHistory> implements UserHistoryDAO { @Override public boolean store(UserHistory history) throws PersistenceException { if (RunLevel.current().aspectEnabled(DocumentHistory.ASPECT)) { boolean ret = super.store(history); if (ret) EventCollector.get().newEvent(history); return ret; } else return true; } private HibernateUserHistoryDAO(); List<UserHistory> findByUserId(long userId); @Override void createUserHistory(User user, String eventType, String comment, String ip, String sessionId); @Override void cleanOldHistories(int ttl); @Override boolean store(UserHistory history); }### Answer: @Test public void testStore() throws PersistenceException { UserHistory userHistory = new UserHistory(); userHistory.setDate(DateBean.dateFromCompactString("20061220")); userHistory.setUsername("sebastian"); userHistory.setUserId(3L); userHistory.setEvent("first test User History store"); Assert.assertTrue(dao.store(userHistory)); UserHistory newUserHistory = new UserHistory(); newUserHistory.setDate(DateBean.dateFromCompactString("20061220")); newUserHistory.setUsername("sebastian"); newUserHistory.setUserId(3L); newUserHistory.setEvent("second test User History store"); Assert.assertTrue(dao.store(newUserHistory)); Collection<UserHistory> histories = (Collection<UserHistory>) dao.findByUserId(3); Assert.assertNotNull(histories); Assert.assertFalse(histories.isEmpty()); UserHistory hStored = null; for (UserHistory userHistory2 : histories) { if (userHistory2.getId() == newUserHistory.getId()) { hStored = userHistory2; break; } } Assert.assertTrue(hStored.equals(newUserHistory)); Assert.assertEquals(hStored.getDate().getTime(), DateBean.dateFromCompactString("20061220").getTime()); Assert.assertEquals(hStored.getUsername(), "sebastian"); Assert.assertEquals(hStored.getEvent(), "second test User History store"); }
### Question: HibernateUserHistoryDAO extends HibernatePersistentObjectDAO<UserHistory> implements UserHistoryDAO { @Override public void cleanOldHistories(int ttl) { if (ttl > 0) { Date today = new Date(); GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.DAY_OF_MONTH, -ttl); Date ldDate = cal.getTime(); log.debug("today: {}", today); log.debug("ldDate: {}", ldDate); try { int rowsUpdated = jdbcUpdate("UPDATE ld_user_history SET ld_deleted = 1, ld_lastmodified = ?" + " WHERE ld_deleted = 0 AND ld_date < ?", today, ldDate); log.info("cleanOldHistories rows updated: {}", rowsUpdated); } catch (Exception e) { if (log.isErrorEnabled()) log.error(e.getMessage(), e); } } } private HibernateUserHistoryDAO(); List<UserHistory> findByUserId(long userId); @Override void createUserHistory(User user, String eventType, String comment, String ip, String sessionId); @Override void cleanOldHistories(int ttl); @Override boolean store(UserHistory history); }### Answer: @SuppressWarnings("rawtypes") @Test public void testCleanOldHistories() { dao.cleanOldHistories(5); UserHistory history = dao.findById(1); Assert.assertNull(history); Collection histories = dao.findAll(); Assert.assertEquals(0, histories.size()); }
### Question: Language implements Comparable<Language> { void loadStopwords() { try { Set<String> swSet = new HashSet<String>(); String stopwordsResource = "/stopwords/stopwords_" + getLocale().toString() + ".txt"; log.debug("Loading stopwords from: " + stopwordsResource); InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(stopwordsResource); if (is == null) is = getClass().getResourceAsStream(stopwordsResource); if (is == null) { log.warn("No stopwords found for locale " + getLocale().toString()); } else { InputStreamReader isr = new InputStreamReader(is, "UTF-8"); BufferedReader br = new BufferedReader(isr); String line = null; while ((line = br.readLine()) != null) { line = line.trim(); if (line.indexOf("|") != -1) { line = line.substring(0, line.indexOf("|")); line = line.trim(); } if (line != null && line.length() > 0 && !swSet.contains(line)) { swSet.add(line); } } } stopWords = swSet; } catch (Throwable e) { log.warn(e.getMessage(), e); } } Language(Locale locale); Locale getLocale(); String getLanguage(); String getDisplayLanguage(); String getDefaultDisplayLanguage(); Set<String> getStopWords(); void setStopWords(Set<String> stopWords); String getAnalyzerClass(); void setAnalyzerClass(String analyzerClass); @SuppressWarnings("unchecked") Analyzer getAnalyzer(); void setAnalyzer(Analyzer analyzer); @Override String toString(); @Override int hashCode(); @Override int compareTo(Language o); SnowballProgram getStemmer(); }### Answer: @Test public void testLoadStopwords() throws IOException { Language language = new Language(Locale.FRENCH); Set<String> swords = language.getStopWords(); assertNotNull(swords); assertEquals(126, swords.size()); }
### Question: HibernateDocumentNoteDAO extends HibernatePersistentObjectDAO<DocumentNote> implements DocumentNoteDAO { @Override public List<DocumentNote> findByDocId(long docId, String fileVersion) { try { if (StringUtils.isEmpty(fileVersion)) return findByWhere("_entity.docId = " + docId, null, null); else return findByWhere("_entity.docId = ?1 and _entity.fileVersion = ?2", new Object[] { docId, fileVersion }, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<DocumentNote>(); } } HibernateDocumentNoteDAO(); @Override boolean store(DocumentNote note, DocumentHistory transaction); @Override List<DocumentNote> findByDocId(long docId, String fileVersion); @Override List<DocumentNote> findByUserId(long userId); @Override boolean delete(long id, int code); @Override int copyAnnotations(long docId, String oldFileVersion, String newFileVersion); }### Answer: @Test public void testFindByDocId() { List<DocumentNote> notes = dao.findByDocId(1L, null); Assert.assertNotNull(notes); Assert.assertEquals(2, notes.size()); DocumentNote note = notes.get(0); Assert.assertEquals("message for note 1", note.getMessage()); }
### Question: SessionManager extends ConcurrentHashMap<String, Session> { public synchronized Session newSession(String username, String password, String key, Client client) throws AuthenticationException { User user = authenticationChain.authenticate(username, password, key, client); if (user == null) return null; else { return createSession(user, password, key, client); } } private SessionManager(); final static SessionManager get(); synchronized Session newSession(String username, String password, String key, Client client); synchronized Session newSession(String username, String password, Client client); synchronized Session createSession(User user, Client client); void kill(String sid); @Override Session remove(Object sid); void renew(String sid); int getStatus(String sid); boolean isOpen(String sid); @Override Session get(Object sid); Session getByClientId(String clientId); int countOpened(); int countOpened(long tenantId); List<Session> getSessions(); Session getSession(HttpServletRequest request); String getSessionId(HttpServletRequest request); void saveSid(HttpServletRequest request, HttpServletResponse response, String sid); void removeSid(HttpServletRequest request); static String getCurrentSid(); HttpSession getServletSession(String sid); Client buildClient(HttpServletRequest req); void setAuthenticationChain(AuthenticationChain authenticationChain); void destroy(); SessionDAO getSessionDao(); void setSessionDao(SessionDAO sessionDao); synchronized void addListener(SessionListener listener); synchronized void removeListener(SessionListener listener); static final String COOKIE_SID; static final String PARAM_SID; }### Answer: @Test public void testNewSession() { SessionManager sm = SessionManager.get(); sm.clear(); Session session1 = sm.newSession("admin", "admin", null); Assert.assertNotNull(session1); Session session2 = sm.newSession("admin", "admin", null); Assert.assertNotNull(session2); Assert.assertFalse(session1.equals(session2)); Assert.assertEquals(2, sm.getSessions().size()); }
### Question: SecurityManagerImpl implements SecurityManager { @Override public Set<Group> getAllowedGroups(long menuId) { Menu menu = menuDAO.findById(menuId); if (menu.getSecurityRef() != null) menu = menuDAO.findById(menu.getSecurityRef()); Set<Group> groups = new HashSet<Group>(); for (MenuGroup mg : menu.getMenuGroups()) { Group group = groupDAO.findById(mg.getGroupId()); if (!groups.contains(group)) groups.add(groupDAO.findById(mg.getGroupId())); } Group admin = groupDAO.findById(Group.GROUPID_ADMIN); if (!groups.contains(admin)) groups.add(admin); return groups; } private SecurityManagerImpl(); void setMenuDAO(MenuDAO menuDAO); void setGroupDAO(GroupDAO groupDAO); void setUserDAO(UserDAO userDAO); @Override Set<Group> getAllowedGroups(long menuId); @Override boolean isMemberOf(long userId, long groupId); @Override boolean isMemberOf(long userId, String groupName); @Override boolean isWriteEnabled(long docId, long userId); @Override boolean isReadEnabled(long docId, long userId); @Override boolean isPrintEnabled(long docId, long userId); @Override boolean isDownloadEnabled(long docId, long userId); @Override boolean isPermissionEnabled(Permission permission, long docId, long userId); @Override Set<Permission> getEnabledPermissions(long docId, long userId); void setFolderDAO(FolderDAO folderDAO); void setDocumentDAO(DocumentDAO documentDAO); }### Answer: @Test public void testGetAllowedGroups() { Set<Group> groups = manager.getAllowedGroups(9); Assert.assertNotNull(groups); Assert.assertTrue(groups.contains(groupDAO.findByName("admin", 1))); }
### Question: SecurityManagerImpl implements SecurityManager { @Override public boolean isMemberOf(long userId, long groupId) { try { return userDAO.queryForInt( "select count(*) from ld_usergroup where ld_userid=" + userId + " and ld_groupid=" + groupId) > 0; } catch (PersistenceException e) { log.error(e.getMessage(), e); return false; } } private SecurityManagerImpl(); void setMenuDAO(MenuDAO menuDAO); void setGroupDAO(GroupDAO groupDAO); void setUserDAO(UserDAO userDAO); @Override Set<Group> getAllowedGroups(long menuId); @Override boolean isMemberOf(long userId, long groupId); @Override boolean isMemberOf(long userId, String groupName); @Override boolean isWriteEnabled(long docId, long userId); @Override boolean isReadEnabled(long docId, long userId); @Override boolean isPrintEnabled(long docId, long userId); @Override boolean isDownloadEnabled(long docId, long userId); @Override boolean isPermissionEnabled(Permission permission, long docId, long userId); @Override Set<Permission> getEnabledPermissions(long docId, long userId); void setFolderDAO(FolderDAO folderDAO); void setDocumentDAO(DocumentDAO documentDAO); }### Answer: @Test public void testIsMemberOfLongLong() { Assert.assertTrue(manager.isMemberOf(1, 1)); Assert.assertFalse(manager.isMemberOf(1, 1234)); Assert.assertFalse(manager.isMemberOf(1, 2)); } @Test public void testIsMemberOfLongString() { Assert.assertTrue(manager.isMemberOf(1, "admin")); Assert.assertFalse(manager.isMemberOf(1, "xyz")); Assert.assertFalse(manager.isMemberOf(1, "author")); }
### Question: HibernateAttributeSetDAO extends HibernatePersistentObjectDAO<AttributeSet> implements AttributeSetDAO { @Override public boolean delete(long id, int code) { if (!checkStoringAspect()) return false; boolean result = true; try { AttributeSet set = (AttributeSet) findById(id); if (set == null) return true; set.setDeleted(code); set.setName(set.getName() + "." + set.getId()); saveOrUpdate(set); optionsDao.deleteBySetIdAndAttribute(id, null); List<Template> templates = templateDao.findAll(set.getTenantId()); for (Template template : templates) templateDao.store(template); } catch (Throwable e) { log.error(e.getMessage(), e); result = false; } return result; } HibernateAttributeSetDAO(); @Override List<AttributeSet> findAll(); @Override List<AttributeSet> findAll(long tenantId); @Override AttributeSet findByName(String name, long tenantId); @Override boolean delete(long id, int code); @Override List<AttributeSet> findByType(int type, long tenantId); void setOptionsDao(AttributeOptionDAO optionsDao); @Override boolean store(AttributeSet set); void setTemplateDao(TemplateDAO templateDao); @Override Map<Long, AttributeSet> load(long tenantId); @Override Map<String, Attribute> findAttributes(long tenantId, Long setId); }### Answer: @Test public void testDelete() throws PersistenceException { Assert.assertTrue(dao.delete(1)); AttributeSet set = dao.findById(1); Assert.assertNull(set); }
### Question: HibernateAttributeSetDAO extends HibernatePersistentObjectDAO<AttributeSet> implements AttributeSetDAO { @Override public List<AttributeSet> findAll() { try { return findByWhere(" 1=1", "order by _entity.name", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<AttributeSet>(); } } HibernateAttributeSetDAO(); @Override List<AttributeSet> findAll(); @Override List<AttributeSet> findAll(long tenantId); @Override AttributeSet findByName(String name, long tenantId); @Override boolean delete(long id, int code); @Override List<AttributeSet> findByType(int type, long tenantId); void setOptionsDao(AttributeOptionDAO optionsDao); @Override boolean store(AttributeSet set); void setTemplateDao(TemplateDAO templateDao); @Override Map<Long, AttributeSet> load(long tenantId); @Override Map<String, Attribute> findAttributes(long tenantId, Long setId); }### Answer: @Test public void testFindAll() { Collection<AttributeSet> sets = dao.findAll(); Assert.assertNotNull(sets); Assert.assertEquals(1, sets.size()); }
### Question: HibernateDocumentNoteDAO extends HibernatePersistentObjectDAO<DocumentNote> implements DocumentNoteDAO { @Override public int copyAnnotations(long docId, String oldFileVersion, String newFileVersion) throws PersistenceException { List<DocumentNote> oldNotes = findByDocId(docId, oldFileVersion); int count=0; for (DocumentNote oldNote : oldNotes) { if (oldNote.getPage() > 0) continue; try { DocumentNote newNote = (DocumentNote) oldNote.clone(); newNote.setId(0L); newNote.setFileVersion(newFileVersion); store(newNote); count++; } catch (CloneNotSupportedException e) { log.error(e.getMessage(), e); } } return count; } HibernateDocumentNoteDAO(); @Override boolean store(DocumentNote note, DocumentHistory transaction); @Override List<DocumentNote> findByDocId(long docId, String fileVersion); @Override List<DocumentNote> findByUserId(long userId); @Override boolean delete(long id, int code); @Override int copyAnnotations(long docId, String oldFileVersion, String newFileVersion); }### Answer: @Test public void testCopyAnnotations() throws PersistenceException { Assert.assertTrue(dao.findByDocId(4L, "2.0").isEmpty()); dao.copyAnnotations(4L, "1.0", "2.0"); Assert.assertEquals(1, dao.findByDocId(4L, "2.0").size()); }
### Question: HibernateAttributeSetDAO extends HibernatePersistentObjectDAO<AttributeSet> implements AttributeSetDAO { @Override public AttributeSet findByName(String name, long tenantId) { AttributeSet template = null; try { List<AttributeSet> coll = findByWhere( "_entity.name = '" + SqlUtil.doubleQuotes(name) + "' and _entity.tenantId=" + tenantId, null, null); if (coll.size() > 0) template = coll.iterator().next(); if (template != null && template.getDeleted() == 1) template = null; } catch (PersistenceException e) { log.error(e.getMessage(), e); } return template; } HibernateAttributeSetDAO(); @Override List<AttributeSet> findAll(); @Override List<AttributeSet> findAll(long tenantId); @Override AttributeSet findByName(String name, long tenantId); @Override boolean delete(long id, int code); @Override List<AttributeSet> findByType(int type, long tenantId); void setOptionsDao(AttributeOptionDAO optionsDao); @Override boolean store(AttributeSet set); void setTemplateDao(TemplateDAO templateDao); @Override Map<Long, AttributeSet> load(long tenantId); @Override Map<String, Attribute> findAttributes(long tenantId, Long setId); }### Answer: @Test public void testFindByName() { AttributeSet set = dao.findByName("default", Tenant.DEFAULT_ID); Assert.assertNotNull(set); Assert.assertEquals(-1, set.getId()); Assert.assertEquals("default", set.getName()); set = dao.findByName("xxx", Tenant.DEFAULT_ID); Assert.assertNull(set); set = dao.findByName("default", 99L); Assert.assertNull(set); }
### Question: HibernateAttributeSetDAO extends HibernatePersistentObjectDAO<AttributeSet> implements AttributeSetDAO { @Override public Map<String, Attribute> findAttributes(long tenantId, Long setId) { List<AttributeSet> sets = new ArrayList<AttributeSet>(); if (setId != null) sets.add(findById(setId)); else sets.addAll(findAll(tenantId)); Map<String, Attribute> attributes = new TreeMap<String, Attribute>(); for (AttributeSet set : sets) { initialize(set); Map<String, Attribute> localAttributes = set.getAttributes(); for (String name : localAttributes.keySet()) if (!attributes.containsKey(name)) attributes.put(name, localAttributes.get(name)); } return attributes; } HibernateAttributeSetDAO(); @Override List<AttributeSet> findAll(); @Override List<AttributeSet> findAll(long tenantId); @Override AttributeSet findByName(String name, long tenantId); @Override boolean delete(long id, int code); @Override List<AttributeSet> findByType(int type, long tenantId); void setOptionsDao(AttributeOptionDAO optionsDao); @Override boolean store(AttributeSet set); void setTemplateDao(TemplateDAO templateDao); @Override Map<Long, AttributeSet> load(long tenantId); @Override Map<String, Attribute> findAttributes(long tenantId, Long setId); }### Answer: @Test public void testFindAttributes() { Map<String, Attribute> attributes = dao.findAttributes(1L, null); Assert.assertEquals(9, attributes.size()); Assert.assertTrue(attributes.containsKey("sourceAuthor")); }
### Question: HibernateTemplateDAO extends HibernatePersistentObjectDAO<Template> implements TemplateDAO { @Override public boolean delete(long id, int code) throws PersistenceException { if (!checkStoringAspect()) return false; boolean result = true; Template template = (Template) findById(id); if (countDocs(id) > 0) throw new PersistenceException(String.format("Some documents are referencing the template %s (%d)", template.getName(), template.getId())); if (countFolders(id) > 0) throw new PersistenceException(String.format("Some folders are referencing the template %s (%d)", template.getName(), template.getId())); if (template != null) { template.setDeleted(code); template.setName(template.getName() + "." + template.getId()); saveOrUpdate(template); } return result; } HibernateTemplateDAO(); @Override List<Template> findAll(); @Override List<Template> findAll(long tenantId); @Override Template findByName(String name, long tenantId); @Override boolean delete(long id, int code); int countFolders(long id); @Override int countDocs(long id); @Override List<Template> findByType(int type, long tenantId); @Override void initialize(Template template); }### Answer: @Test public void testDelete() throws PersistenceException { try { Assert.assertFalse(dao.delete(1)); } catch (PersistenceException e) { Assert.assertTrue(true); } Assert.assertTrue(dao.delete(-1L)); Template template = dao.findById(-1L); Assert.assertNull(template); }
### Question: HibernateTemplateDAO extends HibernatePersistentObjectDAO<Template> implements TemplateDAO { @Override public List<Template> findAll() { try { return findByWhere(" 1=1", "order by _entity.name", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Template>(); } } HibernateTemplateDAO(); @Override List<Template> findAll(); @Override List<Template> findAll(long tenantId); @Override Template findByName(String name, long tenantId); @Override boolean delete(long id, int code); int countFolders(long id); @Override int countDocs(long id); @Override List<Template> findByType(int type, long tenantId); @Override void initialize(Template template); }### Answer: @Test public void testFindAll() { Collection<Template> templates = dao.findAll(); Assert.assertNotNull(templates); Assert.assertEquals(4, templates.size()); }
### Question: HibernateTemplateDAO extends HibernatePersistentObjectDAO<Template> implements TemplateDAO { @Override public void initialize(Template template) { try { refresh(template); if (template.getAttributes() != null) template.getAttributes().keySet().size(); } catch (Throwable t) { } } HibernateTemplateDAO(); @Override List<Template> findAll(); @Override List<Template> findAll(long tenantId); @Override Template findByName(String name, long tenantId); @Override boolean delete(long id, int code); int countFolders(long id); @Override int countDocs(long id); @Override List<Template> findByType(int type, long tenantId); @Override void initialize(Template template); }### Answer: @Test public void testFindById() { Template template = dao.findById(1); Assert.assertNotNull(template); dao.initialize(template); Assert.assertEquals(1, template.getId()); Assert.assertEquals("test1", template.getName()); Assert.assertTrue(template.getAttributes().containsKey("attr1")); template = dao.findById(99); Assert.assertNull(template); template = dao.findById(-1); Assert.assertNotNull(template); dao.initialize(template); Assert.assertEquals(-1, template.getId()); Assert.assertEquals("default", template.getName()); Assert.assertTrue(template.getAttributes().containsKey("object")); } @Test public void testStore() throws PersistenceException { Template template = new Template(); template.setName("test3"); template.setValue("a1", "v1"); template.setValue("a2", "v2"); template.setValue("object", "value"); Assert.assertTrue(dao.store(template)); template = dao.findById(template.getId()); dao.initialize(template); Assert.assertEquals("test3", template.getName()); Assert.assertTrue(template.getAttributes().containsKey("a1")); Assert.assertTrue(template.getAttributes().containsKey("a2")); Assert.assertTrue(template.getAttributes().containsKey("object")); }
### Question: HibernateTemplateDAO extends HibernatePersistentObjectDAO<Template> implements TemplateDAO { @Override public Template findByName(String name, long tenantId) { Template template = null; try { List<Template> coll = findByWhere( "_entity.name = '" + SqlUtil.doubleQuotes(name) + "' and _entity.tenantId=" + tenantId, null, null); if (coll.size() > 0) template = coll.iterator().next(); if (template != null && template.getDeleted() == 1) template = null; } catch (PersistenceException e) { log.error(e.getMessage(), e); } return template; } HibernateTemplateDAO(); @Override List<Template> findAll(); @Override List<Template> findAll(long tenantId); @Override Template findByName(String name, long tenantId); @Override boolean delete(long id, int code); int countFolders(long id); @Override int countDocs(long id); @Override List<Template> findByType(int type, long tenantId); @Override void initialize(Template template); }### Answer: @Test public void testFindByName() { Template template = dao.findByName("test1", Tenant.DEFAULT_ID); Assert.assertNotNull(template); dao.initialize(template); Assert.assertEquals(1, template.getId()); Assert.assertEquals("test1", template.getName()); template = dao.findByName("xxx", Tenant.DEFAULT_ID); Assert.assertNull(template); template = dao.findByName("test1", 99L); Assert.assertNull(template); }
### Question: HibernateAttributeOptionDAO extends HibernatePersistentObjectDAO<AttributeOption> implements AttributeOptionDAO { @Override public void deleteOrphaned(long setId, Collection<String> currentAttributes) { try { if (currentAttributes == null || currentAttributes.isEmpty() || !checkStoringAspect()) return; StringBuffer buf = new StringBuffer(); for (String name : currentAttributes) { if (buf.length() == 0) buf.append("('"); else buf.append(",'"); buf.append(SqlUtil.doubleQuotes(name)); buf.append("'"); } buf.append(")"); List<AttributeOption> options = findByQuery( "from AttributeOption _opt where _opt.setId = ?1 and _opt.attribute not in " + buf.toString(), new Object[] { setId }, null); for (AttributeOption option : options) del(option, PersistentObject.DELETED_CODE_DEFAULT); } catch (Throwable e) { log.error(e.getMessage(), e); } } HibernateAttributeOptionDAO(); @Override boolean deleteBySetIdAndAttribute(long setId, String attribute); @Override List<AttributeOption> findBySetIdAndAttribute(long setId, String attribute); @Override boolean delete(long id, int code); @Override void deleteOrphaned(long setId, Collection<String> currentAttributes); }### Answer: @Test public void testDeleteOrphaned() { List<AttributeOption> options = dao.findBySetIdAndAttribute(1L, "att1"); Assert.assertEquals(2, options.size()); dao.deleteOrphaned(1L, (List<String>)Arrays.asList(new String[]{"pippo","pluto"})); options = dao.findBySetIdAndAttribute(1L, "att1"); Assert.assertEquals(0, options.size()); }
### Question: HibernateAttributeOptionDAO extends HibernatePersistentObjectDAO<AttributeOption> implements AttributeOptionDAO { @Override public List<AttributeOption> findBySetIdAndAttribute(long setId, String attribute) { List<AttributeOption> coll = new ArrayList<AttributeOption>(); try { if (StringUtils.isEmpty(attribute)) coll = (List<AttributeOption>) findByQuery( "from AttributeOption _opt where _opt.deleted=0 and _opt.setId = ?1 order by _opt.position asc", new Object[] { Long.valueOf(setId) }, null); else coll = (List<AttributeOption>) findByQuery( "from AttributeOption _opt where _opt.deleted=0 and _opt.setId = ?1 and _opt.attribute = ?2 order by _opt.position asc", new Object[] { Long.valueOf(setId), attribute }, null); } catch (Throwable e) { log.error(e.getMessage(), e); } return coll; } HibernateAttributeOptionDAO(); @Override boolean deleteBySetIdAndAttribute(long setId, String attribute); @Override List<AttributeOption> findBySetIdAndAttribute(long setId, String attribute); @Override boolean delete(long id, int code); @Override void deleteOrphaned(long setId, Collection<String> currentAttributes); }### Answer: @Test public void testFindByTemplateAndAttribute() { List<AttributeOption> options = dao.findBySetIdAndAttribute(1L, "att1"); Assert.assertEquals(2, options.size()); options = dao.findBySetIdAndAttribute(1L, null); Assert.assertEquals(3, options.size()); options = dao.findBySetIdAndAttribute(999L, null); Assert.assertEquals(0, options.size()); options = dao.findBySetIdAndAttribute(1L, "att2"); Assert.assertEquals(1, options.size()); options = dao.findBySetIdAndAttribute(2L, "att1"); Assert.assertEquals(1, options.size()); options = dao.findBySetIdAndAttribute(2L, null); Assert.assertEquals(1, options.size()); }
### Question: HibernateDocumentHistoryDAO extends HibernatePersistentObjectDAO<DocumentHistory> implements DocumentHistoryDAO { public List<DocumentHistory> findByUserId(long userId) { return findByUserIdAndEvent(userId, null, null); } private HibernateDocumentHistoryDAO(); List<DocumentHistory> findByDocId(long docId); @Override List<DocumentHistory> findByDocIdAndEvent(long docId, String event); List<DocumentHistory> findByUserId(long userId); List<DocumentHistory> findByFolderId(long folderId); @Override List<DocumentHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<DocumentHistory> findByUserIdAndEvent(long userId, String event, String sessionId); @Override void markHistoriesAsRead(String event, long userId); @Override boolean store(DocumentHistory history); @Override List<DocumentHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); }### Answer: @Test public void testDelete() throws PersistenceException { Collection<DocumentHistory> histories = (Collection<DocumentHistory>) dao.findByUserId(1); Assert.assertNotNull(histories); Assert.assertEquals(4, histories.size()); for (DocumentHistory history : histories) { boolean result = dao.delete(history.getId()); Assert.assertTrue(result); } histories = (Collection<DocumentHistory>) dao.findByUserId(4); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); } @SuppressWarnings("rawtypes") @Test public void testFindByUserId() { Collection histories = dao.findByUserId(1); Assert.assertNotNull(histories); Assert.assertEquals(4, histories.size()); histories = dao.findByUserId(99); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: TXTParser extends AbstractParser { @Override public String parse(File file, String filename, String encoding, Locale locale, String tenant) { FileInputStream fis = null; BufferedInputStream bis = null; try { fis = new FileInputStream(file); bis = new BufferedInputStream(fis); String enc = encoding; if (StringUtils.isEmpty(enc)) { try { CharsetDetector cd = new CharsetDetector(); cd.setText(bis); CharsetMatch cm = cd.detect(); if (cm != null) { if (Charset.isSupported(cm.getName())) enc = cm.getName(); } } catch (Throwable th) { log.warn("Error during TXT fileNameCharset detection", th); } } return parse(bis, filename, enc, locale, tenant); } catch (Throwable ex) { log.warn("Failed to extract TXT text content", ex); } finally { try { if (bis != null) bis.close(); if (fis != null) fis.close(); } catch (IOException e) { log.warn(e.getMessage(), e); } } return ""; } @Override String parse(File file, String filename, String encoding, Locale locale, String tenant); @Override void internalParse(InputStream input, String filename, String encoding, Locale locale, String tenant, StringBuffer content); }### Answer: @Test public void testParse() throws UnsupportedEncodingException, FileNotFoundException { String inputFile = "src/test/resources/AnalyzeFileTest_enc.txt"; File file = new File(inputFile); String filename = file.getPath(); Parser parser = ParserFactory.getParser(filename); TXTParser p = (TXTParser) parser; String content = p.parse(file, filename, null, Locale.ENGLISH, Tenant.DEFAULT_NAME); Assert.assertTrue(content.contains("scalpo")); content = p.parse(new FileInputStream(inputFile), filename, null, Locale.ENGLISH, Tenant.DEFAULT_NAME); Assert.assertTrue(content.contains("scalpo")); }
### Question: HibernateFolderHistoryDAO extends HibernatePersistentObjectDAO<FolderHistory> implements FolderHistoryDAO { @Override public List<FolderHistory> findByUserId(long userId) { return findByUserIdAndEvent(userId, null); } private HibernateFolderHistoryDAO(); @Override List<FolderHistory> findByUserId(long userId); @Override List<FolderHistory> findByFolderId(long folderId); @Override List<FolderHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<FolderHistory> findByUserIdAndEvent(long userId, String event); @Override boolean store(FolderHistory entity); @Override List<FolderHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); @Override List<FolderHistory> findByFolderIdAndEvent(long folderId, String event, Date oldestDate); }### Answer: @Test public void testDelete() throws PersistenceException { Collection<FolderHistory> histories = (Collection<FolderHistory>) dao.findByUserId(1); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); for (FolderHistory history : histories) { boolean result = dao.delete(history.getId()); Assert.assertTrue(result); } histories = (Collection<FolderHistory>) dao.findByUserId(4); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); } @SuppressWarnings("rawtypes") @Test public void testFindByUserId() { Collection histories = dao.findByUserId(1); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); histories = dao.findByUserId(99); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: HibernateFolderHistoryDAO extends HibernatePersistentObjectDAO<FolderHistory> implements FolderHistoryDAO { @Override public List<FolderHistory> findByFolderId(long folderId) { try { return findByWhere("_entity.folderId =" + folderId, "order by _entity.date asc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<FolderHistory>(); } } private HibernateFolderHistoryDAO(); @Override List<FolderHistory> findByUserId(long userId); @Override List<FolderHistory> findByFolderId(long folderId); @Override List<FolderHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<FolderHistory> findByUserIdAndEvent(long userId, String event); @Override boolean store(FolderHistory entity); @Override List<FolderHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); @Override List<FolderHistory> findByFolderIdAndEvent(long folderId, String event, Date oldestDate); }### Answer: @SuppressWarnings("rawtypes") @Test public void testFindByFolderId() { Collection histories = dao.findByFolderId(5); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); histories = dao.findByFolderId(99); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: HibernateFolderHistoryDAO extends HibernatePersistentObjectDAO<FolderHistory> implements FolderHistoryDAO { @Override public List<FolderHistory> findNotNotified(Integer max) { try { return findByWhere("_entity.notified = 0", "order by _entity.date asc", max); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<FolderHistory>(); } } private HibernateFolderHistoryDAO(); @Override List<FolderHistory> findByUserId(long userId); @Override List<FolderHistory> findByFolderId(long folderId); @Override List<FolderHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<FolderHistory> findByUserIdAndEvent(long userId, String event); @Override boolean store(FolderHistory entity); @Override List<FolderHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); @Override List<FolderHistory> findByFolderIdAndEvent(long folderId, String event, Date oldestDate); }### Answer: @SuppressWarnings("rawtypes") @Test public void testFindNotNotified() throws PersistenceException { Collection histories = dao.findNotNotified(null); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); FolderHistory history = dao.findById(3); dao.initialize(history); history.setNotified(1); dao.store(history); histories = dao.findNotNotified(null); Assert.assertNotNull(histories); Assert.assertEquals(1, histories.size()); }
### Question: HibernateFolderHistoryDAO extends HibernatePersistentObjectDAO<FolderHistory> implements FolderHistoryDAO { @Override public void cleanOldHistories(int ttl) { if (ttl > 0) { Date today = new Date(); GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.DAY_OF_MONTH, -ttl); Date ldDate = cal.getTime(); try { int rowsUpdated = jdbcUpdate("UPDATE ld_folder_history SET ld_deleted = 1, ld_lastmodified = ?" + " WHERE ld_deleted = 0 AND ld_date < ?", today, ldDate); log.info("cleanOldHistories rows updated: " + rowsUpdated); } catch (Exception e) { if (log.isErrorEnabled()) log.error(e.getMessage(), e); } } } private HibernateFolderHistoryDAO(); @Override List<FolderHistory> findByUserId(long userId); @Override List<FolderHistory> findByFolderId(long folderId); @Override List<FolderHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<FolderHistory> findByUserIdAndEvent(long userId, String event); @Override boolean store(FolderHistory entity); @Override List<FolderHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); @Override List<FolderHistory> findByFolderIdAndEvent(long folderId, String event, Date oldestDate); }### Answer: @SuppressWarnings("rawtypes") @Test public void testCleanOldHistories() { dao.cleanOldHistories(5); FolderHistory history = dao.findById(3); Assert.assertNull(history); Collection histories = dao.findAll(); Assert.assertEquals(0, histories.size()); }
### Question: HibernateFolderHistoryDAO extends HibernatePersistentObjectDAO<FolderHistory> implements FolderHistoryDAO { @Override public List<FolderHistory> findByUserIdAndEvent(long userId, String event) { String query = "_entity.userId =" + userId; if (event != null && StringUtils.isNotEmpty(event)) query += " and lower(_entity.event) like '" + SqlUtil.doubleQuotes(event.toLowerCase()) + "'"; try { return findByWhere(query, "order by _entity.date asc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<FolderHistory>(); } } private HibernateFolderHistoryDAO(); @Override List<FolderHistory> findByUserId(long userId); @Override List<FolderHistory> findByFolderId(long folderId); @Override List<FolderHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<FolderHistory> findByUserIdAndEvent(long userId, String event); @Override boolean store(FolderHistory entity); @Override List<FolderHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); @Override List<FolderHistory> findByFolderIdAndEvent(long folderId, String event, Date oldestDate); }### Answer: @SuppressWarnings("rawtypes") @Test public void testFindByUserIdAndEvent() { Collection histories = dao.findByUserIdAndEvent(1, "data test 03"); Assert.assertNotNull(histories); Assert.assertEquals(1, histories.size()); histories = dao.findByUserIdAndEvent(1, "data test 04"); Assert.assertNotNull(histories); Assert.assertEquals(1, histories.size()); histories = dao.findByUserIdAndEvent(2, "data test 04"); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); histories = dao.findByUserIdAndEvent(99, "data test 04"); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: HibernateDocumentHistoryDAO extends HibernatePersistentObjectDAO<DocumentHistory> implements DocumentHistoryDAO { public List<DocumentHistory> findByDocId(long docId) { return findByDocIdAndEvent(docId, null); } private HibernateDocumentHistoryDAO(); List<DocumentHistory> findByDocId(long docId); @Override List<DocumentHistory> findByDocIdAndEvent(long docId, String event); List<DocumentHistory> findByUserId(long userId); List<DocumentHistory> findByFolderId(long folderId); @Override List<DocumentHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<DocumentHistory> findByUserIdAndEvent(long userId, String event, String sessionId); @Override void markHistoriesAsRead(String event, long userId); @Override boolean store(DocumentHistory history); @Override List<DocumentHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); }### Answer: @SuppressWarnings("rawtypes") @Test public void testFindByDocId() { Collection histories = dao.findByDocId(1); Assert.assertNotNull(histories); Assert.assertEquals(3, histories.size()); histories = dao.findByDocId(99); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: HibernateContactDAO extends HibernatePersistentObjectDAO<Contact> implements ContactDAO { @Override public List<Contact> findByUser(Long userId, String email) { List<Object> params = new ArrayList<Object>(); if (userId != null) params.add(userId); if (email != null) params.add(email); StringBuffer sb = new StringBuffer(""); if (userId == null) sb.append(" _entity.userId is null "); else sb.append(" _entity.userId = ?1 "); if (email != null) sb.append(" and _entity.email = ?2 "); try { return findByWhere(sb.toString(), params.isEmpty() ? null : params.toArray(new Object[0]), "order by _entity.firstName, _entity.lastName", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Contact>(); } } HibernateContactDAO(); @Override List<Contact> findByUser(Long userId, String email); }### Answer: @Test public void testFindByUser() { List<Contact> contacts = dao.findByUser(null, null); Assert.assertEquals(1, contacts.size()); contacts = dao.findByUser(1L, null); Assert.assertEquals(2, contacts.size()); contacts = dao.findByUser(1L, "alessandro@acme.com"); Assert.assertEquals(1, contacts.size()); contacts = dao.findByUser(1L, "xxx"); Assert.assertEquals(0, contacts.size()); }
### Question: HibernateMessageTemplateDAO extends HibernatePersistentObjectDAO<MessageTemplate> implements MessageTemplateDAO { @Override public List<MessageTemplate> findByLanguage(String language, long tenantId) { try { return findByWhere(" _entity.language='" + language + "' and _entity.tenantId=" + tenantId, "order by _entity.name", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<MessageTemplate>(); } } HibernateMessageTemplateDAO(); @Override List<MessageTemplate> findByLanguage(String language, long tenantId); @Override List<MessageTemplate> findByTypeAndLanguage(String type, String language, long tenantId); @Override MessageTemplate findByNameAndLanguage(String name, String language, long tenantId); @Override boolean delete(long id, int code); @Override List<MessageTemplate> findByName(String name, long tenantId); }### Answer: @Test public void testFindByLanguage() { Collection<MessageTemplate> coll = dao.findByLanguage("en", 1L); Assert.assertEquals(6, coll.size()); coll = dao.findByLanguage("it", 1L); Assert.assertEquals(1, coll.size()); coll = dao.findByLanguage("de", 1L); Assert.assertEquals(0, coll.size()); }
### Question: HibernateMessageTemplateDAO extends HibernatePersistentObjectDAO<MessageTemplate> implements MessageTemplateDAO { @Override public List<MessageTemplate> findByName(String name, long tenantId) { try { return findByWhere(" _entity.name='" + SqlUtil.doubleQuotes(name) + "' and _entity.tenantId=" + tenantId, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<MessageTemplate>(); } } HibernateMessageTemplateDAO(); @Override List<MessageTemplate> findByLanguage(String language, long tenantId); @Override List<MessageTemplate> findByTypeAndLanguage(String type, String language, long tenantId); @Override MessageTemplate findByNameAndLanguage(String name, String language, long tenantId); @Override boolean delete(long id, int code); @Override List<MessageTemplate> findByName(String name, long tenantId); }### Answer: @Test public void testFindByName() { Collection<MessageTemplate> coll = dao.findByName("psw.rec1", 1L); Assert.assertEquals(1, coll.size()); coll = dao.findByName("psw.rec1", 2L); Assert.assertEquals(0, coll.size()); coll = dao.findByName("xxxxx", 1L); Assert.assertEquals(0, coll.size()); }
### Question: HibernateMessageTemplateDAO extends HibernatePersistentObjectDAO<MessageTemplate> implements MessageTemplateDAO { @Override public List<MessageTemplate> findByTypeAndLanguage(String type, String language, long tenantId) { StringBuffer query = new StringBuffer("_entity.language='" + language + "' "); query.append(" and _entity.tenantId=" + tenantId); if (StringUtils.isNotEmpty(type)) query.append(" and _entity.type='" + type + "' "); try { return findByWhere(query.toString(), "order by _entity.name", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<MessageTemplate>(); } } HibernateMessageTemplateDAO(); @Override List<MessageTemplate> findByLanguage(String language, long tenantId); @Override List<MessageTemplate> findByTypeAndLanguage(String type, String language, long tenantId); @Override MessageTemplate findByNameAndLanguage(String name, String language, long tenantId); @Override boolean delete(long id, int code); @Override List<MessageTemplate> findByName(String name, long tenantId); }### Answer: @Test public void testFindByTypeLanguage() { Collection<MessageTemplate> coll = dao.findByTypeAndLanguage(MessageTemplate.TYPE_SYSTEM,"en", 1L); Assert.assertEquals(4, coll.size()); coll = dao.findByTypeAndLanguage("xxx","en", 1L); Assert.assertEquals(0, coll.size()); }
### Question: HibernateSystemMessageDAO extends HibernatePersistentObjectDAO<SystemMessage> implements SystemMessageDAO { public void deleteExpiredMessages(String recipient) { collectGarbage(findByRecipient(recipient, SystemMessage.TYPE_SYSTEM, null), true); } HibernateSystemMessageDAO(); @Override List<SystemMessage> findByRecipient(String recipient, int type, Integer read); @Override int getUnreadCount(String recipient, int type); void deleteExpiredMessages(String recipient); void deleteExpiredMessages(int type); @Override List<SystemMessage> findByMode(String mode); @Override List<SystemMessage> findByType(int type); @Override void initialize(SystemMessage message); @Override List<SystemMessage> findMessagesToBeSent(int type, int maxTrial); @Override boolean store(SystemMessage message); }### Answer: @Test public void testDeleteExpiredMessages() { dao.deleteExpiredMessages("sebastian"); Assert.assertNotNull(dao.findById(1)); dao.deleteExpiredMessages(SystemMessage.TYPE_SYSTEM); Assert.assertNotNull(dao.findById(1)); }
### Question: HibernateSystemMessageDAO extends HibernatePersistentObjectDAO<SystemMessage> implements SystemMessageDAO { @Override public int getUnreadCount(String recipient, int type) { String sql = "select count(distinct(R.ld_messageid)) from ld_recipient R, ld_systemmessage M " + " where R.ld_name = '" + SqlUtil.doubleQuotes(recipient) + "' and R.ld_messageid=M.ld_id and M.ld_deleted=0 and M.ld_type=" + type + " and R.ld_read=0"; try { return queryForInt(sql); } catch (PersistenceException e) { log.error(e.getMessage(), e); return 0; } } HibernateSystemMessageDAO(); @Override List<SystemMessage> findByRecipient(String recipient, int type, Integer read); @Override int getUnreadCount(String recipient, int type); void deleteExpiredMessages(String recipient); void deleteExpiredMessages(int type); @Override List<SystemMessage> findByMode(String mode); @Override List<SystemMessage> findByType(int type); @Override void initialize(SystemMessage message); @Override List<SystemMessage> findMessagesToBeSent(int type, int maxTrial); @Override boolean store(SystemMessage message); }### Answer: @Test public void testGetUnreadCount() { Assert.assertEquals(1, dao.getUnreadCount("sebastian", SystemMessage.TYPE_SYSTEM)); Assert.assertEquals(2, dao.getUnreadCount("marco", 1)); Assert.assertEquals(0, dao.getUnreadCount("admin", SystemMessage.TYPE_SYSTEM)); }
### Question: HibernateSystemMessageDAO extends HibernatePersistentObjectDAO<SystemMessage> implements SystemMessageDAO { @Override public List<SystemMessage> findByType(int type) { String sql = "select ld_lastmodified, ld_author, ld_messagetext, ld_subject, ld_sentdate, ld_datescope, ld_prio, ld_confirmation, ld_lastnotified, ld_status, ld_trials, ld_type, ld_id, ld_html, ld_author, ld_tenantid " + " from ld_systemmessage where ld_deleted = 0 and ld_id IN (select ld_messageid from ld_recipient where ld_type = " + type + ") order by ld_sentdate desc"; try { List<SystemMessage> messages = (List<SystemMessage>) query(sql, null, new SystemMessageMapper(), null); return messages; } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<SystemMessage>(); } } HibernateSystemMessageDAO(); @Override List<SystemMessage> findByRecipient(String recipient, int type, Integer read); @Override int getUnreadCount(String recipient, int type); void deleteExpiredMessages(String recipient); void deleteExpiredMessages(int type); @Override List<SystemMessage> findByMode(String mode); @Override List<SystemMessage> findByType(int type); @Override void initialize(SystemMessage message); @Override List<SystemMessage> findMessagesToBeSent(int type, int maxTrial); @Override boolean store(SystemMessage message); }### Answer: @Test public void testFindByType() { Collection<SystemMessage> coll = dao.findByType(0); Assert.assertEquals(2, coll.size()); coll = dao.findByType(1); Assert.assertEquals(2, coll.size()); coll = dao.findByType(2); Assert.assertEquals(1, coll.size()); coll = dao.findByType(3); Assert.assertEquals(0, coll.size()); }
### Question: HibernateSystemMessageDAO extends HibernatePersistentObjectDAO<SystemMessage> implements SystemMessageDAO { @Override public List<SystemMessage> findByMode(String mode) { String sql = "select ld_lastmodified, ld_author, ld_messagetext, ld_subject, ld_sentdate, ld_datescope, ld_prio, ld_confirmation, ld_lastnotified, ld_status, ld_trials, ld_type, ld_id, ld_html, ld_author, ld_tenantid " + " from ld_systemmessage where ld_deleted = 0 and ld_id IN (select ld_messageid from ld_recipient where ld_mode = '" + SqlUtil.doubleQuotes(mode) + "') order by ld_sentdate desc"; try { List<SystemMessage> messages = (List<SystemMessage>) query(sql, null, new SystemMessageMapper(), null); return messages; } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<SystemMessage>(); } } HibernateSystemMessageDAO(); @Override List<SystemMessage> findByRecipient(String recipient, int type, Integer read); @Override int getUnreadCount(String recipient, int type); void deleteExpiredMessages(String recipient); void deleteExpiredMessages(int type); @Override List<SystemMessage> findByMode(String mode); @Override List<SystemMessage> findByType(int type); @Override void initialize(SystemMessage message); @Override List<SystemMessage> findMessagesToBeSent(int type, int maxTrial); @Override boolean store(SystemMessage message); }### Answer: @Test public void testFindByMode() { Collection<SystemMessage> coll = dao.findByMode("CC"); Assert.assertEquals(1, coll.size()); coll = dao.findByMode("sms"); Assert.assertEquals(2, coll.size()); coll = dao.findByMode("socket"); Assert.assertEquals(0, coll.size()); coll = dao.findByMode("xxxx"); Assert.assertEquals(0, coll.size()); }
### Question: MailUtil { private static MimeMessage readMime(InputStream is) throws MessagingException { Properties props = System.getProperties(); props.put("mail.transport.protocol", "smtp"); props.put("mail.smtp.provider.class", CustomTransport.class.getName()); props.put("mail.smtp.provider.vendor", "foo"); props.put("mail.smtp.provider.version", "0.0.0"); props.put("mail.transport.protocol", "smtp"); try { Session mailSession = Session.getInstance(props, null); MimeMessage msg = new MimeMessage(mailSession, is); return msg; } catch (Throwable t) { t.printStackTrace(); } return null; } static boolean emlContainsAttachments(InputStream is); static EMail msgToMail(InputStream is, boolean extractAttachmentContent); static EMail msgToMail(File msgFile, boolean extractAttachmentContent); static EMail messageToMail(InputStream is, boolean extractAttachmentContent); static EMail messageToMail(File emlFile, boolean extractAttachmentContent); static EMail messageToMail(javax.mail.Message msg, boolean extractAttachmentContent); static String getAddressName(Address a); static String getAddressEmail(Address a); static boolean msgContainsAttachments(File msgFile); static boolean msgContainsAttachments(InputStream is); static boolean emlContainsAttachments(File emlFile); static final String NO_SUBJECT; static final String NO_BODY; }### Answer: @Test public void testReadMime() throws Exception { EMail mail = MailUtil.messageToMail(new File("src/test/resources/fattura.eml"), false); Assert.assertNotNull(mail); }
### Question: HibernateDashletDAO extends HibernatePersistentObjectDAO<Dashlet> implements DashletDAO { @Override public Dashlet findByName(String name, long tenantId) { List<Dashlet> dashlets = new ArrayList<Dashlet>(); try { dashlets = findByWhere("_entity.tenantId = ?1 and _entity.name = ?2", new Object[] { tenantId, name }, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); } return dashlets != null && dashlets.size() > 0 ? dashlets.get(0) : null; } protected HibernateDashletDAO(); @Override Dashlet findByName(String name, long tenantId); @Override boolean delete(long id, int code); }### Answer: @Test public void testFindByName() { Dashlet dashlet = dao.findByName("checkout", 1L); Assert.assertNotNull(dashlet); Assert.assertEquals(1L, dashlet.getId()); dashlet = dao.findByName("xxxx", 1L); Assert.assertNull(dashlet); }
### Question: HibernateGenericDAO extends HibernatePersistentObjectDAO<Generic> implements GenericDAO { @Override public boolean delete(long genericId, int code) throws PersistenceException { assert (code != 0); if (!checkStoringAspect()) return false; boolean result = true; Generic generic = findById(genericId); if (generic != null) { generic.setType(generic.getType() + "." + generic.getId()); generic.setSubtype(generic.getSubtype() + "." + generic.getId()); generic.setDeleted(code); saveOrUpdate(generic); flush(); } return result; } HibernateGenericDAO(); @Override boolean delete(long genericId, int code); @Override Generic findByAlternateKey(String type, String subtype, Long qualifier, long tenantId); @Override List<Generic> findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId); @Override void initialize(Generic generic); @Override boolean store(Generic entity); }### Answer: @Test public void testDelete() throws PersistenceException { Assert.assertNotNull(dao.findById(1L)); dao.delete(1L); Assert.assertNull(dao.findById(1L)); }
### Question: HibernateGenericDAO extends HibernatePersistentObjectDAO<Generic> implements GenericDAO { @Override public Generic findByAlternateKey(String type, String subtype, Long qualifier, long tenantId) { Generic generic = null; StringBuffer sb = new StringBuffer(" _entity.type = '" + SqlUtil.doubleQuotes(type) + "' and _entity.subtype='" + SqlUtil.doubleQuotes(subtype) + "' "); sb.append(" and _entity.tenantId=" + tenantId); if (qualifier != null) sb.append(" and _entity.qualifier=" + qualifier); else sb.append(" and _entity.qualifier is null"); try { Collection<Generic> coll = findByWhere(sb.toString(), null, null); if (coll.size() > 0) generic = coll.iterator().next(); } catch (PersistenceException e) { log.error(e.getMessage(), e); } return generic; } HibernateGenericDAO(); @Override boolean delete(long genericId, int code); @Override Generic findByAlternateKey(String type, String subtype, Long qualifier, long tenantId); @Override List<Generic> findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId); @Override void initialize(Generic generic); @Override boolean store(Generic entity); }### Answer: @Test public void testFindByAlternateKey() { Generic generic = dao.findByAlternateKey("a", "a1", null, Tenant.DEFAULT_ID); Assert.assertNotNull(generic); Assert.assertEquals(new Long(0), generic.getInteger1()); generic = dao.findByAlternateKey("a", "xxx", null, 99L); Assert.assertNull(generic); }
### Question: HibernateGenericDAO extends HibernatePersistentObjectDAO<Generic> implements GenericDAO { @Override public List<Generic> findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId) { String query = " 1=1 "; if (StringUtils.isNotEmpty(type)) query += " and _entity.type like '" + SqlUtil.doubleQuotes(type) + "' "; if (StringUtils.isNotEmpty(subtype)) query += " and _entity.subtype like '" + SqlUtil.doubleQuotes(subtype) + "' "; if (qualifier != null) query += " and _entity.qualifier = " + qualifier; if (tenantId != null) query += " and _entity.tenantId = " + tenantId; try { return findByWhere(query, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Generic>(); } } HibernateGenericDAO(); @Override boolean delete(long genericId, int code); @Override Generic findByAlternateKey(String type, String subtype, Long qualifier, long tenantId); @Override List<Generic> findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId); @Override void initialize(Generic generic); @Override boolean store(Generic entity); }### Answer: @Test public void testFindByTypeAndSubtype() { List<Generic> generics = dao.findByTypeAndSubtype("a", "a%", null, null); Assert.assertEquals(2, generics.size()); generics = dao.findByTypeAndSubtype("a", "a%", null, Tenant.DEFAULT_ID); Assert.assertEquals(2, generics.size()); generics = dao.findByTypeAndSubtype("a", "a%", null, 99L); Assert.assertEquals(0, generics.size()); }
### Question: HibernateDocumentHistoryDAO extends HibernatePersistentObjectDAO<DocumentHistory> implements DocumentHistoryDAO { public List<DocumentHistory> findByFolderId(long folderId) { try { return findByWhere("_entity.folderId =" + folderId, "order by _entity.date asc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<DocumentHistory>(); } } private HibernateDocumentHistoryDAO(); List<DocumentHistory> findByDocId(long docId); @Override List<DocumentHistory> findByDocIdAndEvent(long docId, String event); List<DocumentHistory> findByUserId(long userId); List<DocumentHistory> findByFolderId(long folderId); @Override List<DocumentHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<DocumentHistory> findByUserIdAndEvent(long userId, String event, String sessionId); @Override void markHistoriesAsRead(String event, long userId); @Override boolean store(DocumentHistory history); @Override List<DocumentHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); }### Answer: @SuppressWarnings("rawtypes") @Test public void testFindByFolderId() { Collection histories = dao.findByFolderId(5); Assert.assertNotNull(histories); Assert.assertEquals(2, histories.size()); histories = dao.findByFolderId(99); Assert.assertNotNull(histories); Assert.assertEquals(0, histories.size()); }
### Question: HibernateGenericDAO extends HibernatePersistentObjectDAO<Generic> implements GenericDAO { @Override public boolean store(Generic entity) throws PersistenceException { boolean stored = super.store(entity); flush(); return stored; } HibernateGenericDAO(); @Override boolean delete(long genericId, int code); @Override Generic findByAlternateKey(String type, String subtype, Long qualifier, long tenantId); @Override List<Generic> findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId); @Override void initialize(Generic generic); @Override boolean store(Generic entity); }### Answer: @Test public void testStore() throws PersistenceException { Generic generic = new Generic(); generic.setType("xx"); generic.setSubtype("xxx"); generic.setInteger1(22L); generic.setString1("aaa"); Assert.assertTrue(dao.store(generic)); generic = dao.findById(generic.getId()); Assert.assertEquals("xx", generic.getType()); Assert.assertEquals("xxx", generic.getSubtype()); Assert.assertEquals(new Long(22), generic.getInteger1()); Assert.assertEquals("aaa", generic.getString1()); }
### Question: HibernateGenericDAO extends HibernatePersistentObjectDAO<Generic> implements GenericDAO { @Override public void initialize(Generic generic) { refresh(generic); for (String attribute : generic.getAttributes().keySet()) { if (generic.getValue(attribute) != null) generic.getValue(attribute).toString(); } } HibernateGenericDAO(); @Override boolean delete(long genericId, int code); @Override Generic findByAlternateKey(String type, String subtype, Long qualifier, long tenantId); @Override List<Generic> findByTypeAndSubtype(String type, String subtype, Long qualifier, Long tenantId); @Override void initialize(Generic generic); @Override boolean store(Generic entity); }### Answer: @Test public void testInitialize() { Generic generic = dao.findById(1); Assert.assertNotNull(generic); Assert.assertEquals(new Long(0), generic.getInteger1()); dao.initialize(generic); Assert.assertEquals(1, generic.getAttributes().size()); Assert.assertEquals("val1", generic.getValue("att1")); }
### Question: LockManager { public boolean get(String lockName, String transactionId) { GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.SECOND, config.getInt("lock.wait")); Date ldDate = cal.getTime(); while (new Date().before(ldDate)) { if (getInternal(lockName, transactionId)) { log.debug("Acquired lock " + lockName); return true; } else try { Thread.sleep(1000); } catch (InterruptedException e) { } } log.warn("Unable to get lock " + lockName); return false; } @SuppressWarnings("unchecked") List<String> getAllTransactions(); boolean get(String lockName, String transactionId); void release(String lockName, String transactionId); void setGenericDao(GenericDAO genericDao); void setConfig(ContextProperties config); }### Answer: @Test public void testGet() { Assert.assertTrue(manager.get("test", "t1")); Assert.assertTrue(manager.get("test", "t1")); Assert.assertFalse(manager.get("test", "t2")); try { Thread.sleep(3000); } catch (InterruptedException e) { } Assert.assertTrue(manager.get("test", "t2")); manager.release("test", "t2"); Generic lock = dao.findByAlternateKey("lock", "test-" + config.getProperty("id"), null, Tenant.DEFAULT_ID); Assert.assertNotNull(lock); Assert.assertNull(lock.getString1()); Assert.assertNull(lock.getDate1()); }
### Question: ResourceUtil { public static boolean existsResource(String resourceName) { InputStream is = null; try { try { is = new BufferedInputStream(FileUtil.class.getResource(resourceName).openStream()); } catch (Throwable e) { is = new BufferedInputStream( Thread.currentThread().getContextClassLoader().getResource(resourceName).openStream()); } return is != null; } catch (Throwable e) { return false; } finally { if (is != null) try { is.close(); } catch (IOException e) { } } } static String readAsString(String resourceName); static void copyResource(String classpath, File out); static boolean existsResource(String resourceName); }### Answer: @Test public void testExistsResource() throws IOException { Assert.assertTrue(ResourceUtil.existsResource("/context.xml")); Assert.assertFalse(ResourceUtil.existsResource("/test.txt")); }
### Question: HibernateDocumentHistoryDAO extends HibernatePersistentObjectDAO<DocumentHistory> implements DocumentHistoryDAO { @Override public List<DocumentHistory> findNotNotified(Integer max) { try { return findByWhere("_entity.notified = 0", "order by _entity.date asc", max); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<DocumentHistory>(); } } private HibernateDocumentHistoryDAO(); List<DocumentHistory> findByDocId(long docId); @Override List<DocumentHistory> findByDocIdAndEvent(long docId, String event); List<DocumentHistory> findByUserId(long userId); List<DocumentHistory> findByFolderId(long folderId); @Override List<DocumentHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<DocumentHistory> findByUserIdAndEvent(long userId, String event, String sessionId); @Override void markHistoriesAsRead(String event, long userId); @Override boolean store(DocumentHistory history); @Override List<DocumentHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); }### Answer: @SuppressWarnings("rawtypes") @Test public void testFindNotNotified() throws PersistenceException { Collection histories = dao.findNotNotified(null); Assert.assertNotNull(histories); Assert.assertEquals(4, histories.size()); DocumentHistory history = dao.findById(1); dao.initialize(history); history.setNotified(1); dao.store(history); histories = dao.findNotNotified(null); Assert.assertNotNull(histories); Assert.assertEquals(3, histories.size()); }
### Question: MessageServiceImpl extends RemoteServiceServlet implements MessageService { @Override public void delete(long[] ids) throws ServerException { ServiceUtil.validateSession(getThreadLocalRequest()); Context context = Context.get(); SystemMessageDAO dao = (SystemMessageDAO) context.getBean(SystemMessageDAO.class); for (long id : ids) { boolean deleted = false; try { deleted = dao.delete(id); } catch (PersistenceException e) { deleted = false; log.error(e.getMessage(), e); } if (!deleted) throw new ServerException("Messages have not been deleted"); } } @Override void delete(long[] ids); @Override GUIMessage getMessage(long messageId, boolean markAsRead); @Override void save(GUIMessage message, long[] recipientIds); @Override GUIMessageTemplate[] loadTemplates(String language, String type); @Override void saveTemplates(GUIMessageTemplate[] templates); @Override void deleteTemplates(long[] ids); @Override void deleteTemplates(String name); @Override GUIMessageTemplate getTemplate(long templateId); }### Answer: @Test public void testDelete() throws ServerException { service.deleteTemplates("psw.rec1"); MessageTemplate template = templateDao.findById(2L); Assert.assertNotNull(template); template = templateDao.findById(500L); Assert.assertNotNull(template); service.deleteTemplates("test"); template = templateDao.findById(500L); Assert.assertNull(template); }
### Question: HibernateDocumentHistoryDAO extends HibernatePersistentObjectDAO<DocumentHistory> implements DocumentHistoryDAO { @Override public void cleanOldHistories(int ttl) { if (ttl > 0) { Date today = new Date(); GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.DAY_OF_MONTH, -ttl); Date ldDate = cal.getTime(); log.debug("today: {}", today); log.debug("ldDate: {}", ldDate); try { int rowsUpdated = jdbcUpdate("UPDATE ld_history SET ld_deleted = 1, ld_lastmodified = ?" + " WHERE ld_deleted = 0 AND ld_date < ?", today, ldDate); log.info("cleanOldHistories rows updated: {}", rowsUpdated); } catch (Exception e) { if (log.isErrorEnabled()) log.error(e.getMessage(), e); } } } private HibernateDocumentHistoryDAO(); List<DocumentHistory> findByDocId(long docId); @Override List<DocumentHistory> findByDocIdAndEvent(long docId, String event); List<DocumentHistory> findByUserId(long userId); List<DocumentHistory> findByFolderId(long folderId); @Override List<DocumentHistory> findNotNotified(Integer max); @Override void cleanOldHistories(int ttl); @Override List<DocumentHistory> findByUserIdAndEvent(long userId, String event, String sessionId); @Override void markHistoriesAsRead(String event, long userId); @Override boolean store(DocumentHistory history); @Override List<DocumentHistory> findByPath(String pathExpression, Date olderDate, Collection<String> events, Integer max); }### Answer: @SuppressWarnings("rawtypes") @Test public void testCleanOldHistories() { dao.cleanOldHistories(5); DocumentHistory history = dao.findById(1); Assert.assertNull(history); Collection histories = dao.findAll(); Assert.assertEquals(0, histories.size()); }
### Question: TemplateServiceImpl extends RemoteServiceServlet implements TemplateService { @Override public void delete(long templateId) throws ServerException { Session session = ServiceUtil.validateSession(getThreadLocalRequest()); try { TemplateDAO dao = (TemplateDAO) Context.get().getBean(TemplateDAO.class); boolean deleted = dao.delete(templateId); if (!deleted) throw new Exception("Template has not been deleted"); } catch (Throwable t) { ServiceUtil.throwServerException(session, log, t); } } @Override void delete(long templateId); @Override long countDocuments(long templateId); @Override GUITemplate save(GUITemplate template); @Override GUITemplate getTemplate(long templateId); }### Answer: @Test public void testDelete() throws ServerException { service.delete(1); Template template = templateDao.findById(1); Assert.assertNull(template); }
### Question: SoapBookmarkService extends AbstractService implements BookmarkService { @Override public WSBookmark bookmarkDocument(String sid, long docId) throws Exception { User user = validateSession(sid); WSDocument doc = checkDocumentAvailable(sid, docId); BookmarkDAO bDao = (BookmarkDAO) Context.get().getBean(BookmarkDAO.class); Bookmark bmark = bDao.findByUserIdAndDocId(user.getId(), docId); if (bmark == null) { bmark = new Bookmark(); bmark.setType(Bookmark.TYPE_DOCUMENT); bmark.setFileType(doc.getFileName()); bmark.setFileType(doc.getType()); bmark.setUserId(user.getId()); bmark.setTargetId(docId); bDao.store(bmark); } return WSBookmark.fromBookmark(bmark); } @Override WSBookmark saveBookmark(String sid, WSBookmark bookmark); @Override WSBookmark bookmarkDocument(String sid, long docId); @Override WSBookmark bookmarkFolder(String sid, long folderId); @Override WSBookmark[] getBookmarks(String sid); @Override void deleteBookmark(String sid, long bookmarkId); @Override void unbookmarkDocument(String sid, long docId); @Override void unbookmarkFolder(String sid, long folderId); }### Answer: @Test public void testBookmarkDocument() throws Exception { bookmarkService.bookmarkDocument("", 1L); bookmarkService.bookmarkDocument("", 2L); WSBookmark[] bookmarks = bookmarkService.getBookmarks(""); Assert.assertEquals(2, bookmarks.length); try { bookmarkService.bookmarkDocument("", 3L); Assert.fail("the document doesn't exist, why exception was not raised."); } catch (Throwable t) { } }
### Question: SoapBookmarkService extends AbstractService implements BookmarkService { @Override public WSBookmark bookmarkFolder(String sid, long folderId) throws Exception { checkFolderAvailable(sid, folderId); User user = validateSession(sid); WSFolder folder = checkFolderAvailable(sid, folderId); BookmarkDAO bDao = (BookmarkDAO) Context.get().getBean(BookmarkDAO.class); Bookmark bmark = bDao.findByUserIdAndDocId(user.getId(), folderId); if (bmark == null) { bmark = new Bookmark(); bmark.setType(Bookmark.TYPE_DOCUMENT); bmark.setTitle(folder.getName()); bmark.setFileType("folder"); bmark.setUserId(user.getId()); bmark.setTargetId(folderId); bDao.store(bmark); } return WSBookmark.fromBookmark(bmark); } @Override WSBookmark saveBookmark(String sid, WSBookmark bookmark); @Override WSBookmark bookmarkDocument(String sid, long docId); @Override WSBookmark bookmarkFolder(String sid, long folderId); @Override WSBookmark[] getBookmarks(String sid); @Override void deleteBookmark(String sid, long bookmarkId); @Override void unbookmarkDocument(String sid, long docId); @Override void unbookmarkFolder(String sid, long folderId); }### Answer: @Test public void testBookmarkFolder() throws Exception { bookmarkService.bookmarkFolder("", 5L); bookmarkService.bookmarkFolder("", 4L); WSBookmark[] bookmarks = bookmarkService.getBookmarks(""); Assert.assertEquals(2, bookmarks.length); try { bookmarkService.bookmarkDocument("", 99L); Assert.fail("the folder doesn't exist, why exception was not raised."); } catch (Throwable t) { } }
### Question: SoapTagService extends AbstractService implements TagService { @Override public void addDocumentTags(String sid, long docId, String[] tags) throws Exception { SoapDocumentService docService = getDocumentService(); WSDocument doc = docService.getDocument(sid, docId); if (doc == null) return; User user = validateSession(sid); checkWriteEnable(user, doc.getFolderId()); for (String tag : tags) doc.addTag(tag); docService.update(sid, doc); } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testAddDocumentTags() throws Exception { WSDocument[] documents = tagService.findDocumentsByTag("", "abc"); Assert.assertNotNull(documents); Assert.assertEquals(1, documents.length); tagService.addDocumentTags("", documents[0].getId(), new String[] { "pippo", "pluto" }); documents = tagService.findDocumentsByTag("", "pippo"); Assert.assertNotNull(documents); Assert.assertEquals(1, documents.length); }
### Question: SoapTagService extends AbstractService implements TagService { @Override public void addFolderTags(String sid, long folderId, String[] tags) throws Exception { SoapFolderService folderService = getFolderService(); WSFolder folder = folderService.getFolder(sid, folderId); if (folder == null) return; User user = validateSession(sid); checkWriteEnable(user, folderId); for (String tag : tags) folder.addTag(tag); folderService.update(sid, folder); } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testAddFolderTags() throws Exception { tagService.addFolderTags("", 4L, new String[] { "pippo", "pluto" }); WSFolder[] folders = tagService.findFoldersByTag("", "pippo"); Assert.assertNotNull(folders); Assert.assertEquals(1, folders.length); folders = tagService.findFoldersByTag("", "unexisting"); Assert.assertNotNull(folders); Assert.assertEquals(0, folders.length); }
### Question: SoapTagService extends AbstractService implements TagService { @Override public void setDocumentTags(String sid, long docId, String[] tags) throws Exception { SoapDocumentService docService = getDocumentService(); WSDocument doc = docService.getDocument(sid, docId); if (doc == null) return; User user = validateSession(sid); checkWriteEnable(user, doc.getFolderId()); doc.setTags(tags); docService.update(sid, doc); } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testSetDocumentTags() throws Exception { WSDocument[] documents = tagService.findDocumentsByTag("", "abc"); Assert.assertNotNull(documents); Assert.assertEquals(1, documents.length); tagService.setDocumentTags("", documents[0].getId(), new String[] { "pippo", "pluto" }); documents = tagService.findDocumentsByTag("", "pippo"); Assert.assertNotNull(documents); Assert.assertEquals(1, documents.length); documents = tagService.findDocumentsByTag("", "abc"); Assert.assertNotNull(documents); Assert.assertEquals(0, documents.length); }
### Question: SoapTagService extends AbstractService implements TagService { @Override public void setFolderTags(String sid, long folderId, String[] tags) throws Exception { SoapFolderService folderService = getFolderService(); WSFolder folder = folderService.getFolder(sid, folderId); if (folder == null) return; User user = validateSession(sid); checkWriteEnable(user, folderId); folder.setTags(tags); folderService.update(sid, folder); } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testSetFolderTags() throws Exception { tagService.addFolderTags("", 4L, new String[] { "pippo", "pluto" }); WSFolder[] folders = tagService.findFoldersByTag("", "pippo"); Assert.assertNotNull(folders); Assert.assertEquals(1, folders.length); tagService.setFolderTags("", 4L, new String[] { "paperino" }); folders = tagService.findFoldersByTag("", "pippo"); Assert.assertNotNull(folders); Assert.assertEquals(0, folders.length); folders = tagService.findFoldersByTag("", "paperino"); Assert.assertNotNull(folders); Assert.assertEquals(1, folders.length); }
### Question: SoapTagService extends AbstractService implements TagService { @Override public String[] getDocumentTags(String sid, long docId) throws Exception { SoapDocumentService docService = getDocumentService(); WSDocument doc = docService.getDocument(sid, docId); if (doc == null) return new String[0]; User user = validateSession(sid); checkReadEnable(user, doc.getFolderId()); return doc.getTags() != null ? doc.getTags() : new String[0]; } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testGetDocumentTags() throws Exception { WSDocument[] documents = tagService.findDocumentsByTag("", "abc"); Assert.assertNotNull(documents); Assert.assertEquals(1, documents.length); tagService.addDocumentTags("", documents[0].getId(), new String[] { "pippo", "pluto" }); List<String> tags = Arrays.asList(tagService.getDocumentTags("", documents[0].getId())); Assert.assertTrue(tags.contains("abc")); Assert.assertTrue(tags.contains("pippo")); Assert.assertTrue(tags.contains("pluto")); }
### Question: SoapTagService extends AbstractService implements TagService { @Override public String[] getFolderTags(String sid, long folderId) throws Exception { SoapFolderService folderService = getFolderService(); WSFolder folder = folderService.getFolder(sid, folderId); if (folder == null) return new String[0]; User user = validateSession(sid); checkReadEnable(user, folderId); return folder.getTags() != null ? folder.getTags() : new String[0]; } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testGetFolderTags() throws Exception { tagService.addFolderTags("", 4L, new String[] { "pippo", "pluto" }); List<String> tags = Arrays.asList(tagService.getFolderTags("", 4L)); Assert.assertTrue(tags.contains("pippo")); Assert.assertTrue(tags.contains("pluto")); }
### Question: SoapTagService extends AbstractService implements TagService { @Override public WSFolder[] findFoldersByTag(String sid, String tag) throws Exception { User user = validateSession(sid); FolderDAO folderDao = (FolderDAO) Context.get().getBean(FolderDAO.class); List<Folder> folders = folderDao.findByUserIdAndTag(user.getId(), tag, null); WSFolder[] wsFolders = new WSFolder[folders.size()]; for (int i = 0; i < folders.size(); i++) { folderDao.initialize(folders.get(i)); wsFolders[i] = WSFolder.fromFolder(folders.get(i)); } return wsFolders; } @Override void setDocumentTags(String sid, long docId, String[] tags); @Override void addDocumentTags(String sid, long docId, String[] tags); @Override String[] getDocumentTags(String sid, long docId); @Override void setFolderTags(String sid, long folderId, String[] tags); @Override void addFolderTags(String sid, long folderId, String[] tags); @Override String[] getFolderTags(String sid, long folderId); @Override String[] getTags(String sid); @Override String[] getTagsPreset(String sid); @Override WSTagCloud[] getTagCloud(String sid); @Override WSDocument[] findDocumentsByTag(String sid, String tag); @Override WSFolder[] findFoldersByTag(String sid, String tag); }### Answer: @Test public void testFindFoldersByTag() throws Exception { Folder folder = folderDao.findById(4L); folderDao.initialize(folder); folder.addTag("xyz"); folderDao.store(folder); WSFolder[] folders = tagService.findFoldersByTag("", "xyz"); Assert.assertNotNull(folders); Assert.assertEquals(1, folders.length); folders = tagService.findFoldersByTag("", "unexisting"); Assert.assertNotNull(folders); Assert.assertEquals(0, folders.length); }
### Question: SoapFolderService extends AbstractService implements FolderService { @Override public boolean isReadable(String sid, long folderId) throws Exception { User user = validateSession(sid); try { checkReadEnable(user, folderId); } catch (Exception e) { return false; } return true; } @Override WSFolder create(String sid, WSFolder folder); @Override WSFolder createAlias(String sid, long parentId, long foldRef); @Override long createFolder(String sid, long parentId, String name); @Override void delete(String sid, long folderId); @Override WSFolder getFolder(String sid, long folderId); @Override WSFolder findByPath(String sid, String path); @Override boolean isReadable(String sid, long folderId); @Override WSFolder[] listChildren(String sid, long folderId); @Override void move(String sid, long folderId, long parentId); @Override void copy(String sid, long folderId, long targetId, int foldersOnly, int inheritSecurity); @Override void rename(String sid, long folderId, String name); @Override WSFolder getRootFolder(String sid); @Override WSFolder getDefaultWorkspace(String sid); @Override boolean isWritable(String sid, long folderId); @Override boolean isGranted(String sid, long folderId, int permission); @Override WSFolder[] getPath(String sid, long folderId); @Override void grantUser(String sid, long folderId, long userId, int permissions, boolean recursive); @Override void grantGroup(String sid, long folderId, long groupId, int permissions, boolean recursive); @Override WSRight[] getGrantedUsers(String sid, long folderId); @Override WSRight[] getGrantedGroups(String sid, long folderId); @Override void update(String sid, WSFolder folder); @Override WSFolder createPath(String sid, long parentId, String path); @Override WSFolder[] listWorkspaces(String sid); }### Answer: @Test public void testIsReadable() throws Exception { Assert.assertTrue(folderServiceImpl.isReadable("", 1200)); Assert.assertTrue(folderServiceImpl.isReadable("", 99)); }
### Question: SoapFolderService extends AbstractService implements FolderService { @Override public WSRight[] getGrantedGroups(String sid, long folderId) throws Exception { return getGranted(sid, folderId, false); } @Override WSFolder create(String sid, WSFolder folder); @Override WSFolder createAlias(String sid, long parentId, long foldRef); @Override long createFolder(String sid, long parentId, String name); @Override void delete(String sid, long folderId); @Override WSFolder getFolder(String sid, long folderId); @Override WSFolder findByPath(String sid, String path); @Override boolean isReadable(String sid, long folderId); @Override WSFolder[] listChildren(String sid, long folderId); @Override void move(String sid, long folderId, long parentId); @Override void copy(String sid, long folderId, long targetId, int foldersOnly, int inheritSecurity); @Override void rename(String sid, long folderId, String name); @Override WSFolder getRootFolder(String sid); @Override WSFolder getDefaultWorkspace(String sid); @Override boolean isWritable(String sid, long folderId); @Override boolean isGranted(String sid, long folderId, int permission); @Override WSFolder[] getPath(String sid, long folderId); @Override void grantUser(String sid, long folderId, long userId, int permissions, boolean recursive); @Override void grantGroup(String sid, long folderId, long groupId, int permissions, boolean recursive); @Override WSRight[] getGrantedUsers(String sid, long folderId); @Override WSRight[] getGrantedGroups(String sid, long folderId); @Override void update(String sid, WSFolder folder); @Override WSFolder createPath(String sid, long parentId, String path); @Override WSFolder[] listWorkspaces(String sid); }### Answer: @Test public void testGetGrantedGroups() throws Exception { WSRight[] rights = new WSRight[0]; rights = folderServiceImpl.getGrantedGroups("", 80); Assert.assertEquals(2, rights.length); }
### Question: HibernateBookmarkDAO extends HibernatePersistentObjectDAO<Bookmark> implements BookmarkDAO { @Override public List<Bookmark> findByUserId(long userId) { try { return findByWhere("_entity.userId =" + userId, "order by _entity.position asc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Bookmark>(); } } HibernateBookmarkDAO(); @Override List<Bookmark> findByUserId(long userId); @Override Bookmark findByUserIdAndDocId(long userId, long docId); @Override Bookmark findByUserIdAndFolderId(long userId, long folderId); @Override List<Long> findBookmarkedDocs(long userId); @Override boolean isDocBookmarkedByUser(long docId, long userId); }### Answer: @Test @SuppressWarnings("rawtypes") public void testFindByUserId() { Collection bookmarks = dao.findByUserId(1); Assert.assertNotNull(bookmarks); Assert.assertEquals(2, bookmarks.size()); bookmarks = dao.findByUserId(2); Assert.assertNotNull(bookmarks); Assert.assertEquals(1, bookmarks.size()); bookmarks = dao.findByUserId(99); Assert.assertNotNull(bookmarks); Assert.assertEquals(0, bookmarks.size()); }
### Question: HibernateBookmarkDAO extends HibernatePersistentObjectDAO<Bookmark> implements BookmarkDAO { @Override public List<Long> findBookmarkedDocs(long userId) { String sql = "select ld_docid from ld_bookmark where ld_type=" + Bookmark.TYPE_DOCUMENT + " and ld_deleted = 0 and ld_userid = " + userId; try { return (List<Long>) queryForList(sql, Long.class); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Long>(); } } HibernateBookmarkDAO(); @Override List<Bookmark> findByUserId(long userId); @Override Bookmark findByUserIdAndDocId(long userId, long docId); @Override Bookmark findByUserIdAndFolderId(long userId, long folderId); @Override List<Long> findBookmarkedDocs(long userId); @Override boolean isDocBookmarkedByUser(long docId, long userId); }### Answer: @Test @SuppressWarnings("rawtypes") public void testFindBookmarkedDocs() { Collection bookmarks = dao.findByUserId(1); Assert.assertNotNull(bookmarks); Assert.assertEquals(2, bookmarks.size()); List<Long> ids = dao.findBookmarkedDocs(1L); Assert.assertEquals(2, ids.size()); ids = dao.findBookmarkedDocs(55L); Assert.assertEquals(0, ids.size()); }
### Question: HibernateBookmarkDAO extends HibernatePersistentObjectDAO<Bookmark> implements BookmarkDAO { @Override public boolean isDocBookmarkedByUser(long docId, long userId) { String sql = "select count(ld_docid) from ld_bookmark where ld_type=" + Bookmark.TYPE_DOCUMENT + " and ld_deleted = 0 and ld_userid = " + userId + " and ld_docid = " + docId; try { return queryForInt(sql) > 0; } catch (Throwable t) { try { return queryForLong(sql) > 0; } catch (PersistenceException e) { log.error(e.getMessage(), e); return false; } } } HibernateBookmarkDAO(); @Override List<Bookmark> findByUserId(long userId); @Override Bookmark findByUserIdAndDocId(long userId, long docId); @Override Bookmark findByUserIdAndFolderId(long userId, long folderId); @Override List<Long> findBookmarkedDocs(long userId); @Override boolean isDocBookmarkedByUser(long docId, long userId); }### Answer: @Test public void testIsDocBookmarkedByUser() { Assert.assertTrue(dao.isDocBookmarkedByUser(1L, 1L)); Assert.assertFalse(dao.isDocBookmarkedByUser(55L, 1L)); }
### Question: SoapSearchService extends AbstractService implements SearchService { @Override public WSFolder[] findFolders(String sid, String name) throws Exception { User user = validateSession(sid); FolderDAO folderDao = (FolderDAO) Context.get().getBean(FolderDAO.class); List<Folder> folders = folderDao.find(name, user.getTenantId()); WSFolder[] wsFolders = new WSFolder[folders.size()]; for (int i = 0; i < folders.size(); i++) { try { checkReadEnable(user, folders.get(i).getId()); } catch (Exception e) { continue; } folderDao.initialize(folders.get(i)); wsFolders[i] = WSFolder.fromFolder(folders.get(i)); } return wsFolders; } @Override WSSearchResult find(String sid, WSSearchOptions opt); @Override WSDocument[] findByFilename(String sid, String filename); @Override WSFolder[] findFolders(String sid, String name); }### Answer: @Test public void testFindFolders() throws Exception { WSFolder[] folders = searchServiceImpl.findFolders("", "menu.admin"); Assert.assertNotNull(folders); Assert.assertEquals(4, folders.length); List<WSFolder> foldersList = Arrays.asList(folders); Assert.assertEquals(80, foldersList.get(0).getId()); Assert.assertEquals(99, foldersList.get(1).getId()); folders = searchServiceImpl.findFolders("", "menu.adminxx"); Assert.assertEquals(1, folders.length); foldersList = Arrays.asList(folders); Assert.assertEquals(80, foldersList.get(0).getId()); folders = searchServiceImpl.findFolders("", "qqqxxx"); Assert.assertNotNull(folders); Assert.assertEquals(0, folders.length); }
### Question: SoapSystemService extends AbstractService implements SystemService { @Override public WSSystemInfo getInfo() throws Exception { SystemInfo inf = SystemInfo.get(); WSSystemInfo info = new WSSystemInfo(); BeanUtils.copyProperties(info, inf); DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z"); info.setDate(df.format(inf.getDate())); return info; } @Override WSParameter[] getStatistics(String sid); @Override String[] getLanguages(String tenantOrSid); @Override WSSystemInfo getInfo(); }### Answer: @Test public void testGetInfo() throws Exception { WSSystemInfo info = systemServiceImpl.getInfo(); Assert.assertEquals("via Aldo Moro interna, 3", info.getVendorAddress()); Assert.assertEquals("1234567890", info.getInstallationId()); Assert.assertEquals("6.1 Beta2", info.getRelease()); Assert.assertEquals("2011", info.getYear()); }
### Question: SoapSecurityService extends AbstractService implements SecurityService { @Override public WSGroup[] listGroups(String sid) throws Exception { checkAdministrator(sid); User user = validateSession(sid); try { List<WSGroup> groups = new ArrayList<WSGroup>(); GroupDAO dao = (GroupDAO) Context.get().getBean(GroupDAO.class); for (Group grp : dao.findAll(user.getTenantId())) { if (grp.getType() == Group.TYPE_DEFAULT) { dao.initialize(grp); groups.add(WSGroup.fromGroup(grp)); } } return groups.toArray(new WSGroup[0]); } catch (Throwable t) { log.error(t.getMessage(), t); throw new Exception(t.getMessage()); } } @Override WSUser[] listUsers(String sid, String group); @Override WSGroup[] listGroups(String sid); @Override long storeUser(String sid, WSUser user); @Override long storeGroup(String sid, WSGroup group); @Override void deleteUser(String sid, long userId); @Override void deleteGroup(String sid, long groupId); @Override int changePassword(String sid, long userId, String oldPassword, String newPassword); @Override WSUser getUser(String sid, long userId); @Override WSUser getUserByUsername(String sid, String username); @Override WSGroup getGroup(String sid, long groupId); }### Answer: @Test public void testListGroups() throws Exception { WSGroup[] groups = securityServiceImpl.listGroups(""); Assert.assertNotNull(groups); Assert.assertEquals(6, groups.length); List<WSGroup> groupsList = Arrays.asList(groups); WSGroup dummy = new WSGroup(); dummy.setId(1); Assert.assertTrue(groupsList.contains(dummy)); dummy.setId(2); Assert.assertTrue(groupsList.contains(dummy)); Assert.assertEquals("Group of authors", groupsList.get(groupsList.indexOf(dummy)).getDescription()); }
### Question: SoapSecurityService extends AbstractService implements SecurityService { @Override public void deleteUser(String sid, long userId) throws Exception { checkAdministrator(sid); if (userId == 1) throw new Exception("You cannot delete the admin user"); try { UserDAO dao = (UserDAO) Context.get().getBean(UserDAO.class); User usr = dao.findById(userId); if (usr.getType() != User.TYPE_DEFAULT) { throw new Exception("You cannot delete user with id " + usr.getId() + " because it is a system user"); } dao.delete(userId); } catch (Throwable t) { log.error(t.getMessage(), t); throw new Exception("Unable to delete the user with id " + userId); } } @Override WSUser[] listUsers(String sid, String group); @Override WSGroup[] listGroups(String sid); @Override long storeUser(String sid, WSUser user); @Override long storeGroup(String sid, WSGroup group); @Override void deleteUser(String sid, long userId); @Override void deleteGroup(String sid, long groupId); @Override int changePassword(String sid, long userId, String oldPassword, String newPassword); @Override WSUser getUser(String sid, long userId); @Override WSUser getUserByUsername(String sid, String username); @Override WSGroup getGroup(String sid, long groupId); }### Answer: @Test public void testDeleteUser() throws Exception { User user = userDao.findById(2); Assert.assertNotNull(user); securityServiceImpl.deleteUser("", user.getId()); user = userDao.findById(2); Assert.assertNull(user); }
### Question: HibernateBookmarkDAO extends HibernatePersistentObjectDAO<Bookmark> implements BookmarkDAO { @Override public Bookmark findByUserIdAndDocId(long userId, long docId) { List<Bookmark> list = new ArrayList<Bookmark>(); try { list = findByWhere("_entity.userId =" + userId + " and _entity.targetId =" + docId + " and _entity.type=" + Bookmark.TYPE_DOCUMENT, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); } if (list.isEmpty()) return null; else return list.get(0); } HibernateBookmarkDAO(); @Override List<Bookmark> findByUserId(long userId); @Override Bookmark findByUserIdAndDocId(long userId, long docId); @Override Bookmark findByUserIdAndFolderId(long userId, long folderId); @Override List<Long> findBookmarkedDocs(long userId); @Override boolean isDocBookmarkedByUser(long docId, long userId); }### Answer: @Test public void testFindByUserIdAndTargetId() throws PersistenceException { Bookmark bookmark = dao.findByUserIdAndDocId(1, 1); Assert.assertNotNull(bookmark); bookmark = dao.findByUserIdAndDocId(1, 2); Assert.assertNotNull(bookmark); Bookmark book1 = dao.findById(1); dao.initialize(book1); book1.setTargetId(3); dao.store(book1); bookmark = dao.findByUserIdAndDocId(1, 1); Assert.assertNull(bookmark); bookmark = dao.findByUserIdAndDocId(1, 2); Assert.assertNotNull(bookmark); }
### Question: SoapSecurityService extends AbstractService implements SecurityService { @Override public void deleteGroup(String sid, long groupId) throws Exception { checkAdministrator(sid); if (groupId == 1) throw new Exception("You cannot delete the admin group"); try { GroupDAO dao = (GroupDAO) Context.get().getBean(GroupDAO.class); Group grp = dao.findById(groupId); if (grp.getType() != Group.TYPE_DEFAULT) { throw new Exception("You cannot delete group with id " + grp.getId() + " because it is a system group"); } dao.delete(groupId); } catch (Throwable t) { log.error(t.getMessage(), t); throw new Exception("Unable to delete the group with id " + groupId); } } @Override WSUser[] listUsers(String sid, String group); @Override WSGroup[] listGroups(String sid); @Override long storeUser(String sid, WSUser user); @Override long storeGroup(String sid, WSGroup group); @Override void deleteUser(String sid, long userId); @Override void deleteGroup(String sid, long groupId); @Override int changePassword(String sid, long userId, String oldPassword, String newPassword); @Override WSUser getUser(String sid, long userId); @Override WSUser getUserByUsername(String sid, String username); @Override WSGroup getGroup(String sid, long groupId); }### Answer: @Test public void testDeleteGroup() throws Exception { Group group = groupDao.findById(2); Assert.assertNotNull(group); securityServiceImpl.deleteGroup("", group.getId()); group = groupDao.findById(2); Assert.assertNull(group); }
### Question: HibernateDocumentLinkDAO extends HibernatePersistentObjectDAO<DocumentLink> implements DocumentLinkDAO { @Override public boolean store(DocumentLink entity) throws PersistenceException { boolean newLink = entity.getId() == 0L; boolean result = super.store(entity); flush(); if (newLink && result) { if (entity.getDocument1() != null) updateLinksCount(entity.getDocument1().getId()); if (entity.getDocument2() != null) updateLinksCount(entity.getDocument2().getId()); } return result; } HibernateDocumentLinkDAO(); @Override List<DocumentLink> findByDocId(long docId); @Override List<DocumentLink> findByDocId(long docId, String type); @Override DocumentLink findByDocIdsAndType(long docId1, long docId2, String type); @Override boolean delete(long id, int code); @Override boolean store(DocumentLink entity); }### Answer: @Test public void testStore() throws PersistenceException { DocumentLink link = new DocumentLink(); Document doc1 = docDao.findById(1); Document doc2 = docDao.findById(2); link.setDocument1(doc1); link.setDocument2(doc2); link.setType("zzz"); dao.store(link); link = dao.findById(link.getId()); Assert.assertEquals(1, link.getDocument1().getId()); Assert.assertEquals(2, link.getDocument2().getId()); Assert.assertEquals("zzz", link.getType()); }
### Question: HibernateDocumentLinkDAO extends HibernatePersistentObjectDAO<DocumentLink> implements DocumentLinkDAO { @Override public boolean delete(long id, int code) { if (!checkStoringAspect()) return false; DocumentLink link = findById(id); if (link != null) { long docId1 = link.getDocument1() != null ? link.getDocument1().getId() : 0; long docId2 = link.getDocument2() != null ? link.getDocument2().getId() : 0; getCurrentSession().delete(link); flush(); updateLinksCount(docId1); updateLinksCount(docId2); } return true; } HibernateDocumentLinkDAO(); @Override List<DocumentLink> findByDocId(long docId); @Override List<DocumentLink> findByDocId(long docId, String type); @Override DocumentLink findByDocIdsAndType(long docId1, long docId2, String type); @Override boolean delete(long id, int code); @Override boolean store(DocumentLink entity); }### Answer: @Test public void testDelete() throws PersistenceException { DocumentLink link = dao.findById(1); Assert.assertNotNull(link); Assert.assertTrue(dao.delete(1)); link = dao.findById(1); Assert.assertNull(link); dao.delete(99); link = dao.findById(1); Assert.assertNull(link); link = dao.findById(2); Assert.assertNotNull(link); }
### Question: ZipUtil { public List<ZipEntry> listZipEntries(File zipsource) { List<ZipEntry> files = new ArrayList<ZipEntry>(); try (java.util.zip.ZipFile zipFile = new java.util.zip.ZipFile(zipsource)) { @SuppressWarnings("unchecked") Enumeration<ZipEntry> e = (Enumeration<ZipEntry>) zipFile.entries(); while (e.hasMoreElements()) { ZipEntry zipEntry = (ZipEntry) e.nextElement(); files.add(zipEntry); } files.sort(new Comparator<ZipEntry>() { @Override public int compare(ZipEntry o1, ZipEntry o2) { return o1.getName().compareTo(o2.getName()); } }); } catch (Throwable e) { logError(e.getMessage()); } return files; } ZipUtil(); ZipUtil(String charset); List<ZipEntry> listZipEntries(File zipsource); List<String> listEntries(File zipsource); boolean unzip(String zipsource, String target); byte[] getEntryBytes(File zipsource, String entry); InputStream getEntryStream(File zip, String entry); String getEntryContent(File zip, String entry); static void addEntry(File zip, String entry, InputStream content); void zipFile(File src, File dest); void zipFolder(File inFolder, File outFile); String getFileNameCharset(); void setFileNameCharset(String fileNameCharset); }### Answer: @Test public void testListZipEntries() throws IOException { File file = new File("target/test.zip"); FileUtil.copyResource("/test.zip", file); ZipUtil zipUtil = new ZipUtil(); List<ZipEntry> entries = zipUtil.listZipEntries(file); for (ZipEntry zipEntry : entries) { System.out.println(zipEntry.getName()+" "+zipEntry.getSize()+" "+zipEntry.getLastModifiedTime()); } Assert.assertEquals(3, entries.size()); }
### Question: HibernateDocumentLinkDAO extends HibernatePersistentObjectDAO<DocumentLink> implements DocumentLinkDAO { @Override public List<DocumentLink> findByDocId(long docId) { return findByDocId(docId, null); } HibernateDocumentLinkDAO(); @Override List<DocumentLink> findByDocId(long docId); @Override List<DocumentLink> findByDocId(long docId, String type); @Override DocumentLink findByDocIdsAndType(long docId1, long docId2, String type); @Override boolean delete(long id, int code); @Override boolean store(DocumentLink entity); }### Answer: @Test public void testFindByDocId() { Collection<DocumentLink> links = dao.findByDocId(1, null); Assert.assertNotNull(links); Assert.assertEquals(4, links.size()); Collection<DocumentLink> links2 = dao.findByDocId(2, null); Assert.assertNotNull(links2); Assert.assertEquals(4, links.size()); Collection<DocumentLink> links3 = dao.findByDocId(99, null); Assert.assertNotNull(links3); Assert.assertEquals(0, links3.size()); links = dao.findByDocId(1, "test"); Assert.assertNotNull(links); Assert.assertEquals(1, links.size()); links2 = dao.findByDocId(99, "pippo"); Assert.assertNotNull(links2); Assert.assertEquals(0, links2.size()); links2 = dao.findByDocId(1, "pippo"); Assert.assertNotNull(links2); Assert.assertEquals(0, links2.size()); }
### Question: HibernateVersionDAO extends HibernatePersistentObjectDAO<Version> implements VersionDAO { @Override public Version findByVersion(long docId, String version) { List<Version> versions = new ArrayList<Version>(); try { versions = findByWhere(" _entity.docId=" + docId + " and _entity.version='" + version + "'", null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); } if (!versions.isEmpty()) return versions.get(0); else return null; } private HibernateVersionDAO(); @Override List<Version> findByDocId(long docId); @Override Version findByVersion(long docId, String version); @Override Version findByFileVersion(long docId, String fileVersion); @Override void initialize(Version version); @Override boolean store(Version version); @Override void updateDigest(Version version); void setStorer(Storer storer); @Override boolean delete(long versionId, int delCode); void setFolderDAO(FolderDAO folderDAO); }### Answer: @Test public void testFindByVersion() { Version version = dao.findByVersion(1, "testVer02"); Assert.assertNotNull(version); Assert.assertEquals("testVer02", version.getVersion()); version = dao.findByVersion(1, "xxxx"); Assert.assertNull(version); }
### Question: HibernateVersionDAO extends HibernatePersistentObjectDAO<Version> implements VersionDAO { @Override public Version findByFileVersion(long docId, String fileVersion) { List<Version> versions = new ArrayList<Version>(); try { versions = findByWhere(" _entity.docId=" + docId + " and _entity.fileVersion='" + fileVersion + "'", "order by _entity.date asc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); } if (!versions.isEmpty()) return versions.get(0); else return null; } private HibernateVersionDAO(); @Override List<Version> findByDocId(long docId); @Override Version findByVersion(long docId, String version); @Override Version findByFileVersion(long docId, String fileVersion); @Override void initialize(Version version); @Override boolean store(Version version); @Override void updateDigest(Version version); void setStorer(Storer storer); @Override boolean delete(long versionId, int delCode); void setFolderDAO(FolderDAO folderDAO); }### Answer: @Test public void testFindByFileVersion() { Version version = dao.findByFileVersion(1, "fileVer02"); Assert.assertNotNull(version); Assert.assertEquals("fileVer02", version.getFileVersion()); version = dao.findByVersion(1, "30"); Assert.assertNull(version); }
### Question: HibernateRatingDAO extends HibernatePersistentObjectDAO<Rating> implements RatingDAO { @Override public boolean store(Rating rating, DocumentHistory transaction) throws PersistenceException { boolean result = super.store(rating); if (!result) return false; try { if (transaction != null) { transaction.setEvent(DocumentEvent.RATING_NEW.toString()); transaction.setComment("rating: " + rating.getVote()); DocumentDAO documentDao = (DocumentDAO) Context.get().getBean(DocumentDAO.class); documentDao.saveDocumentHistory(documentDao.findById(rating.getDocId()), transaction); } } catch (Throwable e) { if (transaction != null && StringUtils.isNotEmpty(transaction.getSessionId())) { Session session = SessionManager.get().get(transaction.getSessionId()); session.logError(e.getMessage()); } log.error(e.getMessage(), e); result = false; } return result; } HibernateRatingDAO(); @Override boolean store(Rating rating, DocumentHistory transaction); @Override Rating findVotesByDocId(long docId); @Override Rating findByDocIdAndUserId(long docId, long userId); @Override List<Rating> findByDocId(long docId); @Override boolean delete(long id, int code); }### Answer: @Test public void testStore() throws PersistenceException { Rating rat1 = dao.findById(1); dao.initialize(rat1); rat1.setVote(4); rat1.setUserId(3); dao.store(rat1); Assert.assertNotNull(rat1); Rating rat2 = dao.findById(2); dao.initialize(rat2); rat2.setVote(2); rat2.setDocId(4); dao.store(rat2); Assert.assertNotNull(rat2); rat1 = dao.findById(1); Assert.assertEquals(4, rat1.getVote()); Assert.assertEquals(3, rat1.getUserId()); rat2 = dao.findById(2); Assert.assertEquals(2, rat2.getVote()); Assert.assertEquals(4, rat2.getDocId()); }
### Question: HibernateRatingDAO extends HibernatePersistentObjectDAO<Rating> implements RatingDAO { @Override public List<Rating> findByDocId(long docId) { try { return findByWhere("_entity.docId = " + docId, " order by _entity.lastModified desc", null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Rating>(); } } HibernateRatingDAO(); @Override boolean store(Rating rating, DocumentHistory transaction); @Override Rating findVotesByDocId(long docId); @Override Rating findByDocIdAndUserId(long docId, long userId); @Override List<Rating> findByDocId(long docId); @Override boolean delete(long id, int code); }### Answer: @Test public void testFindByDocId() { List<Rating> ratings = dao.findByDocId(1L); Assert.assertEquals(2, ratings.size()); ratings = dao.findByDocId(99L); Assert.assertTrue(ratings.isEmpty()); }
### Question: HibernateRatingDAO extends HibernatePersistentObjectDAO<Rating> implements RatingDAO { @Override public Rating findByDocIdAndUserId(long docId, long userId) { List<Rating> results = new ArrayList<Rating>(); try { results = findByWhere("_entity.docId =" + docId + " and _entity.userId =" + userId, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); } if (results.isEmpty()) return null; else return results.get(0); } HibernateRatingDAO(); @Override boolean store(Rating rating, DocumentHistory transaction); @Override Rating findVotesByDocId(long docId); @Override Rating findByDocIdAndUserId(long docId, long userId); @Override List<Rating> findByDocId(long docId); @Override boolean delete(long id, int code); }### Answer: @Test public void testFindByDocIdAndUserId() { Assert.assertNotNull(dao.findByDocIdAndUserId(1, 1)); Assert.assertNull(dao.findByDocIdAndUserId(2, 2)); }
### Question: ZipUtil { public List<String> listEntries(File zipsource) { List<String> files = new ArrayList<String>(); try { ZipFile zipFile = new ZipFile(zipsource); setCharset(zipFile); @SuppressWarnings("unchecked") List<FileHeader> fileHeaders = zipFile.getFileHeaders(); for (FileHeader fileHeader : fileHeaders) { files.add(fileHeader.getFileName()); } } catch (Throwable e) { logError(e.getMessage()); } return files; } ZipUtil(); ZipUtil(String charset); List<ZipEntry> listZipEntries(File zipsource); List<String> listEntries(File zipsource); boolean unzip(String zipsource, String target); byte[] getEntryBytes(File zipsource, String entry); InputStream getEntryStream(File zip, String entry); String getEntryContent(File zip, String entry); static void addEntry(File zip, String entry, InputStream content); void zipFile(File src, File dest); void zipFolder(File inFolder, File outFile); String getFileNameCharset(); void setFileNameCharset(String fileNameCharset); }### Answer: @Test public void testListEntries() throws IOException { File file = new File("target/test.zip"); FileUtil.copyResource("/test.zip", file); ZipUtil zipUtil = new ZipUtil(); List<String> entries = zipUtil.listEntries(file); Assert.assertEquals(3, entries.size()); Assert.assertTrue(entries.contains("impex.xsd")); }
### Question: ZipUtil { public byte[] getEntryBytes(File zipsource, String entry) { if (entry.startsWith("/")) entry = entry.substring(1); InputStream entryStream = null; ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { ZipFile zipFile = new ZipFile(zipsource); setCharset(zipFile); FileHeader header = zipFile.getFileHeader(entry); entryStream = zipFile.getInputStream(header); IOUtils.copy(entryStream, baos); baos.flush(); } catch (Throwable e) { logError(e.getMessage()); } finally { try { baos.close(); entryStream.close(); } catch (Throwable e) { } } return baos.toByteArray(); } ZipUtil(); ZipUtil(String charset); List<ZipEntry> listZipEntries(File zipsource); List<String> listEntries(File zipsource); boolean unzip(String zipsource, String target); byte[] getEntryBytes(File zipsource, String entry); InputStream getEntryStream(File zip, String entry); String getEntryContent(File zip, String entry); static void addEntry(File zip, String entry, InputStream content); void zipFile(File src, File dest); void zipFolder(File inFolder, File outFile); String getFileNameCharset(); void setFileNameCharset(String fileNameCharset); }### Answer: @Test public void testGetEntryBytes() throws IOException { File file = new File("target/test.zip"); FileUtil.copyResource("/test.zip", file); ZipUtil zipUtil = new ZipUtil(); zipUtil.setFileNameCharset("UTF-8"); byte[] in = zipUtil.getEntryBytes(file, "index.xml"); Assert.assertEquals(132997526, in.length); }
### Question: TagUtil { public static Set<String> extractTags(String tenantName, String words) { if (words != null && !words.contains(",")) words = "," + words + ","; words = words.replace("\\,", "__comma__"); Set<String> coll = new HashSet<String>(); try { ContextProperties conf = new ContextProperties(); int minSize = conf.getInt(tenantName + ".tag.minsize"); int maxSize = conf.getInt(tenantName + ".tag.maxsize"); StringTokenizer st = new StringTokenizer(words, ",", false); while (st.hasMoreTokens()) { String word = st.nextToken(); word = word.replace("__comma__", ","); if (StringUtils.isNotEmpty(word)) { word = word.trim(); if (word.length() >= minSize) { if (word.length() > maxSize) coll.add(word.substring(0, maxSize)); else coll.add(word); } } } } catch (IOException e) { } return coll; } static Set<String> extractTags(String tenantName, String words); static String normalizeTags(String tenantName, String words); static final int MAX_FIELD_LENGTH; }### Answer: @Test public void testExtractTags() { Collection<String> coll = TagUtil.extractTags("default","my name is tom"); assertNotNull(coll); assertEquals(1, coll.size()); coll = TagUtil.extractTags("default","il mio,nome, e' tom"); assertNotNull(coll); assertEquals(3, coll.size()); coll = TagUtil.extractTags("default","il mio, nome e' ,123456789123456789123456789"); assertNotNull(coll); assertEquals(3, coll.size()); assertFalse(coll.contains("123456789123456789123456789")); assertTrue(coll.contains("12345678912345678912")); }
### Question: StringUtil { public static String split(String src, char separator, int tokenSize) { StringBuffer sb = new StringBuffer(); String[] tokens = split(src, tokenSize); for (int i = 0; i < tokens.length; i++) { if (sb.length() > 0) sb.append(separator); sb.append(tokens[i]); } return sb.toString(); } static String split(String src, char separator, int tokenSize); static String[] split(String src, int tokenSize); static String writeToString(Reader reader); static String writeToString(Reader reader, String targetEncoding); static String writeToString(InputStream is, String targetEncoding); static String arrayToString(Object[] a, String separator); static String collectionToString(Collection<?> collection, String separator); static String removeNonUtf8Chars(String src); static boolean matches(String str, String[] includes, String[] excludes); static String unaccent(String src); }### Answer: @Test public void testSplit() { String str="1"; assertEquals("1", StringUtil.split(str, '/', 3)); str="12"; assertEquals("12", StringUtil.split(str, '/', 3)); str="123"; assertEquals("123", StringUtil.split(str, '/', 3)); str="1234"; assertEquals("123/4", StringUtil.split(str, '/', 3)); str="123456"; assertEquals("123/456", StringUtil.split(str, '/', 3)); str="12345678"; assertEquals("123/456/78", StringUtil.split(str, '/', 3)); System.out.println("Crypt J2A86bc26QnIpf1:"+CryptUtil.cryptString("J2A86bc26QnIpf1")); }
### Question: ContextConfigurator { public void addTrigger(String triggerId) { Element element = getPropertyElement("Scheduler", "triggers"); Element list = element.getChild("list", element.getNamespace()); List refs = list.getChildren("ref", element.getNamespace()); for (Iterator iterator = refs.iterator(); iterator.hasNext();) { Element ref = (Element) iterator.next(); if (triggerId.equals(ref.getAttribute("bean").getValue())) return; } Element ref = new Element("ref", element.getNamespace()); ref.setAttribute("bean", triggerId); list.addContent(ref); xml.writeXMLDoc(); } ContextConfigurator(String resource); ContextConfigurator(); void setProperty(String id, String propertyName, String value); void clearPropertyValue(String id, String propertyName); void addPropertyBeanRefList(String id, String propertyName, List<? extends String> values); String getProperty(String id, String propertyName); String getPropertyProp(String id, String propertyName, String key); void setPropValue(String id, String propertyName, String key, String value); String getDialect(); boolean write(); void addTrigger(String triggerId); }### Answer: @Test public void testAddTrigger() { ContextConfigurator config = new ContextConfigurator(contextXml.getPath()); config.addTrigger("TestTrigger"); }
### Question: LoggingConfigurator { public String getFile(String appender) { return getFile(appender, true); } LoggingConfigurator(); Collection<String> getLoggingFiles(); Collection<String> getWebLoggingFiles(); String getFile(String appender); String getFile(String appender, boolean replaceVariables); void setFile(String appender, String file); void addTextAppender(String name); void addHtmlAppender(String name); void addCategory(Class clazz, String[] appenders); void addCategory(String name, String[] appenders); void setLogsRoot(String rootPath); boolean write(); }### Answer: @Test public void testAddTrigger() { LoggingConfigurator config = new LoggingConfigurator(); String file = config.getFile("DMS"); Assert.assertEquals("D:/LogicalDOC-Devel/repository/logs/dms.log", file); }
### Question: HibernateTicketDAO extends HibernatePersistentObjectDAO<Ticket> implements TicketDAO { @Override public boolean deleteByDocId(long docId) { if (!checkStoringAspect()) return false; boolean result = true; try { Collection<Ticket> coll = (Collection<Ticket>) findByQuery("from Ticket _ticket where _ticket.docId = ?1", new Object[] { docId }, null); for (Ticket downloadTicket : coll) { downloadTicket.setDeleted(1); saveOrUpdate(downloadTicket); } } catch (Throwable e) { log.error(e.getMessage(), e); result = false; } return result; } HibernateTicketDAO(); @Override boolean store(Ticket entity); @Override boolean store(Ticket entity, DocumentHistory transaction); boolean deleteByTicketId(String ticketid); @Override Ticket findByTicketId(String ticketid); @Override boolean deleteByDocId(long docId); void setContextProperties(ContextProperties contextProperties); @Override void deleteExpired(); DocumentDAO getDocumentDAO(); void setDocumentDAO(DocumentDAO documentDAO); }### Answer: @Test public void testDeleteByDocId() { Ticket ticket = dao.findByTicketId("1"); Assert.assertNotNull(ticket); Assert.assertEquals(1, ticket.getDocId()); ticket = dao.findByTicketId("3"); Assert.assertNotNull(ticket); Assert.assertEquals(1, ticket.getDocId()); Assert.assertTrue(dao.deleteByDocId(1)); ticket = dao.findByTicketId("1"); Assert.assertNull(ticket); ticket = dao.findByTicketId("3"); Assert.assertNull(ticket); }
### Question: HibernateTicketDAO extends HibernatePersistentObjectDAO<Ticket> implements TicketDAO { @Override public void deleteExpired() { if (!checkStoringAspect()) return; try { Collection<Ticket> coll = (Collection<Ticket>) findByQuery("from Ticket _ticket where _ticket.expired < ?1", new Object[] { new Date() }, null); for (Ticket downloadTicket : coll) { downloadTicket.setDeleted(1); saveOrUpdate(downloadTicket); } } catch (Throwable e) { log.error(e.getMessage(), e); } } HibernateTicketDAO(); @Override boolean store(Ticket entity); @Override boolean store(Ticket entity, DocumentHistory transaction); boolean deleteByTicketId(String ticketid); @Override Ticket findByTicketId(String ticketid); @Override boolean deleteByDocId(long docId); void setContextProperties(ContextProperties contextProperties); @Override void deleteExpired(); DocumentDAO getDocumentDAO(); void setDocumentDAO(DocumentDAO documentDAO); }### Answer: @Test public void testDeleteExpired() throws ParseException { List<Ticket> tickets = dao.findAll(); Assert.assertEquals(3, tickets.size()); dao.deleteExpired(); tickets = dao.findAll(); Assert.assertEquals(0, tickets.size()); }
### Question: HibernateTicketDAO extends HibernatePersistentObjectDAO<Ticket> implements TicketDAO { @Override public Ticket findByTicketId(String ticketid) { try { Collection<Ticket> coll = (Collection<Ticket>) findByQuery( "from Ticket _ticket where _ticket.ticketId = ?1", new Object[] { ticketid }, null); Ticket ticket = null; if (!coll.isEmpty()) { ticket = coll.iterator().next(); if (ticket.getDeleted() == 0) return ticket; } } catch (Throwable e) { log.error(e.getMessage(), e); } return null; } HibernateTicketDAO(); @Override boolean store(Ticket entity); @Override boolean store(Ticket entity, DocumentHistory transaction); boolean deleteByTicketId(String ticketid); @Override Ticket findByTicketId(String ticketid); @Override boolean deleteByDocId(long docId); void setContextProperties(ContextProperties contextProperties); @Override void deleteExpired(); DocumentDAO getDocumentDAO(); void setDocumentDAO(DocumentDAO documentDAO); }### Answer: @Test public void testFindByTicketId() { Ticket ticket = dao.findByTicketId("1"); Assert.assertNotNull(ticket); Assert.assertEquals(1, ticket.getUserId()); Assert.assertEquals(1, ticket.getDocId()); ticket = dao.findByTicketId("99"); Assert.assertNull(ticket); }
### Question: HibernateTicketDAO extends HibernatePersistentObjectDAO<Ticket> implements TicketDAO { @Override public boolean store(Ticket entity) { return this.store(entity, null); } HibernateTicketDAO(); @Override boolean store(Ticket entity); @Override boolean store(Ticket entity, DocumentHistory transaction); boolean deleteByTicketId(String ticketid); @Override Ticket findByTicketId(String ticketid); @Override boolean deleteByDocId(long docId); void setContextProperties(ContextProperties contextProperties); @Override void deleteExpired(); DocumentDAO getDocumentDAO(); void setDocumentDAO(DocumentDAO documentDAO); }### Answer: @Test public void testStore() throws PersistenceException { Ticket ticket = new Ticket(); ticket.setDocId(1); ticket.setUserId(3); ticket.setTicketId("5"); dao.store(ticket); Ticket storedTicket = dao.findByTicketId("5"); Assert.assertNotNull(storedTicket); Assert.assertEquals(ticket, storedTicket); }
### Question: HibernateSequenceDAO extends HibernatePersistentObjectDAO<Sequence> implements SequenceDAO { @Override public synchronized long next(String sequence, long objectId, long tenantId, long increment) { synchronized (SequenceDAO.class) { Sequence seq = findByAlternateKey(sequence, objectId, tenantId); if (seq == null) { seq = new Sequence(); } seq.setName(sequence); seq.setObjectId(objectId); seq.setTenantId(tenantId); seq.setValue(seq.getValue() + increment); try { store(seq); flush(); } catch (PersistenceException e) { log.error(e.getMessage(), e); } return seq.getValue(); } } private HibernateSequenceDAO(); @Override synchronized void reset(String sequence, long objectId, long tenantId, long value); @Override synchronized long next(String sequence, long objectId, long tenantId, long increment); @Override synchronized long next(String sequence, long objectId, long tenantId); @Override long getCurrentValue(String sequence, long objectId, long tenantId); @Override List<Sequence> findByName(String name, long tenantId); @Override Sequence findByAlternateKey(String name, long objectId, long tenantId); @Override void delete(String name, long objectId, long tenantId); @Override boolean delete(long id, int code); }### Answer: @Test public void testNext() { for (int i = 1; i <= 20; i++) { Assert.assertEquals(i, dao.next("test", 0L, Tenant.DEFAULT_ID)); } for (int i = 1; i <= 20; i++) { Assert.assertEquals(i, dao.next("test2", 0L, Tenant.DEFAULT_ID)); } Assert.assertEquals(25L, dao.next("test2", 0L, Tenant.DEFAULT_ID, 5L)); Assert.assertEquals(23L, dao.next("test2", 0L, Tenant.DEFAULT_ID, -2L)); }
### Question: HibernateSequenceDAO extends HibernatePersistentObjectDAO<Sequence> implements SequenceDAO { @Override public List<Sequence> findByName(String name, long tenantId) { String query = " _entity.tenantId=" + tenantId; query += " and _entity.name like '" + SqlUtil.doubleQuotes(name) + "%' "; try { return findByWhere(query, null, null); } catch (PersistenceException e) { log.error(e.getMessage(), e); return new ArrayList<Sequence>(); } } private HibernateSequenceDAO(); @Override synchronized void reset(String sequence, long objectId, long tenantId, long value); @Override synchronized long next(String sequence, long objectId, long tenantId, long increment); @Override synchronized long next(String sequence, long objectId, long tenantId); @Override long getCurrentValue(String sequence, long objectId, long tenantId); @Override List<Sequence> findByName(String name, long tenantId); @Override Sequence findByAlternateKey(String name, long objectId, long tenantId); @Override void delete(String name, long objectId, long tenantId); @Override boolean delete(long id, int code); }### Answer: @Test public void testFindByName() { Collection<Sequence> sequences = dao.findByName("customid-", Tenant.DEFAULT_ID); Assert.assertNotNull(sequences); Assert.assertEquals(2, sequences.size()); }
### Question: HibernateGroupDAO extends HibernatePersistentObjectDAO<Group> implements GroupDAO { public boolean delete(long groupId, int code) { assert (code != 0); boolean result = true; try { Group group = findById(groupId); refresh(group); if (group.getName().equals("admin") || group.getName().equals("guest") || group.getName().equals("publisher")) throw new Exception(String.format("Group %s cannot be deleted", group.getName())); if (group != null) { group.setName(group.getName() + "." + group.getId()); group.setDeleted(code); saveOrUpdate(group); } } catch (Throwable e) { log.error(e.getMessage(), e); result = false; } return result; } private HibernateGroupDAO(); MenuDAO getMenuDAO(); void setMenuDAO(MenuDAO menuDAO); boolean delete(long groupId, int code); boolean exists(String groupname, long tenantId); @Override Collection<String> findAllGroupNames(long tenantId); @Override Group findByName(String name, long tenantId); @Override boolean insert(Group group, long parentGroupId); @Override void inheritACLs(Group group, long parentGroupId); @Override Collection<Group> findByLikeName(String name, long tenantId); @Override int count(); @Override void initialize(Group group); @Override boolean store(Group group); @Override void fixGuestPermissions(Group group); }### Answer: @Test public void testDelete() throws PersistenceException { Assert.assertNotNull(dao.findById(10)); Assert.assertTrue(dao.delete(10)); Assert.assertNull(dao.findById(10)); Assert.assertFalse(dao.delete(1)); }
### Question: WebConfigurator extends XMLBean { public void addServlet(String name, String clazz) { this.addServlet(name, clazz, -1); } WebConfigurator(String path); void addContextParam(String name, String value, String description, INIT_PARAM append); void addFilterInitParam(String filterName, String param_name, String param_value); void addFilterInitParam(String filterName, String name, String value, String description, INIT_PARAM append); void addInitParam(String servletName, String name, String value, String description, INIT_PARAM append); void addListenerInitParam(String listenerClazz, String name, String value, INIT_PARAM append); void addInitParam(String servletName, String name, String value, String description); void addServlet(String name, String clazz); @SuppressWarnings("unchecked") void addServlet(String name, String clazz, int loadOnStartup); @SuppressWarnings("unchecked") void addFilter(String name, String clazz); @SuppressWarnings("unchecked") void addListener(String clazz); @SuppressWarnings("unchecked") void addServletMapping(String servlet, String pattern); @SuppressWarnings("unchecked") void addFilterMapping(String filter, String pattern); void setDisplayName(String displayName); String getDisplayName(); void setDescription(String description); @SuppressWarnings("rawtypes") boolean setTransportGuarantee(String policy); }### Answer: @Test public void testAddServlet() { WebConfigurator config = new WebConfigurator(webXml.getPath()); config.addServlet("DocumentsData", "pippo"); }
### Question: EgovObjectUtil { public static boolean isNull(Object object) { return ((object == null) || object.equals(null)); } private EgovObjectUtil(); static Class<?> loadClass(String className); static Object instantiate(String className); static Object instantiate(String className, String[] types, Object[] values); static boolean isNull(Object object); }### Answer: @Test public void testIsNull() throws Exception { assertFalse(EgovObjectUtil.isNull(new Object())); assertTrue(EgovObjectUtil.isNull(null)); }
### Question: EgovObjectUtil { public static Class<?> loadClass(String className) throws ClassNotFoundException, Exception { Class<?> clazz = null; try { clazz = Thread.currentThread().getContextClassLoader().loadClass( className); } catch (ClassNotFoundException e) { throw new ClassNotFoundException(); } catch (Exception e) { throw new Exception(e); } if (clazz == null) { clazz = Class.forName(className); } return clazz; } private EgovObjectUtil(); static Class<?> loadClass(String className); static Object instantiate(String className); static Object instantiate(String className, String[] types, Object[] values); static boolean isNull(Object object); }### Answer: @Test public void testLoadClass() throws Exception { String className = "egovframework.rte.fdl.string.EgovStringUtil"; String wrongClassName = "egovframework.rte.fdl.string.EgovStringUtil1"; Class<?> clazz = EgovObjectUtil.loadClass(className); assertNotNull(clazz); clazz = null; assertNull(clazz); Class<Exception> exceptionClass = null; try { clazz = EgovObjectUtil.loadClass(wrongClassName); } catch (Exception e) { log.error("### Exception : " + e.toString()); exceptionClass = (Class<Exception>) e.getClass(); } finally { assertEquals(ClassNotFoundException.class, exceptionClass); assertNotSame(InstantiationException.class, exceptionClass); assertNotSame(IllegalAccessException.class, exceptionClass); } }
### Question: EgovNumericUtil { public static boolean isNumber(String source) { if (EgovStringUtil.isNull(source)) { return false; } try { Double db = new Double(source); if (db.isNaN()) { return false; } else { return true; } } catch (NumberFormatException ex) { return false; } } protected EgovNumericUtil(); static boolean isNumber(String source); static String plus(String thisVal, String addVal); static String plus(String thisVal, String addVal, int scale); static String plus(String thisVal, String addVal, int scale, int roundMode); static String minus(String thisVal, String addVal); static String minus(String thisVal, String addVal, int scale); static String minus(String thisVal, String addVal, int scale, int roundMode); static String multiply(String thisVal, String addVal); static String multiply(String thisVal, String addVal, int scale); static String multiply(String thisVal, String addVal, int scale, int roundMode); static String divide(String thisVal, String addVal); static String divide(String thisVal, String addVal, int roundMode); static String divide(String thisVal, String addVal, int scale, int roundMode); static String setScale(String thisVal, int scale, int roundMode); static final int ROUND_UP; static final int ROUND_DOWN; static final int ROUND_HALF_UP; static final int ROUND_UNNECESSARY; }### Answer: @Test public void testIsNumber() throws Exception { assertFalse(EgovNumericUtil.isNumber("abc")); assertFalse(EgovNumericUtil.isNumber("!@")); assertFalse(EgovNumericUtil.isNumber("ab-123")); assertTrue(EgovNumericUtil.isNumber("-123")); assertTrue(EgovNumericUtil.isNumber("1234")); }
### Question: EgovNumericUtil { public static String setScale(String thisVal, int scale, int roundMode) { BigDecimal one = new BigDecimal(thisVal == null ? "0" : thisVal); return one.setScale(scale, roundMode).toString(); } protected EgovNumericUtil(); static boolean isNumber(String source); static String plus(String thisVal, String addVal); static String plus(String thisVal, String addVal, int scale); static String plus(String thisVal, String addVal, int scale, int roundMode); static String minus(String thisVal, String addVal); static String minus(String thisVal, String addVal, int scale); static String minus(String thisVal, String addVal, int scale, int roundMode); static String multiply(String thisVal, String addVal); static String multiply(String thisVal, String addVal, int scale); static String multiply(String thisVal, String addVal, int scale, int roundMode); static String divide(String thisVal, String addVal); static String divide(String thisVal, String addVal, int roundMode); static String divide(String thisVal, String addVal, int scale, int roundMode); static String setScale(String thisVal, int scale, int roundMode); static final int ROUND_UP; static final int ROUND_DOWN; static final int ROUND_HALF_UP; static final int ROUND_UNNECESSARY; }### Answer: @Test public void testScale() throws Exception { assertEquals("151.754", EgovNumericUtil.setScale("151.7531", 3, EgovNumericUtil.ROUND_UP)); assertEquals("151.753", EgovNumericUtil.setScale("151.7531", 3, EgovNumericUtil.ROUND_DOWN)); assertEquals("151.753", EgovNumericUtil.setScale("151.7531", 3, EgovNumericUtil.ROUND_HALF_UP)); }
### Question: HibernateWebServiceServerDefinitionDao extends HibernateDaoSupport implements WebServiceServerDefinitionDao { public WebServiceServerDefinition getWebServiceServerDefinition( ServiceDefinition serviceDefinition) { LOG.debug("get WebServiceServerDefinition(serviceDefinition = " + serviceDefinition + ")"); WebServiceServerDefinition webServiceServerDefinition = getWebServiceServerDefinition(serviceDefinition.getKey()); LOG.debug("get WebServiceServerDefinition(serviceDefinition = " + serviceDefinition + ") = " + webServiceServerDefinition); return webServiceServerDefinition; } WebServiceServerDefinition getWebServiceServerDefinition( ServiceDefinition serviceDefinition); WebServiceServerDefinition getWebServiceServerDefinition(String key); }### Answer: @Test public void testReadSucceeds() throws Exception { WebServiceServerDefinition wsd = dao.getWebServiceServerDefinition("3"); assertNotNull(wsd); assertTrue(wsd.isValid()); } @Test public void testReadFails() throws Exception { WebServiceServerDefinition wsd = dao.getWebServiceServerDefinition("1"); assertNull(wsd); }
### Question: HibernateWebServiceClientDefinitionDao extends HibernateDaoSupport implements WebServiceClientDefinitionDao { public WebServiceClientDefinition getWebServiceClientDefinition( ServiceDefinition serviceDefinition) { LOG.debug("get WebServiceClientDefinition(serviceDefinition = " + serviceDefinition + ")"); WebServiceClientDefinition webServiceClientDefinition = getWebServiceClientDefinition(serviceDefinition.getKey()); LOG.debug("get WebServiceClientDefinition(serviceDefinition = " + serviceDefinition + ") = " + webServiceClientDefinition); return webServiceClientDefinition; } WebServiceClientDefinition getWebServiceClientDefinition( ServiceDefinition serviceDefinition); WebServiceClientDefinition getWebServiceClientDefinition(String key); }### Answer: @Test public void testReadSucceeds() throws Exception { WebServiceClientDefinition wsd = dao.getWebServiceClientDefinition("4"); assertNotNull(wsd); assertTrue(wsd.isValid()); } @Test public void testReadFails() throws Exception { WebServiceClientDefinition wsd = dao.getWebServiceClientDefinition("1"); assertNull(wsd); }
### Question: EgovWebService extends AbstractService { public EgovIntegrationMessage createRequestMessage() { return new EgovWebServiceMessage(new EgovWebServiceMessageHeader( defaultHeader)); } EgovWebService(String id, long defaultTimeout, IntegrationDefinition integrationDefinition, EgovWebServiceClient client); EgovIntegrationMessage createRequestMessage(); }### Answer: @Test public void testCreateRequestMessageSucceeds() throws Exception { EgovWebService service = new EgovWebService("test", 5000, integrationDefinition, echoClient); EgovIntegrationMessage requestMessage = service.createRequestMessage(); assertNotNull(requestMessage); assertNotNull(requestMessage.getHeader()); EgovIntegrationMessageHeader header = requestMessage.getHeader(); assertEquals(integrationDefinition.getId(), header.getIntegrationId()); assertEquals(providerOrganization.getId(), header.getProviderOrganizationId()); assertEquals(providerSystem.getId(), header.getProviderSystemId()); assertEquals(providerService.getId(), header.getProviderServiceId()); assertEquals(consumerOrganization.getId(), header.getConsumerOrganizationId()); assertEquals(consumerSystem.getId(), header.getConsumerSystemId()); assertNotNull(requestMessage.getBody()); assertEquals(0, requestMessage.getBody().size()); }