private org.exoplatform.calendar.model.Calendar persist( org.exoplatform.calendar.model.Calendar cal, boolean isNew) { Calendar o; if (cal instanceof Calendar) { o = (Calendar) cal; } else { o = Calendar.build(cal); } int type = o.getCalType(); if (type == Calendar.Type.PERSONAL.type()) { try { dataStorage.saveUserCalendar(o.getCalendarOwner(), o, isNew); } catch (Exception ex) { LOG.error(ex); } } else if (type == Calendar.Type.GROUP.type()) { try { dataStorage.savePublicCalendar(o, isNew, null); } catch (Exception ex) { LOG.error(ex); } } else { throw new UnsupportedOperationException( "Save calendar with type '" + type + "' is not supported"); } return cal; }
@GET @Path("join/{spaceName}") public Response join( @PathParam("spaceName") String spaceName, @Context SecurityContext sc, @Context UriInfo uriInfo) { try { String userId = getUserId(sc, uriInfo); if (userId == null) { return Response.status(HTTPStatus.INTERNAL_ERROR).cacheControl(cacheControl).build(); } SpaceService spaceService = (SpaceService) ExoContainerContext.getCurrentContainer() .getComponentInstanceOfType(SpaceService.class); if (spaceService.getSpaceById(spaceName).getRegistration().equals("open")) spaceService.addMember(spaceService.getSpaceById(spaceName), userId); return Response.ok("{}", MediaType.APPLICATION_JSON).cacheControl(cacheControl).build(); } catch (Exception e) { log.error("Error in space deny rest service: " + e.getMessage(), e); return Response.ok("error").cacheControl(cacheControl).build(); } }
/** * delete the event activity * * @param event * @param calendarId * @param eventType */ private void deleteActivity(CalendarEvent event, String calendarId, String eventType) { try { Class.forName("org.exoplatform.social.core.space.spi.SpaceService"); } catch (ClassNotFoundException e) { if (LOG.isDebugEnabled()) { LOG.debug("eXo Social components not found!", e); } return; } if (calendarId == null || calendarId.indexOf(CalendarDataInitialize.SPACE_CALENDAR_ID_SUFFIX) < 0) { return; } try { ActivityManager activityM = (ActivityManager) PortalContainer.getInstance().getComponentInstanceOfType(ActivityManager.class); SpaceService spaceService = (SpaceService) PortalContainer.getInstance().getComponentInstanceOfType(SpaceService.class); String spaceGroupId = Utils.getSpaceGroupIdFromCalendarId(calendarId); Space space = spaceService.getSpaceByGroupId(spaceGroupId); if (space != null && event.getActivityId() != null) { activityM.deleteActivity(event.getActivityId()); } } catch (ExoSocialException e) { if (LOG.isDebugEnabled()) LOG.error("Can not delete Activity for space when event deleted ", e); } }
/** {@inheritDoc} */ public void run() { notifyListeners(); try { repository.getWorkspaceContainer(workspaceName).setState(ManageableRepository.SUSPENDED); List<Backupable> backupableComponents = repository .getWorkspaceContainer(workspaceName) .getComponentInstancesOfType(Backupable.class); // backup all components for (Backupable component : backupableComponents) { component.backup(new File(getStorageURL().getFile())); } } catch (BackupException e) { LOG.error("Full backup failed " + getStorageURL().getPath(), e); notifyError("Full backup failed", e); } catch (RepositoryException e) { LOG.error("Full backup failed " + getStorageURL().getPath(), e); notifyError("Full backup failed", e); } finally { try { repository.getWorkspaceContainer(workspaceName).setState(ManageableRepository.ONLINE); } catch (RepositoryException e) { LOG.error("Full backup failed " + getStorageURL().getPath(), e); notifyError("Full backup failed", e); } } state = FINISHED; notifyListeners(); }
/** * Check existed software registration node * * @return */ private boolean hasSoftwareRegistration() { SessionProvider sessionProvider = null; try { if (hasSoftwareRegisteredNode) { return hasSoftwareRegisteredNode; } else { try { sessionProvider = SessionProvider.createSystemProvider(); Node publicApplicationNode = nodeHierarchyCreator.getPublicApplicationNode(sessionProvider); if (publicApplicationNode.hasNode(SW_NODE_NAME)) { hasSoftwareRegisteredNode = true; } else { hasSoftwareRegisteredNode = false; } } catch (Exception e) { LOG.error("Software Registration: cannot get node", e); hasSoftwareRegisteredNode = false; } finally { sessionProvider.close(); } return hasSoftwareRegisteredNode; } } catch (Exception e) { LOG.error("Software Registration: cannot check node", e); } return hasSoftwareRegisteredNode; }
private void saveToNewDataFormat(ExoSocialActivity activity) { try { final JSONObject jsonObject = new JSONObject(activity.getTitle()); final String docActivityTitle = "<a href=\"${" + UIDocActivity.DOCLINK + "}\">" + "${" + UIDocActivity.DOCNAME + "}</a>"; // activity.setTitle(docActivityTitle); // Map<String, String> activityParams = new HashMap<String, String>(); activityParams.put(UIDocActivity.DOCNAME, jsonObject.getString(UIDocActivity.DOCNAME)); activityParams.put(UIDocActivity.DOCLINK, jsonObject.getString(UIDocActivity.DOCLINK)); activityParams.put(UIDocActivity.DOCPATH, jsonObject.getString(UIDocActivity.DOCPATH)); activityParams.put(UIDocActivity.REPOSITORY, jsonObject.getString(UIDocActivity.REPOSITORY)); activityParams.put(UIDocActivity.WORKSPACE, jsonObject.getString(UIDocActivity.WORKSPACE)); activityParams.put(UIDocActivity.MESSAGE, jsonObject.getString(UIDocActivity.MESSAGE)); activity.setTemplateParams(activityParams); // ActivityManager activityManager = CommonsUtils.getService(ActivityManager.class); // activityManager.saveActivityNoReturn(activity); activity = activityManager.getActivity(activity.getId()); } catch (JSONException je) { LOG.error("Error with activity's title data"); } catch (ActivityStorageException ase) { LOG.error("Could not save new data format for document activity.", ase); } catch (Exception e) { LOG.error("Unknown error to save document activity.", e); } }
/** {@inheritDoc} */ public void start() { configuredTemplates_ = new HashMap<String, Set<String>>(); RepositoryEntry repositoryEntry = null; try { repositoryEntry = repositoryService.getCurrentRepository().getConfiguration(); } catch (RepositoryException e) { if (LOG.isErrorEnabled()) { LOG.error(e.getMessage(), e); } } String repoName = repositoryEntry.getName(); String workspaceName = repositoryEntry.getSystemWorkspaceName(); storedWorkspaces.put(repoName, workspaceName); basedApplicationTemplatesPath = hierarchyCreator.getJcrPath(BasePath.CMS_VIEWTEMPLATES_PATH); SessionProvider sessionProvider = SessionProvider.createSystemProvider(); for (Iterator<String> repositories = storedWorkspaces.keySet().iterator(); repositories.hasNext(); ) { String repository = repositories.next(); try { Node storedTemplateHome = getBasedApplicationTemplatesHome(sessionProvider); importPredefinedTemplateToDB(storedTemplateHome); } catch (Exception e) { if (LOG.isErrorEnabled()) { LOG.error( "Exception when import predefine application template into repository: " + repository, e); } } } sessionProvider.close(); }
/** * Creates an entry in the group. In a case the group does not exist already it will be * automatically created. * * @param entryStream the input stream corresponding to the content of the registry entry * @param groupName the relative path to the group * @request {code} "entryStream" : the input stream corresponding to the content of the registry * entry {code} Example : {code:xml} <registry * xlinks:href="http://localhost:8080/portal/rest/registry/"> <GroovyScript2RestLoader * xlinks:href="http://localhost:8080/portal/rest/registry/exo:services/GroovyScript2RestLoader"/> * <Audit xlinks:href="http://localhost:8080/portal/rest/registry/exo:services/Audit"/> * </registry> {code} @LevelAPI Experimental */ @POST @Path("/{groupName:.+}") @Consumes(MediaType.APPLICATION_XML) public Response createEntry( InputStream entryStream, @PathParam("groupName") String groupName, @Context UriInfo uriInfo) { SessionProvider sessionProvider = sessionProviderService.getSessionProvider(null); try { RegistryEntry entry = RegistryEntry.parse(entryStream); regService.createEntry(sessionProvider, normalizePath(groupName), entry); URI location = uriInfo.getRequestUriBuilder().path(entry.getName()).build(); return Response.created(location).build(); } catch (IllegalArgumentException e) { LOG.error("Create registry entry failed", e); throw new WebApplicationException(e); } catch (IOException e) { LOG.error("Create registry entry failed", e); throw new WebApplicationException(e); } catch (SAXException e) { LOG.error("Create registry entry failed", e); throw new WebApplicationException(e); } catch (ParserConfigurationException e) { LOG.error("Create registry entry failed", e); throw new WebApplicationException(e); } catch (RepositoryException e) { LOG.error("Create registry entry failed", e); throw new WebApplicationException(e); } }
/** * This method will re-observer all nodes that have been ever observed with all repositories. * * @throws Exception */ private void reInitObserver() throws Exception { RepositoryEntry repo = repoService_.getCurrentRepository().getConfiguration(); ManageableRepository repository = repoService_.getCurrentRepository(); String[] workspaceNames = repository.getWorkspaceNames(); for (String workspace : workspaceNames) { Session session = repository.getSystemSession(workspace); QueryManager queryManager = null; try { queryManager = session.getWorkspace().getQueryManager(); } catch (Exception e) { if (LOG.isErrorEnabled()) { LOG.error("Unexpected error", e); } } if (queryManager == null) { session.logout(); continue; } try { Query query = queryManager.createQuery(WATCHABLE_MIXIN_QUERY, Query.XPATH); QueryResult queryResult = query.execute(); for (NodeIterator iter = queryResult.getNodes(); iter.hasNext(); ) { Node observedNode = iter.nextNode(); EmailNotifyListener emailNotifyListener = new EmailNotifyListener(observedNode); ObservationManager manager = session.getWorkspace().getObservationManager(); List<String> list = getDocumentNodeTypes(observedNode); String[] observedNodeTypeNames = list.toArray(new String[list.size()]); manager.addEventListener( emailNotifyListener, Event.PROPERTY_CHANGED, observedNode.getPath(), true, null, observedNodeTypeNames, false); } session.logout(); } catch (Exception e) { if (LOG.isWarnEnabled()) { LOG.warn( "==>>> Cannot init observer for node: " + e.getLocalizedMessage() + " in '" + repo.getName() + "' repository"); } if (LOG.isErrorEnabled()) { LOG.error("Unexpected error", e); } } } }
/** * get user by name in range with sql statement * * @param username */ public User getUserByNameLimtSQL(String username) { username.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY); username = username.trim(); SessionProvider sProvider = SessionProvider.createSystemProvider(); StringBuffer queryString = new StringBuffer("Select * from " + BookNodeTypes.EXO_USER); queryString.append(" where " + BookNodeTypes.EXO_USER_NAME + " = '" + username + "'"); try { QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager(); QueryImpl query = (QueryImpl) queryManager.createQuery(queryString.toString(), Query.SQL); query.setOffset(0L); query.setLimit(3L); QueryResult result = query.execute(); NodeIterator nodes = result.getNodes(); if (nodes.getSize() > 0) { Node node = nodes.nextNode(); return createUserByNode(node); } return null; } catch (RepositoryException re) { log.error("Can not get user by name", re); return null; } finally { sProvider.close(); } }
/** * get user by name with xpath * * @param username * @return */ public User getUserByNameXPath(String username) { username.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY); username = username.trim(); SessionProvider sProvider = SessionProvider.createSystemProvider(); StringBuffer queryString = new StringBuffer( "//element(*, " + BookNodeTypes.EXO_USER + ")[(jcr:like(@" + BookNodeTypes.EXO_USER_NAME + ",'%" + username + "%'" + ") and @" + BookNodeTypes.EXO_USER_ADDRESS + "='Hanoi'" + ")]"); try { QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager(); Query query = queryManager.createQuery(queryString.toString(), Query.XPATH); QueryResult result = query.execute(); NodeIterator nodes = result.getNodes(); if (nodes.getSize() > 0) { Node node = nodes.nextNode(); PropertyReader reader = new PropertyReader(node); return createUserByNode(node); } return null; } catch (RepositoryException re) { log.error("Can not get user by name(XPath)", re); return null; } finally { sProvider.close(); } }
/** * add new user * * @param user * @param nodes * @return * @throws DuplicateBookException */ public Node addUser(User user, List<String> nodes) throws DuplicateBookException { SessionProvider sProvider = SessionProvider.createSystemProvider(); if (isExistUserName(user.getUsername(), sProvider)) { throw new DuplicateBookException(String.format("User %s is existed", user.getUsername())); } user.setUserId(Utils.userId++); try { Node parentNode = getNodeByPath(DEFAULT_PARENT_PATH + DEFAULT_PARENT_USER_PATH, sProvider); Node userNode = parentNode.addNode("" + user.getUserId(), BookNodeTypes.EXO_USER); userNode.setProperty(BookNodeTypes.EXO_USER_NAME, user.getUsername()); userNode.setProperty(BookNodeTypes.EXO_USER_PASSWORD, user.getPassword()); userNode.setProperty(BookNodeTypes.EXO_USER_FULLNAME, user.getFullname()); userNode.setProperty(BookNodeTypes.EXO_USER_ADDRESS, user.getAddress()); userNode.setProperty(BookNodeTypes.EXO_USER_PHONE, user.getPhone()); List<Value> values = new ArrayList<Value>(); for (String string : nodes) { Value val = parentNode.getSession().getValueFactory().createValue(getNodeByPath(string, sProvider)); values.add(val); } userNode.setProperty(BookNodeTypes.EXO_BOOK, values.toArray(new Value[values.size()])); parentNode.getSession().save(); return userNode; } catch (RepositoryException re) { log.error("Failed to add user", re); return null; } finally { sProvider.close(); } }
// ============================================================================ // == public static String generateUUID(Object o) { StringBuffer tmpBuffer = new StringBuffer(16); if (hexServerIP_ == null) { InetAddress localInetAddress = null; try { // get the inet address localInetAddress = InetAddress.getLocalHost(); } catch (java.net.UnknownHostException uhe) { // System .err .println( // "ContentSetUtil: Could not get the local IP address using InetAddress.getLocalHost()!" // ); // todo: find better way to get around this... LOG.error(uhe.getLocalizedMessage(), uhe); return null; } byte serverIP[] = localInetAddress.getAddress(); hexServerIP_ = hexFormat(getInt(serverIP), 8); } String hashcode = hexFormat(System.identityHashCode(o), 8); tmpBuffer.append(hexServerIP_); tmpBuffer.append(hashcode); long timeNow = System.currentTimeMillis(); int timeLow = (int) timeNow & 0xFFFFFFFF; int node = seeder_.nextInt(); StringBuffer guid = new StringBuffer(32); guid.append(hexFormat(timeLow, 8)); guid.append(tmpBuffer.toString()); guid.append(hexFormat(node, 8)); return guid.toString(); }
public void updateFolderAllowed(String path) { UIFormSelectBox sltWorkspace = getChildById(UIDriveInputSet.FIELD_WORKSPACE); String strWorkspace = sltWorkspace.getSelectedValues()[0]; SessionProvider sessionProvider = WCMCoreUtils.getSystemSessionProvider(); try { Session session = sessionProvider.getSession( strWorkspace, getApplicationComponent(RepositoryService.class).getCurrentRepository()); Node rootNode = (Node) session.getItem(path); List<SelectItemOption<String>> foldertypeOptions = new ArrayList<SelectItemOption<String>>(); RequestContext context = RequestContext.getCurrentInstance(); ResourceBundle res = context.getApplicationResourceBundle(); for (String foldertype : setFoldertypes) { if (isChildNodePrimaryTypeAllowed(rootNode, foldertype)) { try { foldertypeOptions.add( new SelectItemOption<String>( res.getString(getId() + ".label." + foldertype.replace(":", "_")), foldertype)); } catch (MissingResourceException mre) { foldertypeOptions.add(new SelectItemOption<String>(foldertype, foldertype)); } } } Collections.sort(foldertypeOptions, new ItemOptionNameComparator()); getUIFormSelectBox(FIELD_ALLOW_CREATE_FOLDERS).setOptions(foldertypeOptions); } catch (Exception e) { if (LOG.isErrorEnabled()) { LOG.error("Unexpected problem occurs while updating", e); } } }
/** * Cleans repository data from database. * * @param rEntry the repository configuration * @throws DBCleanException */ public static void cleanRepositoryData(RepositoryEntry rEntry) throws DBCleanException { SecurityHelper.validateSecurityPermission(JCRRuntimePermissions.MANAGE_REPOSITORY_PERMISSION); WorkspaceEntry wsEntry = rEntry.getWorkspaceEntries().get(0); boolean multiDB = getMultiDbParameter(wsEntry); if (multiDB) { for (WorkspaceEntry entry : rEntry.getWorkspaceEntries()) { cleanWorkspaceData(entry); } } else { Connection jdbcConn = getConnection(wsEntry); String dialect = resolveDialect(jdbcConn, wsEntry); boolean autoCommit = dialect.startsWith(DialectConstants.DB_DIALECT_SYBASE); try { jdbcConn.setAutoCommit(autoCommit); DBCleanerTool dbCleaner = getRepositoryDBCleaner(jdbcConn, rEntry); doClean(dbCleaner); } catch (SQLException e) { throw new DBCleanException(e); } finally { try { jdbcConn.close(); } catch (SQLException e) { LOG.error("Can not close connection", e); } } } }
/** * search book by name with like condition(using SQL) * * @param name The name of book * @return List<Book> */ public List<Book> searchBookByNameLikeSQL(String name) { /* replace "" sign and - sign */ name.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY); /* create query string */ StringBuffer sb = new StringBuffer("Select * from " + BookNodeTypes.EXO_BOOK); sb.append(" where " + BookNodeTypes.EXO_BOOK_NAME + " like '%" + name + "%'"); SessionProvider sProvider = SessionProvider.createSystemProvider(); try { /* create QueryManager from session */ QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager(); /* create Query object */ Query query = queryManager.createQuery(sb.toString(), Query.SQL); /* execute query and return result to QueryResult */ QueryResult result = query.execute(); /* transfer data to NodeIterator */ NodeIterator nodes = result.getNodes(); List<Book> books = new ArrayList<Book>(); while (nodes.hasNext()) { Node node = nodes.nextNode(); books.add(createBookByNode(node)); } return books; } catch (RepositoryException re) { log.error("Can not find book", re); return null; } finally { sProvider.close(); } }
/** {@inheritDoc} */ public void deleteSpace(Space space) { try { // remove memberships of users with deleted space. SpaceUtils.removeMembershipFromGroup(space); spaceStorage.deleteSpace(space.getId()); OrganizationService orgService = getOrgService(); UserACL acl = getUserACL(); GroupHandler groupHandler = orgService.getGroupHandler(); Group deletedGroup = groupHandler.findGroupById(space.getGroupId()); List<String> mandatories = acl.getMandatoryGroups(); if (deletedGroup != null) { if (!isMandatory(groupHandler, deletedGroup, mandatories)) { SpaceUtils.removeGroup(space); } } else { LOG.warn("deletedGroup is null"); } // remove pages and group navigation of space SpaceUtils.removePagesAndGroupNavigation(space); } catch (Exception e) { LOG.error("Unable delete space", e); } spaceLifeCycle.spaceRemoved(space, null); }
public String getEditModeContent() { StringBuilder portletContent = new StringBuilder(); try { PortalRequestContext prcontext = (PortalRequestContext) WebuiRequestContext.getCurrentInstance(); prcontext.ignoreAJAXUpdateOnPortlets(true); StatefulPortletContext portletContext = uiPortlet_.getPortletContext(); ExoPortletInvocationContext portletInvocationContext = new ExoPortletInvocationContext(prcontext, uiPortlet_); List<Cookie> requestCookies = new ArrayList<Cookie>(Arrays.asList(prcontext.getRequest().getCookies())); PortletInvocation portletInvocation = uiPortlet_.create(RenderInvocation.class, prcontext); RenderInvocation renderInvocation = (RenderInvocation) portletInvocation; // make sure we are in the EDIT mode, and not whatever the current portlet mode is for the // Portlet renderInvocation.setMode(Mode.create(PortletMode.EDIT.toString())); PortletInvocationResponse portletResponse = uiPortlet_.invoke(renderInvocation); portletContent.append(uiPortlet_.generateRenderMarkup(portletResponse, prcontext).toString()); } catch (Throwable ex) { WebuiRequestContext webuiRequest = WebuiRequestContext.getCurrentInstance(); portletContent.append( webuiRequest.getApplicationResourceBundle().getString("UIPortlet.message.RuntimeError")); log.error( "The portlet " + uiPortlet_.getName() + " could not be loaded. Check if properly deployed.", ExceptionUtil.getRootCause(ex)); } return portletContent.toString(); }
public static void savePortletPreference( FAQSetting setting, String emailAddNewQuestion, String emailEditResponseQuestion) { try { PortletRequestContext pcontext = (PortletRequestContext) WebuiRequestContext.getCurrentInstance(); PortletPreferences portletPref = pcontext.getRequest().getPreferences(); portletPref.setValue("display", setting.getDisplayMode()); portletPref.setValue("orderBy", setting.getOrderBy()); portletPref.setValue("orderType", setting.getOrderType()); portletPref.setValue("isDiscussForum", String.valueOf(setting.getIsDiscussForum())); portletPref.setValue("idNameCategoryForum", setting.getIdNameCategoryForum()); portletPref.setValue("enableAutomaticRSS", setting.isEnableAutomaticRSS() + ""); portletPref.setValue("enableViewAvatar", setting.isEnableViewAvatar() + ""); portletPref.setValue("enanbleVotesAndComments", setting.isEnanbleVotesAndComments() + ""); portletPref.setValue( "enableAnonymousSubmitQuestion", setting.isEnableAnonymousSubmitQuestion() + ""); portletPref.setValue("SendMailAddNewQuestion", emailAddNewQuestion); portletPref.setValue("SendMailEditResponseQuestion", emailEditResponseQuestion); portletPref.setValue("emailMoveQuestion", setting.getEmailMoveQuestion()); portletPref.setValue( "isPostQuestionInRootCategory", setting.isPostQuestionInRootCategory() + ""); portletPref.store(); } catch (Exception e) { log.error("Fail to save portlet preferences: ", e); } }
protected void executeQuery(final Statement statement, final String sql) throws SQLException { try { long start = 0; if (LOG.isDebugEnabled()) { start = System.currentTimeMillis(); LOG.debug("Execute script: \n[" + sql + "]"); } SecurityHelper.doPrivilegedSQLExceptionAction( new PrivilegedExceptionAction<Object>() { public Object run() throws Exception { statement.executeUpdate(sql); return null; } }); if (LOG.isDebugEnabled()) { LOG.debug( "Script " + sql + " executed in " + ((System.currentTimeMillis() - start) / 1000d) + " sec"); } } catch (SQLException e) { LOG.error("Query execution \"" + sql + "\" failed: " + JDBCUtils.getFullMessage(e), e); throw e; } }
/** * Execute script on database. Set auto commit mode if needed. * * @param scripts the scripts for execution * @throws SQLException */ protected void execute(List<String> scripts) throws SQLException { SecurityHelper.validateSecurityPermission(JCRRuntimePermissions.MANAGE_REPOSITORY_PERMISSION); // set needed auto commit mode boolean autoCommit = connection.getAutoCommit(); if (autoCommit != this.autoCommit) { connection.setAutoCommit(this.autoCommit); } Statement st = connection.createStatement(); try { for (String scr : scripts) { String sql = JDBCUtils.cleanWhitespaces(scr.trim()); if (!sql.isEmpty()) { if (LOG.isDebugEnabled()) { LOG.debug("Execute script: \n[" + sql + "]"); } executeQuery(st, sql); } } } finally { try { st.close(); } catch (SQLException e) { LOG.error("Can't close the Statement." + e.getMessage()); } // restore previous auto commit mode if (autoCommit != this.autoCommit) { connection.setAutoCommit(autoCommit); } } }
/** * get all book in workspace * * @return List<Book> */ public List<Book> getAllBook() { /* create query string */ StringBuffer sb = new StringBuffer("Select * from " + BookNodeTypes.EXO_BOOK); SessionProvider sProvider = SessionProvider.createSystemProvider(); try { /* create QueryManager from session */ QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager(); /* create Query object */ Query query = queryManager.createQuery(sb.toString(), Query.SQL); /* execute query and return result to QueryResult */ QueryResult result = query.execute(); /* transfer data to NodeIterator */ NodeIterator nodes = result.getNodes(); List<Book> books = new ArrayList<Book>(); while (nodes.hasNext()) { Node node = nodes.nextNode(); books.add(createBookByNode(node)); } return books; } catch (RepositoryException re) { log.error("Can not find book", re); return null; } finally { sProvider.close(); } }
/** * search book by name with limit of result(using SQL) * * @param name The name of book * @return List<Book> */ public List<Book> searchBookByNameLimitSQL(String name) { /* replace "" sign and - sign */ name = name.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY); /* create query string */ StringBuffer sb = new StringBuffer("Select * from " + BookNodeTypes.EXO_BOOK); SessionProvider sProvider = SessionProvider.createSystemProvider(); try { /* create QueryManager from session */ QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager(); /* create QueryImpl object */ QueryImpl query = (QueryImpl) queryManager.createQuery(sb.toString(), QueryImpl.SQL); /* set offset(which first record will be get) */ query.setOffset(2); /* set limit(how many record will be get after offset) */ query.setLimit(3); /* execute query and return result to QueryResult */ QueryResult result = query.execute(); /* transfer data to NodeIterator */ NodeIterator nodes = result.getNodes(); List<Book> books = new ArrayList<Book>(); while (nodes.hasNext()) { Node node = nodes.nextNode(); books.add(createBookByNode(node)); } return books; } catch (RepositoryException re) { log.error("Can not find book", re); return null; } finally { sProvider.close(); } }
/** {@inheritDoc} */ @Override public void start() { try { init(); load(); } catch (RepositoryException e) { log.error("Repository error", e); throw new RuntimeException(e); } catch (RepositoryConfigurationException e) { log.error("Configuration error", e); throw new RuntimeException(e); } super.start(); }
@GET @Path("/all/{repoName}") public Response getCategory(@PathParam("repoName") String repoName) { List<CategoryNode> listCategoryNode = new ArrayList<CategoryNode>(); if (repoName == null || repoName.trim().isEmpty()) { return Response.status(HTTPStatus.NOT_FOUND) .entity(new RepositoryException("Can't find repository")) .build(); } // Get all category try { if (documentTypes.isEmpty()) documentTypes = templateService_.getAllDocumentNodeTypes(repoName); List<Node> categoryNodes = taxonomyService_.getAllTaxonomyTrees(repoName); for (Node rootCategoryNode : categoryNodes) { getTaxnomyNodeRescursive(rootCategoryNode, rootCategoryNode, listCategoryNode); } } catch (Exception e) { LOG.error(e); return Response.serverError().build(); } ListResultNode listResultNode = new ListResultNode(); listResultNode.setLstNode(listCategoryNode); return Response.ok(listResultNode, new MediaType("application", "json")).build(); }
public String getHomePageLogoURI() { SessionProvider sProvider = SessionProvider.createSystemProvider(); Node rootNode = null; Node publicApplicationNode = null; String pathImageNode = null; Node ImageNode = null; Session session = null; try { publicApplicationNode = nodeCreator.getPublicApplicationNode(sProvider); session = publicApplicationNode.getSession(); rootNode = session.getRootNode(); Node logosNode = rootNode.getNode(path); if (logosNode.hasNode(logo_name)) { ImageNode = logosNode.getNode(logo_name); pathImageNode = ImageNode.getPath() + "?" + System.currentTimeMillis(); } } catch (Exception e) { LOG.error("Can not get path of Logo : default LOGO will be used" + e.getMessage(), e); return null; } finally { if (session != null) session.logout(); if (sProvider != null) sProvider.close(); } return pathImageNode; }
@Override public void save(NotificationInfo message) throws Exception { boolean created = NotificationSessionManager.createSystemProvider(); SessionProvider sProvider = NotificationSessionManager.getSessionProvider(); final ReentrantLock localLock = lock; try { localLock.lock(); Node messageHomeNode = getOrCreateMessageParent(sProvider, workspace, message.getKey().getId()); Node messageNode = messageHomeNode.addNode(message.getId(), NTF_MESSAGE); messageNode.setProperty(NTF_FROM, message.getFrom()); messageNode.setProperty(NTF_ORDER, message.getOrder()); messageNode.setProperty(NTF_PROVIDER_TYPE, message.getKey().getId()); messageNode.setProperty(NTF_OWNER_PARAMETER, message.getArrayOwnerParameter()); messageNode.setProperty(NTF_SEND_TO_DAILY, message.getSendToDaily()); messageNode.setProperty(NTF_SEND_TO_WEEKLY, message.getSendToWeekly()); messageHomeNode.getSession().save(); // record statistics insert entity if (NotificationContextFactory.getInstance().getStatistics().isStatisticsEnabled()) { NotificationContextFactory.getInstance().getStatisticsCollector().insertEntity(NTF_MESSAGE); } } catch (Exception e) { LOG.error("Failed to save the NotificationMessage", e); } finally { NotificationSessionManager.closeSessionProvider(created); localLock.unlock(); } }
/** * add new book to workspace * * @param book The new book which want to add * @return Book * @throws DuplicateBookException */ public Node addBook(Book book, String nodePath) throws DuplicateBookException { SessionProvider sProvider = SessionProvider.createSystemProvider(); /* Check exist of book */ if (isExistBookName(book.getName(), sProvider)) { throw new DuplicateBookException(String.format("Book %s is existed", book.getName())); } /* get id and set to new book */ book.setBookId(Utils.bookId++); try { /* execute set data to node and save to workspace */ Node parentNode = getNodeByPath(DEFAULT_PARENT_PATH + DEFAULT_PARENT_BOOK_PATH, sProvider); Node bookNode = parentNode.addNode("" + book.getBookId(), BookNodeTypes.EXO_BOOK); bookNode.setProperty(BookNodeTypes.EXO_BOOK_NAME, book.getName()); bookNode.setProperty( BookNodeTypes.EXO_BOOK_CATEGORY, Utils.bookCategoryEnumToString(book.getCategory())); bookNode.setProperty(BookNodeTypes.EXO_BOOK_CONTENT, book.getContent()); bookNode.setProperty(BookNodeTypes.EXO_BOOK_AUTHOR, getNodeByPath(nodePath, sProvider)); parentNode.getSession().save(); return bookNode; } catch (RepositoryException e) { log.error("Failed to add book", e); return null; } finally { sProvider.close(); } }
/** {@inheritDoc} */ public void onEvent(EventIterator eventIterator) { // waiting for Event.PROPERTY_ADDED, Event.PROPERTY_REMOVED, // Event.PROPERTY_CHANGED Session session = null; try { while (eventIterator.hasNext()) { Event event = eventIterator.nextEvent(); String path = event.getPath(); if (path.endsWith("/jcr:data")) { // jcr:data removed 'exo:groovyResourceContainer' then unbind resource if (event.getType() == Event.PROPERTY_REMOVED) { unloadScript(path.substring(0, path.lastIndexOf('/'))); } else if (event.getType() == Event.PROPERTY_ADDED || event.getType() == Event.PROPERTY_CHANGED) { if (session == null) { session = repository.getSystemSession(workspaceName); } Node node = session.getItem(path).getParent(); if (node.getProperty("exo:autoload").getBoolean()) loadScript(node); } } } } catch (Exception e) { LOG.error("Process event failed. ", e); } finally { if (session != null) { session.logout(); } } }
public Book addBook(Book book) throws DuplicateBookException { SessionProvider sProvider = SessionProvider.createSystemProvider(); String nodeId = IdGenerator.generate(); book.setId(nodeId); try { Node parentNode = getNodeByPath(DEFAULT_PARENT_PATH, sProvider); Node bookNode = parentNode.addNode(nodeId, BookNodeTypes.EXO_BOOK); bookNode.setProperty(BookNodeTypes.EXP_BOOK_NAME, book.getName()); bookNode.setProperty( BookNodeTypes.EXP_BOOK_CATEGORY, Utils.bookCategoryEnumToString(book.getCategory())); bookNode.setProperty(BookNodeTypes.EXP_BOOK_CONTENT, book.getContent()); parentNode.getSession().save(); return book; } catch (PathNotFoundException e) { return null; } catch (Exception e) { log.error("Failed to add book", e); return null; } finally { sProvider.close(); } }